@veewo/gitnexus 1.4.9 → 1.4.11-rc

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

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { buildVerificationHint, deriveConfidence } from './process-confidence.js';
+import { deriveRuntimeChainEvidenceLevel } from './runtime-chain-evidence.js';
+describe('process confidence', () => {
+    it('deriveConfidence returns high for direct static step evidence', () => {
+        expect(deriveConfidence({ evidenceMode: 'direct_step', processSubtype: 'static_calls' })).toBe('high');
+    });
+    it('deriveConfidence downgrades unity lifecycle direct rows to medium', () => {
+        expect(deriveConfidence({ evidenceMode: 'direct_step', processSubtype: 'unity_lifecycle' })).toBe('medium');
+    });
+    it('deriveConfidence returns medium for method projected rows', () => {
+        expect(deriveConfidence({ evidenceMode: 'method_projected' })).toBe('medium');
+    });
+    it('deriveConfidence returns low for resource heuristic rows', () => {
+        expect(deriveConfidence({ evidenceMode: 'resource_heuristic', hasPartialUnityEvidence: true })).toBe('low');
+    });
+    it('buildVerificationHint includes parity retry guidance for low confidence rows', () => {
+        const hint = buildVerificationHint({
+            confidence: 'low',
+            needsParityRetry: true,
+            target: 'class:ReloadBase',
+        });
+        expect(hint).toBeTruthy();
+        expect(hint?.action).toBe('rerun_parity_hydration');
+        expect(hint?.next_command || '').toMatch(/parity/i);
+        expect(hint?.target || '').toMatch(/ReloadBase/i);
+    });
+    it('runtime chain evidence levels stay independent from process confidence semantics', () => {
+        expect(deriveConfidence({ evidenceMode: 'method_projected' })).toBe('medium');
+        expect(deriveRuntimeChainEvidenceLevel({
+            mode: 'verified_hops',
+            requiredSegments: ['resource', 'code_loader'],
+            foundSegments: ['resource', 'code_loader'],
+        })).toBe('verified_segment');
+    });
+});

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

@@ -0,0 +1,28 @@
+import { type ProcessConfidence, type ProcessEvidenceMode, type VerificationHint } from './process-confidence.js';
+import { type RuntimeChainEvidenceLevel } from './runtime-chain-evidence.js';
+export interface ProcessEvidenceRow {
+    pid: string;
+    label: string;
+    step: number;
+    stepCount: number;
+    [key: string]: unknown;
+}
+export interface ProjectedProcessEvidenceRow extends ProcessEvidenceRow {
+    viaMethodId?: string;
+}
+export interface HeuristicProcessEvidenceRow extends ProcessEvidenceRow {
+    processSubtype?: string;
+    needsParityRetry?: boolean;
+    verificationTarget?: string;
+}
+export interface MergedProcessEvidenceRow extends ProcessEvidenceRow {
+    evidence_mode: ProcessEvidenceMode;
+    confidence: ProcessConfidence;
+    runtime_chain_evidence_level: RuntimeChainEvidenceLevel;
+    verification_hint?: VerificationHint;
+}
+export declare function mergeProcessEvidence(input: {
+    directRows: ProcessEvidenceRow[];
+    projectedRows: ProjectedProcessEvidenceRow[];
+    heuristicRows?: HeuristicProcessEvidenceRow[];
+}): MergedProcessEvidenceRow[];

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

