@veewo/gitnexus 1.4.11-rc → 1.5.0-rc

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

@@ -39,7 +39,7 @@ test('summary-only rows hydrate and merge into full bindings with preserved fiel
             .map((binding) => binding.resourcePath))];
     const hydration = await hydrateLazyBindings({
         pendingPaths,
-        config: { maxPendingPathsPerRequest: 10, batchSize: 10, maxHydrationMs: 5000 },
+        config: { lazyMaxPaths: 10, lazyBatchSize: 10, lazyMaxMs: 5000 },
         resolveBatch: async () => new Map([
             ['Assets/Doors/Door.prefab', [
                     {

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

@@ -18,7 +18,7 @@ export function buildVerificationHint(input) {
         return {
             action: 'rerun_parity_hydration',
             target,
-            next_command: 'GITNEXUS_UNITY_PROCESS_CONFIDENCE_FIELDS=on gitnexus query --unity-resources on --unity-hydration parity "<symbol-or-query>"',
+            next_command: 'gitnexus query --unity-resources on --unity-hydration parity "<symbol-or-query>"',
         };
     }
     return {

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

@@ -21,6 +21,7 @@ export interface MergedProcessEvidenceRow extends ProcessEvidenceRow {
     runtime_chain_evidence_level: RuntimeChainEvidenceLevel;
     verification_hint?: VerificationHint;
 }
+export declare function deriveEvidenceFingerprint(...parts: unknown[]): string;
 export declare function mergeProcessEvidence(input: {
     directRows: ProcessEvidenceRow[];
     projectedRows: ProjectedProcessEvidenceRow[];

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

@@ -1,5 +1,27 @@
 import { buildVerificationHint, deriveConfidence, } from './process-confidence.js';
 import { deriveRuntimeChainEvidenceLevel, } from './runtime-chain-evidence.js';
+function asFingerprintToken(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => asFingerprintToken(item)).join(',');
+    }
+    const obj = value;
+    const ordered = {};
+    for (const key of Object.keys(obj).sort()) {
+        ordered[key] = obj[key];
+    }
+    return JSON.stringify(ordered);
+}
+export function deriveEvidenceFingerprint(...parts) {
+    return parts
+        .map((part) => asFingerprintToken(part))
+        .filter((token) => token.length > 0)
+        .join('::');
+}
 const normalizeProcessConfidence = (raw, fallback) => {
     if (raw === 'high' || raw === 'medium' || raw === 'low')
         return raw;

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

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mergeProcessEvidence } from './process-evidence.js';
+import { deriveEvidenceFingerprint, mergeProcessEvidence } from './process-evidence.js';
 test('projected-only rows are method_projected + medium', () => {
     const out = mergeProcessEvidence({
         directRows: [],
@@ -54,3 +54,13 @@ test('heuristic-only rows emit low confidence with verification hint', () => {
     assert.equal(out[0].verification_hint?.action, 'rerun_parity_hydration');
     assert.match(out[0].verification_hint?.next_command || '', /parity/i);
 });
+test('deriveEvidenceFingerprint is stable for same input ordering', () => {
+    const left = deriveEvidenceFingerprint({ resourcePath: 'Assets/A.prefab', bindingKind: 'component', line: 10 }, { pid: 'proc:123', step: 1 });
+    const right = deriveEvidenceFingerprint({ line: 10, bindingKind: 'component', resourcePath: 'Assets/A.prefab' }, { step: 1, pid: 'proc:123' });
+    assert.equal(left, right);
+});
+test('deriveEvidenceFingerprint changes when signal changes', () => {
+    const left = deriveEvidenceFingerprint({ resourcePath: 'Assets/A.prefab', line: 10 });
+    const right = deriveEvidenceFingerprint({ resourcePath: 'Assets/A.prefab', line: 11 });
+    assert.notEqual(left, right);
+});

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

@@ -0,0 +1,24 @@
+export type ProcessRefKind = 'persistent' | 'derived';
+export type ProcessRefOrigin = 'step_in_process' | 'method_projected' | 'resource_heuristic';
+export interface ProcessRef {
+    id: string;
+    kind: ProcessRefKind;
+    readable: boolean;
+    reader_uri: string;
+    origin: ProcessRefOrigin;
+}
+export interface BuildDerivedProcessIdInput {
+    indexedCommit: string;
+    symbolUid: string;
+    evidenceFingerprint: string;
+}
+export declare function buildDerivedProcessId(input: BuildDerivedProcessIdInput): string;
+export interface BuildProcessRefInput {
+    repoName: string;
+    processId?: string;
+    origin: ProcessRefOrigin;
+    indexedCommit: string;
+    symbolUid: string;
+    evidenceFingerprint: string;
+}
+export declare function buildProcessRef(input: BuildProcessRefInput): ProcessRef;

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

@@ -0,0 +1,33 @@
+import { createHash } from 'node:crypto';
+export function buildDerivedProcessId(input) {
+    const key = `${input.indexedCommit}::${input.symbolUid}::${input.evidenceFingerprint}`;
+    const hash = createHash('sha1').update(key).digest('hex').slice(0, 16);
+    return `derived:${hash}`;
+}
+function isPersistentProcessId(processId) {
+    return processId.length > 0 && !processId.startsWith('proc:heuristic:');
+}
+export function buildProcessRef(input) {
+    const processId = String(input.processId || '').trim();
+    if (isPersistentProcessId(processId)) {
+        return {
+            id: processId,
+            kind: 'persistent',
+            readable: true,
+            reader_uri: `gitnexus://repo/${encodeURIComponent(input.repoName)}/process/${encodeURIComponent(processId)}`,
+            origin: input.origin,
+        };
+    }
+    const id = buildDerivedProcessId({
+        indexedCommit: input.indexedCommit,
+        symbolUid: input.symbolUid,
+        evidenceFingerprint: input.evidenceFingerprint,
+    });
+    return {
+        id,
+        kind: 'derived',
+        readable: true,
+        reader_uri: `gitnexus://repo/${encodeURIComponent(input.repoName)}/derived-process/${encodeURIComponent(id)}`,
+        origin: input.origin,
+    };
+}

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

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

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

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildDerivedProcessId } from './process-ref.js';
+test('buildDerivedProcessId is stable for identical fingerprint input', () => {
+    const left = buildDerivedProcessId({
+        indexedCommit: 'abc',
+        symbolUid: 'Class:Assets/A.cs:A',
+        evidenceFingerprint: 'resource=Assets/A.prefab;line=10',
+    });
+    const right = buildDerivedProcessId({
+        indexedCommit: 'abc',
+        symbolUid: 'Class:Assets/A.cs:A',
+        evidenceFingerprint: 'resource=Assets/A.prefab;line=10',
+    });
+    assert.equal(left, right);
+});
+test('buildDerivedProcessId does not leak heuristic process id prefix', () => {
+    const id = buildDerivedProcessId({
+        indexedCommit: 'abc',
+        symbolUid: 'Class:Assets/A.cs:A',
+        evidenceFingerprint: 'resource=Assets/A.prefab;line=11',
+    });
+    assert.doesNotMatch(id, /^proc:heuristic:/);
+});

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

@@ -1,4 +1,6 @@
-import { type RuntimeChainEvidenceLevel } from './runtime-chain-evidence.js';
+import type { RuntimeChainEvidenceLevel } from './runtime-chain-evidence.js';
+import { type RuntimeClaim } from './runtime-claim.js';
+import { type RuntimeClaimRule } from './runtime-claim-rule-registry.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';
@@ -13,12 +15,15 @@ export interface RuntimeChainGap {
     segment: 'resource' | 'guid_map' | 'loader' | 'runtime';
     reason: string;
     next_command: string;
+    why_not_next?: string;
 }
 export interface RuntimeChainResult {
     status: RuntimeChainStatus;
     evidence_level: RuntimeChainEvidenceLevel;
+    evidence_source?: 'analyze_time' | 'query_time';
     hops: RuntimeChainHop[];
     gaps: RuntimeChainGap[];
+    why_not_next?: string[];
 }
 interface QueryExecutor {
     (query: string, params?: Record<string, unknown>): Promise<any[]>;
@@ -27,11 +32,20 @@ interface VerifyRuntimeChainInput {
     repoPath: string;
     executeParameterized: QueryExecutor;
     queryText?: string;
+    resourceSeedPath?: string;
+    mappedSeedTargets?: string[];
     symbolName?: string;
     symbolFilePath?: string;
     resourceBindings?: Array<{
         resourcePath?: string;
     }>;
+    requiredHops?: string[];
+    rule?: RuntimeClaimRule;
+}
+interface VerifyRuntimeClaimInput extends VerifyRuntimeChainInput {
+    rulesRoot?: string;
+    minimumEvidenceSatisfied?: boolean;
 }
 export declare function verifyRuntimeChainOnDemand(input: VerifyRuntimeChainInput): Promise<RuntimeChainResult | undefined>;
+export declare function verifyRuntimeClaimOnDemand(input: VerifyRuntimeClaimInput): Promise<RuntimeClaim>;
 export {};

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

@@ -1,221 +1,225 @@
-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();
+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
+        .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 shouldVerifyReloadChain(input) {
-    const haystack = [
+function buildRuntimeMatchHaystack(input) {
+    return [
         input.queryText,
+        input.resourceSeedPath,
         input.symbolName,
         input.symbolFilePath,
+        ...(input.mappedSeedTargets || []),
         ...(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,
-    };
+function parseTriggerTokens(triggerFamily) {
+    return String(triggerFamily || '')
+        .toLowerCase()
+        .split(/[\s,|/]+/)
+        .map((token) => token.trim())
+        .filter((token) => token.length > 0);
 }
-async function readFileLines(repoPath, relativePath) {
+async function verifyRuleDrivenRuntimeChain(input) {
+    const ruleId = input.rule?.id;
+    if (!ruleId) {
+        return { status: 'failed', evidence_level: 'none', evidence_source: 'analyze_time', hops: [], gaps: [] };
+    }
     try {
-        const fullPath = path.join(repoPath, relativePath);
-        const raw = await fs.readFile(fullPath, 'utf-8');
-        return raw.split(/\r?\n/);
+        const rows = await input.executeParameterized(`
+      MATCH (s)-[r:CodeRelation {type: 'CALLS'}]->(t)
+      WHERE r.reason CONTAINS $ruleId
+        AND r.reason STARTS WITH 'unity-rule-'
+      RETURN s.name AS sourceName, s.filePath AS sourceFilePath, s.startLine AS sourceStartLine,
+             t.name AS targetName, t.filePath AS targetFilePath, t.startLine AS targetStartLine,
+             r.reason AS reason
+      LIMIT 20
+    `, { ruleId });
+        if (rows.length > 0) {
+            const hops = rows.map((row) => ({
+                hop_type: 'code_runtime',
+                anchor: `${row.sourceFilePath}:${row.sourceStartLine || 1}->${row.targetFilePath}:${row.targetStartLine || 1}`,
+                confidence: 'high',
+                note: `Synthetic edge injected at analyze time (${row.reason}).`,
+                snippet: `${row.sourceName} -> ${row.targetName}`,
+            }));
+            return {
+                status: 'verified_full',
+                evidence_level: 'verified_chain',
+                evidence_source: 'analyze_time',
+                hops,
+                gaps: [],
+            };
+        }
     }
     catch {
-        return null;
+        // Graph query failed; fall through to no match.
     }
-}
-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(),
+        status: 'failed',
+        evidence_level: 'none',
+        evidence_source: 'analyze_time',
+        hops: [],
+        gaps: [],
     };
 }
-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),
-    };
+export async function verifyRuntimeChainOnDemand(input) {
+    if (!input.rule)
+        return undefined;
+    return await verifyRuleDrivenRuntimeChain(input);
 }
-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;
+function buildFailureRuntimeClaim(input) {
     return {
-        hop_type: hopType,
-        anchor: `${method.filePath}:${method.line}`,
-        confidence: 'high',
-        note,
-        snippet,
+        rule_id: input.rule?.id || 'none',
+        rule_version: input.rule?.version || '0.0.0',
+        scope: {
+            resource_types: input.rule?.resource_types || [],
+            host_base_type: input.rule?.host_base_type || [],
+            trigger_family: input.rule?.trigger_family || 'none',
+        },
+        status: 'failed',
+        evidence_level: 'none',
+        guarantees: [],
+        non_guarantees: input.rule?.non_guarantees?.length
+            ? [...input.rule.non_guarantees]
+            : ['runtime_chain_verification_not_executed'],
+        hops: [],
+        gaps: [],
+        reason: input.reason,
+        next_action: input.next_action,
     };
 }
-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');
+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;
+        }
     }
-    else {
-        gaps.push(buildGap('resource', 'missing PowerUp asset anchor'));
+    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 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');
+    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;
+        }
     }
-    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'));
+    for (const token of rule.match?.module_scope || []) {
+        const normalized = String(token || '').trim().toLowerCase();
+        if (normalized && haystack.includes(normalized))
+            score += 8 + normalized.length;
     }
-    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');
+    return score;
+}
+export async function verifyRuntimeClaimOnDemand(input) {
+    let registry;
+    try {
+        registry = await loadRuleRegistry(input.repoPath, input.rulesRoot);
     }
-    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'));
+    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;
     }
-    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',
+    const activeRules = registry.activeRules || [];
+    const fallbackNextAction = buildDefaultVerifyNextCommand(input.queryText);
+    if (activeRules.length === 0) {
+        return buildFailureRuntimeClaim({
+            reason: 'rule_not_matched',
+            next_action: fallbackNextAction,
         });
-        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');
+    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,
+        });
     }
-    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 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 requiredSegments = ['resource', 'guid_map', 'code_loader', 'code_runtime'];
-    const evidence_level = deriveRuntimeChainEvidenceLevel({
-        mode: hops.length > 0 ? 'verified_hops' : 'none',
-        requiredSegments,
-        foundSegments: [...foundSegments],
+    const normalizedStatus = (runtimeChain.status === 'pending' ? 'failed' : runtimeChain.status);
+    const verificationFailed = normalizedStatus === 'failed'
+        || (runtimeChain.evidence_level === 'none' && normalizedStatus !== 'verified_full');
+    const resolved = buildRuntimeClaimFromRule({
+        rule: matchedRule,
+        status: verificationFailed ? 'failed' : normalizedStatus,
+        evidence_level: runtimeChain.evidence_level,
+        hops: runtimeChain.hops,
+        gaps: runtimeChain.gaps,
+        ...(verificationFailed
+            ? {
+                reason: 'rule_matched_but_verification_failed',
+                next_action: matchedRule.next_action || buildDefaultVerifyNextCommand(input.queryText),
+            }
+            : {}),
     });
-    const status = evidence_level === 'verified_chain' ? 'verified_full'
-        : hops.length > 0 ? 'verified_partial'
-            : 'failed';
-    return {
-        status,
-        evidence_level,
-        hops,
-        gaps,
-    };
+    const chainClosed = resolved.status === 'verified_full'
+        && resolved.evidence_level === 'verified_chain'
+        && resolved.gaps.length === 0;
+    if (input.minimumEvidenceSatisfied === false && !chainClosed) {
+        return {
+            ...resolved,
+            status: 'failed',
+            evidence_level: 'clue',
+            guarantees: [],
+            non_guarantees: [...resolved.non_guarantees, 'minimum_evidence_contract_not_satisfied'],
+            reason: 'rule_matched_but_evidence_missing',
+            next_action: matchedRule.next_action || buildDefaultVerifyNextCommand(input.queryText),
+        };
+    }
+    return resolved;
 }