@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

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

@@ -1,32 +1,73 @@
-import { buildRuntimeClaimFromRule } from './runtime-claim.js';
-import { RuleRegistryLoadError, loadRuleRegistry } from './runtime-claim-rule-registry.js';
-function buildDefaultVerifyNextCommand(queryText) {
-    const normalizedQuery = String(queryText || '').trim() || 'Reload NEON.Game.Graph.Nodes.Reloads';
-    const escapedQuery = normalizedQuery
+import { extractRuntimeGraphCandidates } from './runtime-chain-graph-candidates.js';
+import { evaluateRuntimeClosure } from './runtime-chain-closure-evaluator.js';
+function hasStructuredVerifierAnchors(input) {
+    const hasValue = (value) => String(value || '').trim().length > 0;
+    if (hasValue(input.resourceSeedPath))
+        return true;
+    if (hasValue(input.symbolName))
+        return true;
+    if (hasValue(input.symbolFilePath))
+        return true;
+    if (Array.isArray(input.mappedSeedTargets) && input.mappedSeedTargets.some((value) => hasValue(value)))
+        return true;
+    if (Array.isArray(input.resourceBindings)
+        && input.resourceBindings.some((binding) => hasValue(binding?.resourcePath)))
+        return true;
+    return false;
+}
+function toGraphOnlyRuntimeChainResult(input) {
+    const nextCommand = buildDefaultVerifyNextCommand({
+        queryText: input.queryText,
+        symbolName: input.symbolName,
+        resourceSeedPath: input.resourceSeedPath,
+    });
+    const closure = evaluateRuntimeClosure({
+        queryText: input.queryText,
+        symbolName: input.symbolName,
+        resourceSeedPath: input.resourceSeedPath,
+        mappedSeedTargets: input.mappedSeedTargets,
+        resourceBindings: input.resourceBindings,
+        candidates: input.candidates,
+        nextCommand,
+    });
+    const hops = input.candidates.slice(0, 20).map((candidate) => ({
+        hop_type: String(candidate.reason || '').startsWith('unity-rule-')
+            || String(candidate.reason || '').toLowerCase().includes('bridge')
+            ? 'code_loader'
+            : 'code_runtime',
+        anchor: `${candidate.sourceFilePath || candidate.sourceName}:${candidate.sourceStartLine || 1}->${candidate.targetFilePath || candidate.targetName}:${candidate.targetStartLine || 1}`,
+        confidence: String(candidate.reason || '').startsWith('unity-rule-') ? 'high' : 'medium',
+        note: String(candidate.reason || '').startsWith('unity-rule-')
+            ? `Synthetic edge observed in graph (${candidate.reason}).`
+            : 'Graph continuity candidate from structured anchors.',
+        snippet: `${candidate.sourceName} -> ${candidate.targetName}`,
+    }));
+    return {
+        status: closure.status,
+        evidence_level: closure.evidence_level,
+        evidence_source: 'query_time',
+        hops,
+        gaps: closure.gaps,
+    };
+}
+function resolveFollowUpSubject(input) {
+    const seedPath = String(input.resourceSeedPath || '').trim();
+    if (seedPath)
+        return seedPath;
+    const symbolName = String(input.symbolName || '').trim();
+    if (symbolName)
+        return symbolName;
+    const queryText = String(input.queryText || '').trim();
+    if (queryText)
+        return queryText;
+    return 'unity-runtime-chain';
+}
+function buildDefaultVerifyNextCommand(input) {
+    const escapedQuery = resolveFollowUpSubject(input)
         .replace(/\\/g, '\\\\')
         .replace(/"/g, '\\"');
     return `node gitnexus/dist/cli/index.js query --unity-resources on --unity-hydration parity --runtime-chain-verify on-demand "${escapedQuery}"`;
 }
-function buildRuntimeMatchHaystack(input) {
-    return [
-        input.queryText,
-        input.resourceSeedPath,
-        input.symbolName,
-        input.symbolFilePath,
-        ...(input.mappedSeedTargets || []),
-        ...(input.resourceBindings || []).map((binding) => binding.resourcePath),
-    ]
-        .filter(Boolean)
-        .join(' ')
-        .toLowerCase();
-}
-function parseTriggerTokens(triggerFamily) {
-    return String(triggerFamily || '')
-        .toLowerCase()
-        .split(/[\s,|/]+/)
-        .map((token) => token.trim())
-        .filter((token) => token.length > 0);
-}
 async function verifyRuleDrivenRuntimeChain(input) {
     const ruleId = input.rule?.id;
     if (!ruleId) {
@@ -71,8 +112,23 @@ async function verifyRuleDrivenRuntimeChain(input) {
     };
 }
 export async function verifyRuntimeChainOnDemand(input) {
-    if (!input.rule)
-        return undefined;
+    if (!input.rule) {
+        if (!hasStructuredVerifierAnchors(input) || !String(input.symbolName || '').trim())
+            return undefined;
+        const candidates = await extractRuntimeGraphCandidates({
+            executeParameterized: input.executeParameterized,
+            symbolName: input.symbolName,
+            symbolFilePath: input.symbolFilePath,
+        });
+        return toGraphOnlyRuntimeChainResult({
+            queryText: input.queryText,
+            symbolName: input.symbolName,
+            resourceSeedPath: input.resourceSeedPath,
+            mappedSeedTargets: input.mappedSeedTargets,
+            resourceBindings: input.resourceBindings,
+            candidates,
+        });
+    }
     return await verifyRuleDrivenRuntimeChain(input);
 }
 function buildFailureRuntimeClaim(input) {
@@ -96,130 +152,85 @@ function buildFailureRuntimeClaim(input) {
         next_action: input.next_action,
     };
 }
-function scoreRuntimeClaimRule(rule, input) {
-    const haystack = buildRuntimeMatchHaystack(input);
-    const tokens = Array.isArray(rule.match?.trigger_tokens) && rule.match.trigger_tokens.length > 0
-        ? rule.match.trigger_tokens
-        : parseTriggerTokens(rule.trigger_family);
-    if (tokens.length === 0)
-        return Number.NEGATIVE_INFINITY;
-    let score = 0;
-    let matchedTrigger = false;
-    for (const token of 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;
-    const boostLists = [
-        ...(Array.isArray(rule.match?.host_base_type) ? [rule.match.host_base_type] : []),
-        ...(Array.isArray(rule.host_base_type) ? [rule.host_base_type] : []),
-    ];
-    for (const list of boostLists) {
-        for (const token of list) {
-            const normalized = String(token || '').trim().toLowerCase();
-            if (normalized && haystack.includes(normalized))
-                score += 20 + normalized.length;
-        }
-    }
-    const resourceLists = [
-        ...(Array.isArray(rule.match?.resource_types) ? [rule.match.resource_types] : []),
-        ...(Array.isArray(rule.resource_types) ? [rule.resource_types] : []),
-    ];
-    for (const list of resourceLists) {
-        for (const token of list) {
-            const normalized = String(token || '').trim().toLowerCase();
-            if (normalized && haystack.includes(normalized))
-                score += 4 + normalized.length;
-        }
-    }
-    for (const token of rule.match?.module_scope || []) {
-        const normalized = String(token || '').trim().toLowerCase();
-        if (normalized && haystack.includes(normalized))
-            score += 8 + normalized.length;
-    }
-    return score;
-}
-export async function verifyRuntimeClaimOnDemand(input) {
-    let registry;
-    try {
-        registry = await loadRuleRegistry(input.repoPath, input.rulesRoot);
-    }
-    catch (error) {
-        if (error instanceof RuleRegistryLoadError) {
-            if (error.code === 'rule_catalog_missing' || error.code === 'rule_file_missing') {
-                return buildFailureRuntimeClaim({
-                    reason: 'rule_not_matched',
-                    next_action: buildDefaultVerifyNextCommand(input.queryText),
-                });
-            }
-        }
-        throw error;
-    }
-    const activeRules = registry.activeRules || [];
-    const fallbackNextAction = buildDefaultVerifyNextCommand(input.queryText);
-    if (activeRules.length === 0) {
-        return buildFailureRuntimeClaim({
-            reason: 'rule_not_matched',
-            next_action: fallbackNextAction,
-        });
-    }
-    const matchedRule = [...activeRules]
-        .map((rule) => ({ rule, score: scoreRuntimeClaimRule(rule, input) }))
-        .filter((entry) => Number.isFinite(entry.score))
-        .sort((a, b) => (b.score - a.score) || a.rule.id.localeCompare(b.rule.id))[0]?.rule;
-    if (!matchedRule) {
-        return buildFailureRuntimeClaim({
-            reason: 'rule_not_matched',
-            next_action: fallbackNextAction,
-        });
-    }
-    const runtimeChain = await verifyRuntimeChainOnDemand({
-        ...input,
-        requiredHops: matchedRule.required_hops,
-        rule: matchedRule,
-    });
-    if (!runtimeChain) {
-        return buildFailureRuntimeClaim({
-            reason: 'rule_matched_but_evidence_missing',
-            next_action: matchedRule.next_action || buildDefaultVerifyNextCommand(input.queryText),
-            rule: matchedRule,
-        });
-    }
-    const normalizedStatus = (runtimeChain.status === 'pending' ? 'failed' : runtimeChain.status);
+function buildGraphOnlyRuntimeClaim(input) {
+    const normalizedStatus = (input.runtimeChain.status === 'pending' ? 'failed' : input.runtimeChain.status);
     const verificationFailed = normalizedStatus === 'failed'
-        || (runtimeChain.evidence_level === 'none' && normalizedStatus !== 'verified_full');
-    const resolved = buildRuntimeClaimFromRule({
-        rule: matchedRule,
+        || (input.runtimeChain.evidence_level === 'none' && normalizedStatus !== 'verified_full');
+    const nextAction = buildDefaultVerifyNextCommand({
+        queryText: input.queryText,
+        symbolName: input.symbolName,
+        resourceSeedPath: input.resourceSeedPath,
+    });
+    const base = {
+        rule_id: 'graph-only.runtime-closure.v1',
+        rule_version: '1.0.0',
+        scope: {
+            resource_types: ['asset', 'prefab', 'unity'],
+            host_base_type: input.symbolName ? [input.symbolName] : [],
+            trigger_family: 'graph_only',
+        },
         status: verificationFailed ? 'failed' : normalizedStatus,
-        evidence_level: runtimeChain.evidence_level,
-        hops: runtimeChain.hops,
-        gaps: runtimeChain.gaps,
+        evidence_level: input.runtimeChain.evidence_level,
+        guarantees: (!verificationFailed && normalizedStatus === 'verified_full')
+            ? ['runtime_chain_graph_closure']
+            : [],
+        non_guarantees: [
+            'no_runtime_execution',
+            'no_dynamic_data_flow_proof',
+            'no_state_transition_proof',
+        ],
+        hops: input.runtimeChain.hops,
+        gaps: input.runtimeChain.gaps,
         ...(verificationFailed
             ? {
                 reason: 'rule_matched_but_verification_failed',
-                next_action: matchedRule.next_action || buildDefaultVerifyNextCommand(input.queryText),
+                next_action: nextAction,
             }
             : {}),
-    });
-    const chainClosed = resolved.status === 'verified_full'
-        && resolved.evidence_level === 'verified_chain'
-        && resolved.gaps.length === 0;
+    };
+    const chainClosed = base.status === 'verified_full'
+        && base.evidence_level === 'verified_chain'
+        && base.gaps.length === 0;
     if (input.minimumEvidenceSatisfied === false && !chainClosed) {
         return {
-            ...resolved,
+            ...base,
             status: 'failed',
             evidence_level: 'clue',
             guarantees: [],
-            non_guarantees: [...resolved.non_guarantees, 'minimum_evidence_contract_not_satisfied'],
+            non_guarantees: [...base.non_guarantees, 'minimum_evidence_contract_not_satisfied'],
             reason: 'rule_matched_but_evidence_missing',
-            next_action: matchedRule.next_action || buildDefaultVerifyNextCommand(input.queryText),
+            next_action: nextAction,
         };
     }
-    return resolved;
+    return base;
+}
+export async function verifyRuntimeClaimOnDemand(input) {
+    const fallbackNextAction = buildDefaultVerifyNextCommand({
+        queryText: input.queryText,
+        symbolName: input.symbolName,
+        resourceSeedPath: input.resourceSeedPath,
+    });
+    if (!hasStructuredVerifierAnchors(input)) {
+        return buildFailureRuntimeClaim({
+            reason: 'rule_not_matched',
+            next_action: fallbackNextAction,
+        });
+    }
+    const graphOnlyRuntimeChain = await verifyRuntimeChainOnDemand({
+        ...input,
+        rule: undefined,
+    });
+    if (graphOnlyRuntimeChain) {
+        return buildGraphOnlyRuntimeClaim({
+            runtimeChain: graphOnlyRuntimeChain,
+            queryText: input.queryText,
+            symbolName: input.symbolName,
+            resourceSeedPath: input.resourceSeedPath,
+            minimumEvidenceSatisfied: input.minimumEvidenceSatisfied,
+        });
+    }
+    return buildFailureRuntimeClaim({
+        reason: 'rule_not_matched',
+        next_action: fallbackNextAction,
+    });
 }

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

@@ -29,18 +29,6 @@ async function fileExists(filePath) {
         return false;
     }
 }
-async function resolveWorkspaceRulesRoot() {
-    const candidates = [
-        path.resolve('.gitnexus/rules'),
-        path.resolve('../.gitnexus/rules'),
-    ];
-    for (const candidate of candidates) {
-        if (await fileExists(path.join(candidate, 'catalog.json'))) {
-            return candidate;
-        }
-    }
-    return candidates[0];
-}
 function makeExecuteParameterized(repoPath) {
     return async (query, params) => {
         const q = String(query || '');
@@ -231,65 +219,109 @@ describe('runtime chain verify', () => {
         expect(out).toBeUndefined();
         await fs.rm(repoPath, { recursive: true, force: true });
     });
-    it('runtime chain gaps are actionable under matched rule execution', async () => {
+    it('runtime chain gaps are actionable under graph-only verification', async () => {
         const out = await verifyRuntimeChainOnDemand({
             repoPath: await fs.mkdtemp(path.join(os.tmpdir(), 'runtime-chain-gaps-')),
             queryText: 'Reload',
+            symbolName: 'ReloadBase',
+            symbolFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs',
             executeParameterized: async () => [],
             resourceBindings: [],
-            rule: {
-                id: 'demo.reload.strict.v2',
-                version: '2.0.0',
-                trigger_family: 'reload',
-                resource_types: ['asset'],
-                host_base_type: ['ReloadBase'],
-                required_hops: ['resource', 'guid_map', 'code_loader', 'code_runtime'],
-                guarantees: ['strict_chain_closed'],
-                non_guarantees: ['strict_no_runtime_execution'],
-                next_action: 'node strict',
-                file_path: '.gitnexus/rules/approved/demo.reload.strict.v2.yaml',
-            },
-            requiredHops: ['resource', 'guid_map', 'code_loader', 'code_runtime'],
         });
         expect(out?.gaps.length).toBeGreaterThan(0);
         expect(out?.gaps.every((gap) => !!gap.next_command)).toBe(true);
     });
-    it('accepts seed-to-mapped resource equivalence for resource hop verification', async () => {
+    it('builds graph-only follow-up command from symbol anchor when query text is missing', async () => {
+        const out = await verifyRuntimeClaimOnDemand({
+            repoPath: await fs.mkdtemp(path.join(os.tmpdir(), 'runtime-chain-anchor-symbol-')),
+            executeParameterized: async () => [],
+            queryText: '',
+            symbolName: 'InitGlobal',
+            symbolFilePath: 'Assets/NEON/Code/Game/Core/GameBootstrap.cs',
+            resourceBindings: [],
+        });
+        expect(out.next_action).toContain('InitGlobal');
+        expect(out.next_action).not.toContain('Reload NEON.Game.Graph.Nodes.Reloads');
+        expect(out.gaps.every((gap) => !gap.next_command.includes('Reload NEON.Game.Graph.Nodes.Reloads'))).toBe(true);
+        expect(out.gaps.every((gap) => gap.next_command.includes('InitGlobal'))).toBe(true);
+    });
+    it('prefers resource seed path in follow-up command subject when seed is present', async () => {
+        const seedPath = 'Assets/NEON/DataAssets/Powerups/Startup/init_global.asset';
+        const out = await verifyRuntimeClaimOnDemand({
+            repoPath: await fs.mkdtemp(path.join(os.tmpdir(), 'runtime-chain-anchor-seed-')),
+            executeParameterized: async () => [],
+            queryText: '',
+            symbolName: 'InitGlobal',
+            symbolFilePath: 'Assets/NEON/Code/Game/Core/GameBootstrap.cs',
+            resourceSeedPath: seedPath,
+            resourceBindings: [],
+        });
+        expect(out.next_action).toContain(seedPath);
+        expect(out.next_action).not.toContain('Reload NEON.Game.Graph.Nodes.Reloads');
+        expect(out.gaps.every((gap) => !gap.next_command.includes('Reload NEON.Game.Graph.Nodes.Reloads'))).toBe(true);
+    });
+    it('accepts seed-to-mapped resource equivalence for bind segment in graph-only verifier', async () => {
         const repoPath = await fs.mkdtemp(path.join(os.tmpdir(), 'runtime-chain-mapped-resource-'));
-        const out = await verifyRuntimeChainOnDemand({
+        const out = await verifyRuntimeClaimOnDemand({
             repoPath,
             queryText: 'EnergyByAttackCount Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/0_初始武器/1_weapon_0_james_new.asset',
+            symbolName: 'EnergyNode',
+            symbolFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyNode.cs',
             resourceSeedPath: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/0_初始武器/1_weapon_0_james_new.asset',
             mappedSeedTargets: ['Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_0_james1.asset'],
-            executeParameterized: async () => [],
             resourceBindings: [{ resourcePath: 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_0_james1.asset' }],
-            rule: {
-                id: 'demo.energy.seed-map.v1',
-                version: '1.0.0',
-                trigger_family: 'energy',
-                resource_types: ['asset'],
-                host_base_type: ['GunGraphNode'],
-                required_hops: ['resource'],
-                guarantees: ['seed_mapped_resource_is_accepted'],
-                non_guarantees: ['does_not_verify_full_runtime_order'],
-                next_action: 'node mapped-resource',
-                file_path: '.gitnexus/rules/approved/demo.energy.seed-map.v1.yaml',
+            executeParameterized: async (query) => {
+                const q = String(query || '');
+                if (q.includes('WHERE n.name IN $symbolNames')) {
+                    return [{
+                            id: 'Class:Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyNode.cs:EnergyNode',
+                            name: 'EnergyNode',
+                            type: 'Class',
+                            filePath: 'Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyNode.cs',
+                            startLine: 1,
+                        }];
+                }
+                if (q.includes("MATCH (s {id: $symbolId})-[r:CodeRelation {type: 'CALLS'}]->(t)")) {
+                    return [{
+                            sourceId: 'Method:Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyNode.cs:Apply',
+                            sourceName: 'Apply',
+                            sourceFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyNode.cs',
+                            sourceStartLine: 22,
+                            targetId: 'Method:Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyRuntime.cs:Run',
+                            targetName: 'Run',
+                            targetFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyRuntime.cs',
+                            targetStartLine: 10,
+                            reason: 'unity-rule-method-bridge:demo.energy.seed-map.v1',
+                        }];
+                }
+                if (q.includes("MATCH (n {id: $symbolId})-[:CodeRelation {type: 'HAS_METHOD'}]->(m)")
+                    && q.includes("MATCH (m)-[r:CodeRelation {type: 'CALLS'}]->(t)")) {
+                    return [{
+                            sourceId: 'Method:Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyNode.cs:Bootstrap',
+                            sourceName: 'Bootstrap',
+                            sourceFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyNode.cs',
+                            sourceStartLine: 8,
+                            targetId: 'Method:Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyNode.cs:Apply',
+                            targetName: 'Apply',
+                            targetFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Energy/EnergyNode.cs',
+                            targetStartLine: 22,
+                            reason: 'static-call',
+                        }];
+                }
+                return [];
             },
-            requiredHops: ['resource'],
         });
-        expect(out?.status).toBe('verified_full');
-        expect(out?.gaps.length).toBe(0);
-        expect(out?.hops[0]?.note || '').toContain('mapped resource equivalence');
+        expect(out.rule_id).toBe('graph-only.runtime-closure.v1');
+        expect(out.status).toBe('verified_full');
+        expect(out.gaps.length).toBe(0);
         await fs.rm(repoPath, { recursive: true, force: true });
     });
     it('phase2 runtime claim returns explicit rule_not_matched', async () => {
-        const workspaceRulesRoot = await resolveWorkspaceRulesRoot();
         const out = await verifyRuntimeClaimOnDemand({
             repoPath: path.resolve('.'),
             queryText: 'CompletelyUnrelatedChain',
             executeParameterized: async () => [],
             resourceBindings: [],
-            rulesRoot: workspaceRulesRoot,
         });
         expect(out.status).toBe('failed');
         expect(out.reason).toBe('rule_not_matched');
@@ -328,33 +360,32 @@ describe('runtime chain verify', () => {
         expect(out.next_action).toBeTruthy();
         await fs.rm(repoPath, { recursive: true, force: true });
     });
-    it('phase2 runtime claim uses bootstrap reload rule metadata', async () => {
+    it('phase2 runtime claim uses graph-only metadata', async () => {
         const repoPath = await makeTempRepo();
-        const workspaceRulesRoot = await resolveWorkspaceRulesRoot();
         const out = await verifyRuntimeClaimOnDemand({
             repoPath,
             queryText: 'Reload NEON.Game.Graph.Nodes.Reloads',
+            symbolName: 'ReloadBase',
+            symbolFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs',
             executeParameterized: makeExecuteParameterized(repoPath),
+            resourceSeedPath: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
             resourceBindings: [{ resourcePath: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset' }],
-            rulesRoot: workspaceRulesRoot,
         });
-        expect(out.rule_id).toBe('unity.gungraph.reload.output-getvalue.v1');
+        expect(out.rule_id).toBe('graph-only.runtime-closure.v1');
         expect(out.rule_version).toBe('1.0.0');
     });
     it('phase2 next_action remains shell-parsable when unmatched', async () => {
-        const workspaceRulesRoot = await resolveWorkspaceRulesRoot();
         const out = await verifyRuntimeClaimOnDemand({
             repoPath: path.resolve('.'),
             queryText: 'CompletelyUnrelatedChain',
             executeParameterized: async () => [],
             resourceBindings: [],
-            rulesRoot: workspaceRulesRoot,
         });
         expect(out.reason).toBe('rule_not_matched');
         expect(typeof out.next_action).toBe('string');
         expect(hasBalancedShellQuotes(String(out.next_action || ''))).toBe(true);
     });
-    it('phase2 runtime claim required_hops are rule-driven', async () => {
+    it('phase2 runtime claim is stable under different rulesRoot values (graph-only)', async () => {
         const repoPath = await makeTempRepo();
         const executeParameterized = makeExecuteParameterized(repoPath);
         const strictExecuteParameterized = async (query, params) => {
@@ -408,6 +439,9 @@ describe('runtime chain verify', () => {
         const strict = await verifyRuntimeClaimOnDemand({
             repoPath,
             queryText: 'Reload NEON.Game.Graph.Nodes.Reloads',
+            symbolName: 'ReloadBase',
+            symbolFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs',
+            resourceSeedPath: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
             executeParameterized: strictExecuteParameterized,
             resourceBindings: [{ resourcePath: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset' }],
             rulesRoot: strictRulesRoot,
@@ -415,15 +449,20 @@ describe('runtime chain verify', () => {
         const relaxed = await verifyRuntimeClaimOnDemand({
             repoPath,
             queryText: 'Reload NEON.Game.Graph.Nodes.Reloads',
+            symbolName: 'ReloadBase',
+            symbolFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs',
+            resourceSeedPath: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
             executeParameterized,
             resourceBindings: [{ resourcePath: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset' }],
             rulesRoot: relaxedRulesRoot,
         });
-        expect(strict.status).toBe('verified_partial');
-        expect(relaxed.status).toBe('verified_full');
+        expect(strict.rule_id).toBe('graph-only.runtime-closure.v1');
+        expect(relaxed.rule_id).toBe('graph-only.runtime-closure.v1');
+        expect(strict.status).toBe(relaxed.status);
+        expect(strict.evidence_level).toBe(relaxed.evidence_level);
         await fs.rm(repoPath, { recursive: true, force: true });
     });
-    it('phase2 runtime claim guarantees/non_guarantees come from matched rule', async () => {
+    it('phase2 runtime claim guarantees/non_guarantees follow graph-only contract', async () => {
         const repoPath = await makeTempRepo();
         const rulesRoot = await writeRules(repoPath, {
             'approved/demo.reload.claim-semantics.v1.yaml': [
@@ -474,17 +513,21 @@ describe('runtime chain verify', () => {
         const out = await verifyRuntimeClaimOnDemand({
             repoPath,
             queryText: 'Reload runtime start sequence',
+            symbolName: 'ReloadBase',
+            symbolFilePath: 'Assets/NEON/Code/Game/Graph/Nodes/Reloads/ReloadBase.cs',
+            resourceSeedPath: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
             executeParameterized: makeExecuteParameterized(repoPath),
             resourceBindings: [{ resourcePath: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset' }],
             rulesRoot,
         });
-        expect(out.rule_id).toBe('demo.reload.claim-semantics.v1');
-        expect(out.rule_version).toBe('2.0.0');
-        expect(out.guarantees).toEqual(['custom_guarantee_from_rule']);
-        expect(out.non_guarantees).toEqual(['custom_non_guarantee_from_rule']);
+        expect(out.rule_id).toBe('graph-only.runtime-closure.v1');
+        expect(out.non_guarantees).toContain('no_runtime_execution');
+        expect(out.non_guarantees).toContain('no_dynamic_data_flow_proof');
+        expect(out.non_guarantees).toContain('no_state_transition_proof');
+        expect(out.non_guarantees).not.toContain('custom_non_guarantee_from_rule');
         await fs.rm(repoPath, { recursive: true, force: true });
     });
-    it('phase2 non-reload trigger family executes rule-driven verifier', async () => {
+    it('phase2 without structured anchors returns rule_not_matched', async () => {
         const repoPath = await makeTempRepo();
         const rulesRoot = await writeRules(repoPath, {
             'approved/demo.startup.v1.yaml': [
@@ -511,10 +554,8 @@ describe('runtime chain verify', () => {
             resourceBindings: [{ resourcePath: 'Assets/Custom/Rules/startup.asset' }],
             rulesRoot,
         });
-        expect(out.rule_id).toBe('demo.startup.v1');
-        expect(out.status).toBe('verified_full');
-        expect(out.evidence_level).toBe('verified_segment');
-        expect(out.reason).toBeUndefined();
+        expect(out.rule_id).toBe('none');
+        expect(out.reason).toBe('rule_not_matched');
         await fs.rm(repoPath, { recursive: true, force: true });
     });
     it('phase2 rule_not_matched does not leak first rule next_action', async () => {
@@ -549,7 +590,7 @@ describe('runtime chain verify', () => {
         expect(String(out.next_action || '')).toContain('Reload runtime start sequence');
         await fs.rm(repoPath, { recursive: true, force: true });
     });
-    it('phase5 rule-lab promoted rule is loadable', async () => {
+    it('phase5 promote artifacts do not alter query-time graph-only rule identity', async () => {
         const repoPath = await fs.mkdtemp(path.join(os.tmpdir(), 'runtime-chain-rule-lab-promote-'));
         const sliceDir = path.join(repoPath, '.gitnexus', 'rules', 'lab', 'runs', 'run-x', 'slices', 'slice-a');
         await fs.mkdir(sliceDir, { recursive: true });
@@ -573,10 +614,27 @@ describe('runtime chain verify', () => {
         const out = await verifyRuntimeClaimOnDemand({
             repoPath,
             queryText: 'Startup Graph Trigger',
-            executeParameterized: async () => [],
+            symbolName: 'StartupNode',
+            symbolFilePath: 'Assets/Rules/StartupNode.cs',
+            resourceSeedPath: 'Assets/Rules/startup.asset',
+            executeParameterized: async (query) => {
+                if (String(query || '').includes('WHERE n.name IN $symbolNames')) {
+                    return [{
+                            id: 'Class:Assets/Rules/StartupNode.cs:StartupNode',
+                            name: 'StartupNode',
+                            type: 'Class',
+                            filePath: 'Assets/Rules/StartupNode.cs',
+                            startLine: 1,
+                        }];
+                }
+                return [];
+            },
             resourceBindings: [{ resourcePath: 'Assets/Rules/startup.asset' }],
         });
-        expect(out.rule_id).toBe('demo.startup.v1');
+        expect(out.rule_id).toBe('graph-only.runtime-closure.v1');
+        expect(out.rule_id).not.toBe('demo.startup.v1');
+        expect(out.status).toBe('verified_partial');
+        expect(out.evidence_level).toBe('verified_segment');
         expect(out.reason).toBeUndefined();
         await fs.rm(repoPath, { recursive: true, force: true });
     });

package/dist/mcp/local/runtime-claim-rule-registry.d.ts

@@ -60,5 +60,9 @@ export declare class RuleRegistryLoadError extends Error {
     constructor(code: RuleRegistryLoadErrorCode, message: string, details?: Record<string, string>);
 }
 export declare function parseRuleYaml(raw: string, filePath: string): RuntimeClaimRule;
+/**
+ * Runtime claim rule registry remains the source for analyze-time synthetic-edge production
+ * and offline governance/report workflows. Query-time runtime closure verification is graph-only.
+ */
 export declare function loadRuleRegistry(repoPath: string, rulesRoot?: string): Promise<RuntimeClaimRuleRegistry>;
 export declare function loadAnalyzeRules(repoPath: string, rulesRoot?: string): Promise<RuntimeClaimRule[]>;

package/dist/mcp/local/runtime-claim-rule-registry.js

@@ -215,6 +215,10 @@ export function parseRuleYaml(raw, filePath) {
         file_path: filePath,
     };
 }
+/**
+ * Runtime claim rule registry remains the source for analyze-time synthetic-edge production
+ * and offline governance/report workflows. Query-time runtime closure verification is graph-only.
+ */
 export async function loadRuleRegistry(repoPath, rulesRoot) {
     const normalizedRepoPath = path.resolve(repoPath);
     const root = rulesRoot