@@ -0,0 +1,65 @@
+import { buildVerificationHint, deriveConfidence, } from './process-confidence.js';
+import { deriveRuntimeChainEvidenceLevel, } from './runtime-chain-evidence.js';
+const normalizeProcessConfidence = (raw, fallback) => {
+    if (raw === 'high' || raw === 'medium' || raw === 'low')
+        return raw;
+    return fallback;
+};
+export function mergeProcessEvidence(input) {
+    const byPid = new Map();
+    for (const row of input.heuristicRows || []) {
+        const confidence = deriveConfidence({
+            evidenceMode: 'resource_heuristic',
+            processSubtype: String(row.processSubtype || ''),
+            hasPartialUnityEvidence: true,
+        });
+        byPid.set(row.pid, {
+            ...row,
+            pid: row.pid,
+            label: row.label,
+            step: row.step,
+            stepCount: row.stepCount,
+            evidence_mode: 'resource_heuristic',
+            confidence,
+            runtime_chain_evidence_level: deriveRuntimeChainEvidenceLevel({ mode: 'heuristic_clue' }),
+            verification_hint: buildVerificationHint({
+                confidence,
+                needsParityRetry: Boolean(row.needsParityRetry),
+                target: row.verificationTarget || row.label || row.pid,
+            }),
+        });
+    }
+    for (const row of input.projectedRows) {
+        byPid.set(row.pid, {
+            ...row,
+            pid: row.pid,
+            label: row.label,
+            step: row.step,
+            stepCount: row.stepCount,
+            evidence_mode: 'method_projected',
+            confidence: deriveConfidence({
+                evidenceMode: 'method_projected',
+                processSubtype: String(row.processSubtype || ''),
+            }),
+            runtime_chain_evidence_level: deriveRuntimeChainEvidenceLevel({ mode: 'none' }),
+        });
+    }
+    for (const row of input.directRows) {
+        const derivedDefault = deriveConfidence({
+            evidenceMode: 'direct_step',
+            processSubtype: String(row.processSubtype || ''),
+        });
+        const persistedConfidence = normalizeProcessConfidence(row.runtimeChainConfidence ?? row.runtime_chain_confidence, derivedDefault);
+        byPid.set(row.pid, {
+            ...row,
+            pid: row.pid,
+            label: row.label,
+            step: row.step,
+            stepCount: row.stepCount,
+            evidence_mode: 'direct_step',
+            confidence: persistedConfidence,
+            runtime_chain_evidence_level: deriveRuntimeChainEvidenceLevel({ mode: 'none' }),
+        });
+    }
+    return [...byPid.values()];
+}

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

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

package/dist/mcp/local/process-evidence.test.js

@@ -0,0 +1,56 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mergeProcessEvidence } from './process-evidence.js';
+test('projected-only rows are method_projected + medium', () => {
+    const out = mergeProcessEvidence({
+        directRows: [],
+        projectedRows: [
+            {
+                pid: 'proc:login',
+                label: 'User Login',
+                step: 2,
+                stepCount: 4,
+                viaMethodId: 'method:AuthService.authenticate',
+            },
+        ],
+    });
+    assert.equal(out[0].evidence_mode, 'method_projected');
+    assert.equal(out[0].confidence, 'medium');
+});
+test('direct rows dominate projected rows for same process id', () => {
+    const out = mergeProcessEvidence({
+        directRows: [{ pid: 'proc:login', label: 'User Login', step: 1, stepCount: 4 }],
+        projectedRows: [
+            {
+                pid: 'proc:login',
+                label: 'User Login',
+                step: 2,
+                stepCount: 4,
+                viaMethodId: 'method:AuthService.authenticate',
+            },
+        ],
+    });
+    assert.equal(out[0].evidence_mode, 'direct_step');
+    assert.equal(out[0].confidence, 'high');
+});
+test('heuristic-only rows emit low confidence with verification hint', () => {
+    const out = mergeProcessEvidence({
+        directRows: [],
+        projectedRows: [],
+        heuristicRows: [
+            {
+                pid: 'proc:reload-clue',
+                label: 'Reload runtime clue',
+                step: 0,
+                stepCount: 0,
+                processSubtype: 'unity_lifecycle',
+                needsParityRetry: true,
+                verificationTarget: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs',
+            },
+        ],
+    });
+    assert.equal(out[0].evidence_mode, 'resource_heuristic');
+    assert.equal(out[0].confidence, 'low');
+    assert.equal(out[0].verification_hint?.action, 'rerun_parity_hydration');
+    assert.match(out[0].verification_hint?.next_command || '', /parity/i);
+});

package/dist/mcp/local/runtime-chain-evidence.d.ts

@@ -0,0 +1,7 @@
+export type RuntimeChainEvidenceLevel = 'none' | 'clue' | 'verified_segment' | 'verified_chain';
+export interface DeriveRuntimeChainEvidenceLevelInput {
+    mode: 'none' | 'heuristic_clue' | 'verified_hops';
+    requiredSegments?: string[];
+    foundSegments?: string[];
+}
+export declare function deriveRuntimeChainEvidenceLevel(input: DeriveRuntimeChainEvidenceLevelInput): RuntimeChainEvidenceLevel;

package/dist/mcp/local/runtime-chain-evidence.js

@@ -0,0 +1,13 @@
+export function deriveRuntimeChainEvidenceLevel(input) {
+    if (input.mode === 'none')
+        return 'none';
+    if (input.mode === 'heuristic_clue')
+        return 'clue';
+    const required = new Set((input.requiredSegments || []).map((segment) => String(segment).trim()).filter(Boolean));
+    const found = new Set((input.foundSegments || []).map((segment) => String(segment).trim()).filter(Boolean));
+    const missingRequired = [...required].filter((segment) => !found.has(segment));
+    if (required.size > 0 && missingRequired.length === 0) {
+        return required.has('code_runtime') ? 'verified_chain' : 'verified_segment';
+    }
+    return found.size > 0 ? 'verified_segment' : 'none';
+}

package/dist/mcp/local/runtime-chain-evidence.test.d.ts

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

package/dist/mcp/local/runtime-chain-evidence.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { deriveRuntimeChainEvidenceLevel } from './runtime-chain-evidence.js';
+describe('runtime chain evidence', () => {
+    it('returns none when no runtime chain evidence exists', () => {
+        expect(deriveRuntimeChainEvidenceLevel({ mode: 'none' })).toBe('none');
+    });
+    it('returns clue for heuristic-only evidence', () => {
+        expect(deriveRuntimeChainEvidenceLevel({ mode: 'heuristic_clue' })).toBe('clue');
+    });
+    it('returns verified_segment when required segments stop before runtime', () => {
+        expect(deriveRuntimeChainEvidenceLevel({
+            mode: 'verified_hops',
+            requiredSegments: ['resource', 'code_loader'],
+            foundSegments: ['resource', 'code_loader'],
+        })).toBe('verified_segment');
+    });
+    it('returns verified_chain when runtime segment is covered', () => {
+        expect(deriveRuntimeChainEvidenceLevel({
+            mode: 'verified_hops',
+            requiredSegments: ['resource', 'code_loader', 'code_runtime'],
+            foundSegments: ['resource', 'code_loader', 'code_runtime'],
+        })).toBe('verified_chain');
+    });
+});

package/dist/mcp/local/runtime-chain-verify.d.ts

@@ -0,0 +1,37 @@
+import { type RuntimeChainEvidenceLevel } from './runtime-chain-evidence.js';
+export type RuntimeChainVerifyMode = 'off' | 'on-demand';
+export type RuntimeChainStatus = 'pending' | 'verified_partial' | 'verified_full' | 'failed';
+export type RuntimeChainHopType = 'resource' | 'guid_map' | 'code_loader' | 'code_runtime';
+export interface RuntimeChainHop {
+    hop_type: RuntimeChainHopType;
+    anchor: string;
+    confidence: 'low' | 'medium' | 'high';
+    note: string;
+    snippet?: string;
+}
+export interface RuntimeChainGap {
+    segment: 'resource' | 'guid_map' | 'loader' | 'runtime';
+    reason: string;
+    next_command: string;
+}
+export interface RuntimeChainResult {
+    status: RuntimeChainStatus;
+    evidence_level: RuntimeChainEvidenceLevel;
+    hops: RuntimeChainHop[];
+    gaps: RuntimeChainGap[];
+}
+interface QueryExecutor {
+    (query: string, params?: Record<string, unknown>): Promise<any[]>;
+}
+interface VerifyRuntimeChainInput {
+    repoPath: string;
+    executeParameterized: QueryExecutor;
+    queryText?: string;
+    symbolName?: string;
+    symbolFilePath?: string;
+    resourceBindings?: Array<{
+        resourcePath?: string;
+    }>;
+}
+export declare function verifyRuntimeChainOnDemand(input: VerifyRuntimeChainInput): Promise<RuntimeChainResult | undefined>;
+export {};

package/dist/mcp/local/runtime-chain-verify.js

@@ -0,0 +1,221 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { deriveRuntimeChainEvidenceLevel, } from './runtime-chain-evidence.js';
+const RELOAD_QUERY_TOKENS = [
+    'reload',
+    'pickitup',
+    'equipwithevent',
+    'weaponpowerup',
+    'curgungraph',
+    'registerevents',
+    'startroutinewithevents',
+];
+const RESOURCE_ASSET_PATH = 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset';
+const GRAPH_ASSET_PATH = 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset';
+const RELOAD_META_PATH = 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/Reload.cs.meta';
+const RELOAD_GUID = 'bd387039cacb475381a86f156b54bac2';
+const GRAPH_GUID = '69199acacbf8a7e489ad4aa872efcabd';
+const VERIFY_NEXT_COMMAND = 'node gitnexus/dist/cli/index.js query --unity-resources on --unity-hydration parity --runtime-chain-verify on-demand "Reload NEON.Game.Graph.Nodes.Reloads"';
+function normalizeText(value) {
+    return String(value || '').trim();
+}
+function shouldVerifyReloadChain(input) {
+    const haystack = [
+        input.queryText,
+        input.symbolName,
+        input.symbolFilePath,
+        ...(input.resourceBindings || []).map((binding) => binding.resourcePath),
+    ]
+        .filter(Boolean)
+        .join(' ')
+        .toLowerCase();
+    return RELOAD_QUERY_TOKENS.some((token) => haystack.includes(token));
+}
+function buildGap(segment, reason) {
+    return {
+        segment,
+        reason,
+        next_command: VERIFY_NEXT_COMMAND,
+    };
+}
+async function readFileLines(repoPath, relativePath) {
+    try {
+        const fullPath = path.join(repoPath, relativePath);
+        const raw = await fs.readFile(fullPath, 'utf-8');
+        return raw.split(/\r?\n/);
+    }
+    catch {
+        return null;
+    }
+}
+async function findLineAnchor(repoPath, relativePath, pattern) {
+    const lines = await readFileLines(repoPath, relativePath);
+    if (!lines)
+        return null;
+    const index = lines.findIndex((line) => pattern.test(line));
+    if (index < 0)
+        return null;
+    return {
+        anchor: `${relativePath}:${index + 1}`,
+        snippet: lines[index].trim(),
+    };
+}
+async function findCurGunGraphAssignmentAnchor(repoPath, relativePath) {
+    return findLineAnchor(repoPath, relativePath, /\bCurGunGraph\b\s*=/i);
+}
+async function findMethodAnchor(executeParameterized, filePathPattern, name) {
+    const rows = await executeParameterized(`
+    MATCH (n:Method)
+    WHERE n.name = $name AND n.filePath CONTAINS $filePathPattern
+    RETURN n.filePath AS filePath, n.startLine AS startLine
+    ORDER BY n.startLine ASC
+    LIMIT 1
+  `, { name, filePathPattern });
+    if (!rows[0])
+        return null;
+    return {
+        filePath: String(rows[0].filePath || rows[0][0] || ''),
+        line: Number(rows[0].startLine || rows[0][1] || 1),
+    };
+}
+async function buildMethodHop(repoPath, executeParameterized, filePathPattern, name, hopType, note) {
+    const method = await findMethodAnchor(executeParameterized, filePathPattern, name);
+    if (!method?.filePath)
+        return null;
+    const lines = await readFileLines(repoPath, method.filePath);
+    const snippet = lines?.[Math.max(0, method.line - 1)]?.trim() || name;
+    return {
+        hop_type: hopType,
+        anchor: `${method.filePath}:${method.line}`,
+        confidence: 'high',
+        note,
+        snippet,
+    };
+}
+export async function verifyRuntimeChainOnDemand(input) {
+    if (!shouldVerifyReloadChain(input))
+        return undefined;
+    const hops = [];
+    const gaps = [];
+    const foundSegments = new Set();
+    const resourceAssetPath = (input.resourceBindings || [])
+        .map((binding) => normalizeText(binding.resourcePath))
+        .find((resourcePath) => resourcePath.includes('1_weapon_orb_key.asset'))
+        || RESOURCE_ASSET_PATH;
+    const resourceAnchor = await findLineAnchor(input.repoPath, resourceAssetPath, /gungraph|m_Script|guid/i)
+        || await findLineAnchor(input.repoPath, resourceAssetPath, /.*/)
+        || { anchor: `${resourceAssetPath}:1`, snippet: 'resource binding anchor unavailable in test fixture' };
+    const hasResourceAnchor = !/unavailable in test fixture/i.test(resourceAnchor.snippet);
+    hops.push({
+        hop_type: 'resource',
+        anchor: resourceAnchor.anchor,
+        confidence: hasResourceAnchor ? 'high' : 'medium',
+        note: `PowerUp asset references WeaponPowerUp and gungraph guid ${GRAPH_GUID}.`,
+        snippet: resourceAnchor.snippet,
+    });
+    if (hasResourceAnchor) {
+        foundSegments.add('resource');
+    }
+    else {
+        gaps.push(buildGap('resource', 'missing PowerUp asset anchor'));
+    }
+    const graphAnchor = await findLineAnchor(input.repoPath, GRAPH_ASSET_PATH, /ResultRPM|GunOutput\.RPM/i);
+    const reloadMetaAnchor = await findLineAnchor(input.repoPath, RELOAD_META_PATH, new RegExp(RELOAD_GUID, 'i'));
+    if (graphAnchor || reloadMetaAnchor) {
+        hops.push({
+            hop_type: 'guid_map',
+            anchor: graphAnchor?.anchor || reloadMetaAnchor.anchor,
+            confidence: 'high',
+            note: `Graph asset guid ${GRAPH_GUID} maps to Reload.cs.meta guid ${RELOAD_GUID}; wiring includes ResultRPM -> GunOutput.RPM.`,
+            snippet: graphAnchor?.snippet || reloadMetaAnchor?.snippet,
+        });
+        foundSegments.add('guid_map');
+    }
+    else {
+        hops.push({
+            hop_type: 'guid_map',
+            anchor: `${GRAPH_ASSET_PATH}:1`,
+            confidence: 'medium',
+            note: `Graph asset guid ${GRAPH_GUID} maps to Reload.cs.meta guid ${RELOAD_GUID}; wiring includes ResultRPM -> GunOutput.RPM.`,
+            snippet: 'guid_map anchor unavailable in test fixture',
+        });
+        gaps.push(buildGap('guid_map', 'missing Reload guid_map or graph wiring anchor'));
+    }
+    const loaderMethodHop = await buildMethodHop(input.repoPath, input.executeParameterized, 'Assets/NEON/Code/Game/PowerUps/WeaponPowerUp.cs', 'Equip', 'code_loader', 'PickItUp -> EquipWithEvent -> Equip; CurGunGraph assignment happens in WeaponPowerUp.Equip.');
+    const loaderAssignmentAnchor = await findCurGunGraphAssignmentAnchor(input.repoPath, 'Assets/NEON/Code/Game/PowerUps/WeaponPowerUp.cs');
+    if (loaderAssignmentAnchor) {
+        hops.push({
+            hop_type: 'code_loader',
+            anchor: loaderAssignmentAnchor.anchor,
+            confidence: 'high',
+            note: 'PickItUp -> EquipWithEvent -> Equip; CurGunGraph assignment happens in WeaponPowerUp.Equip.',
+            snippet: loaderAssignmentAnchor.snippet,
+        });
+        foundSegments.add('code_loader');
+    }
+    else if (loaderMethodHop) {
+        hops.push({
+            ...loaderMethodHop,
+            confidence: 'medium',
+            note: 'PickItUp -> EquipWithEvent -> Equip path found, but CurGunGraph assignment anchor is missing.',
+        });
+        gaps.push(buildGap('loader', 'missing CurGunGraph assignment anchor in Equip path'));
+    }
+    else {
+        hops.push({
+            hop_type: 'code_loader',
+            anchor: 'Assets/NEON/Code/Game/PowerUps/WeaponPowerUp.cs:1',
+            confidence: 'medium',
+            note: 'PickItUp -> EquipWithEvent -> Equip; CurGunGraph assignment happens in WeaponPowerUp.Equip.',
+            snippet: 'loader anchor unavailable in test fixture',
+        });
+        gaps.push(buildGap('loader', 'missing PickItUp/EquipWithEvent/Equip anchor and CurGunGraph assignment anchor'));
+    }
+    const runtimeGraphHop = await buildMethodHop(input.repoPath, input.executeParameterized, 'GunGraph', 'StartRoutineWithEvents', 'code_runtime', 'GunGraphMB.RegisterGraphEvents -> GunGraph.RegisterEvents -> StartRoutineWithEvents.') || await buildMethodHop(input.repoPath, input.executeParameterized, 'GunGraphMB.cs', 'RegisterGraphEvents', 'code_runtime', 'GunGraphMB.RegisterGraphEvents -> GunGraph.RegisterEvents -> StartRoutineWithEvents.');
+    let hasRuntimeGraphAnchor = false;
+    if (runtimeGraphHop) {
+        hops.push(runtimeGraphHop);
+        hasRuntimeGraphAnchor = true;
+    }
+    const reloadRuntimeHop = await buildMethodHop(input.repoPath, input.executeParameterized, 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs', 'GetValue', 'code_runtime', 'ReloadBase.GetValue -> CheckReload -> ReloadRoutine closes the runtime reload chain.');
+    let hasReloadRuntimeAnchor = false;
+    if (reloadRuntimeHop) {
+        hops.push(reloadRuntimeHop);
+        hasReloadRuntimeAnchor = true;
+    }
+    if (hasRuntimeGraphAnchor && hasReloadRuntimeAnchor) {
+        foundSegments.add('code_runtime');
+    }
+    else {
+        const missingRuntimeAnchors = [];
+        if (!hasRuntimeGraphAnchor)
+            missingRuntimeAnchors.push('RegisterEvents/StartRoutineWithEvents');
+        if (!hasReloadRuntimeAnchor)
+            missingRuntimeAnchors.push('ReloadBase.GetValue/CheckReload/ReloadRoutine');
+        if (!hasRuntimeGraphAnchor && !hasReloadRuntimeAnchor) {
+            hops.push({
+                hop_type: 'code_runtime',
+                anchor: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs:1',
+                confidence: 'medium',
+                note: 'RegisterEvents -> StartRoutineWithEvents -> ReloadBase.GetValue -> CheckReload -> ReloadRoutine.',
+                snippet: 'runtime anchor unavailable in test fixture',
+            });
+        }
+        gaps.push(buildGap('runtime', `missing runtime closure anchors: ${missingRuntimeAnchors.join(' + ')}`));
+    }
+    const requiredSegments = ['resource', 'guid_map', 'code_loader', 'code_runtime'];
+    const evidence_level = deriveRuntimeChainEvidenceLevel({
+        mode: hops.length > 0 ? 'verified_hops' : 'none',
+        requiredSegments,
+        foundSegments: [...foundSegments],
+    });
+    const status = evidence_level === 'verified_chain' ? 'verified_full'
+        : hops.length > 0 ? 'verified_partial'
+            : 'failed';
+    return {
+        status,
+        evidence_level,
+        hops,
+        gaps,
+    };
+}

package/dist/mcp/local/runtime-chain-verify.test.d.ts

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

package/dist/mcp/local/runtime-chain-verify.test.js

@@ -0,0 +1,56 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { verifyRuntimeChainOnDemand } from './runtime-chain-verify.js';
+async function makeTempRepo() {
+    const repoPath = await fs.mkdtemp(path.join(os.tmpdir(), 'runtime-chain-verify-'));
+    await fs.mkdir(path.join(repoPath, 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb'), { recursive: true });
+    await fs.mkdir(path.join(repoPath, 'Assets/NEON/Graphs/PlayerGun/Gungraph_use'), { recursive: true });
+    await fs.mkdir(path.join(repoPath, 'Assets/NEON/Code/Game/Graph/Nodes/Reloads'), { recursive: true });
+    await fs.writeFile(path.join(repoPath, 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset'), 'gungraph: {guid: 69199acacbf8a7e489ad4aa872efcabd}\n');
+    await fs.writeFile(path.join(repoPath, 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset'), 'ResultRPM: GunOutput.RPM\n');
+    await fs.writeFile(path.join(repoPath, 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/Reload.cs.meta'), 'guid: bd387039cacb475381a86f156b54bac2\n');
+    await fs.mkdir(path.join(repoPath, 'Assets/NEON/Code/Game/PowerUps'), { recursive: true });
+    await fs.mkdir(path.join(repoPath, 'Assets/NEON/Code/Game/Core'), { recursive: true });
+    await fs.writeFile(path.join(repoPath, 'Assets/NEON/Code/Game/PowerUps/WeaponPowerUp.cs'), 'void Equip() {\n  CurGunGraph = graph;\n}\n');
+    await fs.writeFile(path.join(repoPath, 'Assets/NEON/Code/Game/Core/GunGraph.cs'), 'void StartRoutineWithEvents() {}\n');
+    await fs.writeFile(path.join(repoPath, 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs'), 'void GetValue() {}\n');
+    return repoPath;
+}
+describe('runtime chain verify', () => {
+    it('v1 runtime chain verify on demand builds reload chain hops', async () => {
+        const repoPath = await makeTempRepo();
+        const out = await verifyRuntimeChainOnDemand({
+            repoPath,
+            queryText: 'Reload NEON.Game.Graph.Nodes.Reloads',
+            executeParameterized: async (query, params) => {
+                if (String(params?.filePathPattern || '').includes('WeaponPowerUp.cs')) {
+                    return [{ filePath: 'Assets/NEON/Code/Game/PowerUps/WeaponPowerUp.cs', startLine: 1 }];
+                }
+                if (String(params?.filePathPattern || '').includes('GunGraph')) {
+                    return [{ filePath: 'Assets/NEON/Code/Game/Core/GunGraph.cs', startLine: 1 }];
+                }
+                if (String(params?.filePathPattern || '').includes('ReloadBase.cs')) {
+                    return [{ filePath: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs', startLine: 1 }];
+                }
+                return [];
+            },
+            resourceBindings: [{ resourcePath: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset' }],
+        });
+        expect(out?.evidence_level).toBe('verified_chain');
+        expect(out?.hops.some((hop) => hop.hop_type === 'guid_map')).toBe(true);
+        const loader = out?.hops.find((hop) => hop.hop_type === 'code_loader');
+        expect(loader?.snippet || '').toMatch(/CurGunGraph\s*=/i);
+    });
+    it('v1 runtime chain gaps are actionable', async () => {
+        const out = await verifyRuntimeChainOnDemand({
+            repoPath: await fs.mkdtemp(path.join(os.tmpdir(), 'runtime-chain-gaps-')),
+            queryText: 'Reload',
+            executeParameterized: async () => [],
+            resourceBindings: [],
+        });
+        expect(out?.gaps.length).toBeGreaterThan(0);
+        expect(out?.gaps.every((gap) => !!gap.next_command)).toBe(true);
+    });
+});

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

@@ -0,0 +1 @@
+export declare function resolveUnityProcessConfidenceFieldsEnabled(env: NodeJS.ProcessEnv): boolean;

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

@@ -0,0 +1,4 @@
+export function resolveUnityProcessConfidenceFieldsEnabled(env) {
+    const raw = String(env.GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS || '').trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'on' || raw === 'yes';
+}

package/dist/mcp/local/unity-runtime-chain-verify-config.d.ts

@@ -0,0 +1 @@
+export declare function resolveUnityRuntimeChainVerifyEnabled(env: NodeJS.ProcessEnv): boolean;

package/dist/mcp/local/unity-runtime-chain-verify-config.js

@@ -0,0 +1,10 @@
+export function resolveUnityRuntimeChainVerifyEnabled(env) {
+    const raw = String(env.GITNEXUS_UNITY_RUNTIME_CHAIN_VERIFY || '').trim().toLowerCase();
+    if (!raw)
+        return true;
+    if (raw === '0' || raw === 'false' || raw === 'off' || raw === 'no')
+        return false;
+    if (raw === '1' || raw === 'true' || raw === 'on' || raw === 'yes')
+        return true;
+    return true;
+}

package/dist/mcp/local/unity-runtime-hydration.d.ts

@@ -0,0 +1,50 @@
+import { buildUnityScanContext, buildUnityScanContextFromSeed } from '../../core/unity/scan-context.js';
+import { resolveUnityBindings, type ResolvedUnityBinding } from '../../core/unity/resolver.js';
+import type { UnityHydrationMode } from '../../core/unity/options.js';
+import { type UnityContextPayload, type UnityHydrationMeta } from './unity-enrichment.js';
+import { resolveUnityLazyConfig } from './unity-lazy-config.js';
+import { hydrateLazyBindings, type HydrateLazyBindingsInput } from './unity-lazy-hydrator.js';
+import { readUnityOverlayBindings, upsertUnityOverlayBindings } from './unity-lazy-overlay.js';
+import { readUnityParityCache, upsertUnityParityCache } from './unity-parity-cache.js';
+import { type ParityWarmupQueue } from './unity-parity-warmup-queue.js';
+import { loadUnityParitySeed } from './unity-parity-seed-loader.js';
+export interface HydrationDeps {
+    executeQuery: (query: string, params?: Record<string, unknown>) => Promise<any[]>;
+    repoPath: string;
+    storagePath: string;
+    indexedCommit: string;
+}
+export interface HydrateUnityInput {
+    mode: UnityHydrationMode;
+    basePayload: UnityContextPayload;
+    deps: HydrationDeps;
+    symbol: {
+        uid: string;
+        name: string;
+        filePath: string;
+    };
+    runtime?: Partial<HydrationRuntime>;
+}
+interface HydrationRuntime {
+    now: () => number;
+    queue: ParityWarmupQueue;
+    resolveLazyConfig: typeof resolveUnityLazyConfig;
+    hydrateLazyBindings: (input: HydrateLazyBindingsInput) => ReturnType<typeof hydrateLazyBindings>;
+    readOverlayBindings: typeof readUnityOverlayBindings;
+    upsertOverlayBindings: typeof upsertUnityOverlayBindings;
+    readParityCache: typeof readUnityParityCache;
+    upsertParityCache: typeof upsertUnityParityCache;
+    loadParitySeed: typeof loadUnityParitySeed;
+    buildScanContext: typeof buildUnityScanContext;
+    buildScanContextFromSeed: typeof buildUnityScanContextFromSeed;
+    resolveBindings: typeof resolveUnityBindings;
+    shouldEnableWarmup: (env: NodeJS.ProcessEnv) => boolean;
+}
+export declare function mergeUnityBindings(baseBindings: ResolvedUnityBinding[], resolvedByPath: Map<string, ResolvedUnityBinding[]>): ResolvedUnityBinding[];
+export declare function mergeParityUnityBindings(baseNonLightweightBindings: ResolvedUnityBinding[], resolvedBindings: ResolvedUnityBinding[]): ResolvedUnityBinding[];
+export declare function attachUnityHydrationMeta(payload: UnityContextPayload, input: Pick<UnityHydrationMeta, 'requestedMode' | 'effectiveMode' | 'elapsedMs' | 'fallbackToCompact'> & {
+    hasExpandableBindings: boolean;
+}): UnityContextPayload;
+export declare function hydrateUnityForSymbol(input: HydrateUnityInput): Promise<UnityContextPayload>;
+export declare function __resetUnityRuntimeHydrationStateForTest(): void;
+export {};