@veewo/gitnexus 1.5.6 → 1.5.8

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

@@ -24,12 +24,6 @@ import { adjustRuntimeClaimForPolicy } from './runtime-claim.js';
 // git utilities available if needed
 // import { isGitRepo, getCurrentCommit, getGitRoot } from '../../storage/git.js';
 import { listRegisteredRepos, cleanupOldKuzuFiles, } from '../../storage/repo-manager.js';
-import { analyzeRuleLabSlice } from '../../rule-lab/analyze.js';
-import { buildReviewPack } from '../../rule-lab/review-pack.js';
-import { curateRuleLabSlice } from '../../rule-lab/curate.js';
-import { promoteCuratedRules } from '../../rule-lab/promote.js';
-import { runRuleLabRegress } from '../../rule-lab/regress.js';
-import { loadCompiledRuleBundle } from '../../rule-lab/compiled-bundles.js';
 // AI context generation is CLI-only (gitnexus analyze)
 // import { generateAIContextFiles } from '../../cli/ai-context.js';
 /**
@@ -246,10 +240,28 @@ async function loadSeedUnityResourceChains(input) {
     }
     catch (e) {
         logQueryError('unity-resource-chains:seed-second-hop', e);
-        return [];
+    }
+    // One-hop query: direct UNITY_GRAPH_NODE_SCRIPT_REF from seed to Class
+    let oneHopRows = [];
+    try {
+        oneHopRows = await executeParameterized(input.repoId, `
+      MATCH (source:File {filePath: $seedPath})-[r:CodeRelation {type: 'UNITY_GRAPH_NODE_SCRIPT_REF'}]->(target)
+      WHERE labels(target)[0] = 'Class'
+      RETURN source.filePath AS sourceResourcePath,
+             r.type AS relationType,
+             r.reason AS relationReason,
+             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-one-hop', e);
     }
     const seen = new Set();
-    const chains = rows
+    const twoHopEntries = rows
         .map((row, index) => {
         const targetUid = String(row?.targetUid || row?.[6] || '').trim();
         const targetName = String(row?.targetName || row?.[7] || '').trim();
@@ -268,18 +280,35 @@ async function loadSeedUnityResourceChains(input) {
                 ...(targetFilePath ? { filePath: targetFilePath } : {}),
             },
         };
-        return {
-            chain,
-            index,
-            score: scoreUnityResourceChainTarget(chain, targetSymbols),
+        return { chain, index, score: scoreUnityResourceChainTarget(chain, targetSymbols) };
+    });
+    const oneHopEntries = oneHopRows
+        .map((row, index) => {
+        const targetUid = String(row?.targetUid || row?.[4] || '').trim();
+        const targetName = String(row?.targetName || row?.[5] || '').trim();
+        const targetFilePath = normalizePath(String(row?.targetFilePath || row?.[7] || '').trim());
+        const chain = {
+            sourceResourcePath: normalizePath(String(row?.sourceResourcePath || row?.[0] || '').trim()),
+            relationType: 'UNITY_GRAPH_NODE_SCRIPT_REF',
+            relationReason: String(row?.relationReason || row?.[2] || '').trim() || undefined,
+            targetSymbol: {
+                ...(targetUid ? { uid: targetUid } : {}),
+                ...(targetName ? { name: targetName } : {}),
+                kind: String(row?.targetKind || row?.[6] || '').trim() || undefined,
+                ...(targetFilePath ? { filePath: targetFilePath } : {}),
+            },
         };
-    })
+        return { chain, index: rows.length + index, score: scoreUnityResourceChainTarget(chain, targetSymbols) };
+    });
+    const chains = [...twoHopEntries, ...oneHopEntries]
         .filter(({ chain, score }) => {
-        if (!chain.sourceResourcePath || !chain.intermediateResourcePath || !chain.targetSymbol?.name)
+        if (!chain.sourceResourcePath || !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}`;
+        const key = chain.intermediateResourcePath
+            ? `${chain.sourceResourcePath}->${chain.intermediateResourcePath}->${chain.targetSymbol.uid || chain.targetSymbol.name}`
+            : `${chain.sourceResourcePath}->${chain.targetSymbol.uid || chain.targetSymbol.name}`;
         if (seen.has(key))
             return false;
         seen.add(key);
@@ -473,14 +502,7 @@ export function buildNextHops(input) {
     const mappedRemainder = input.mappedSeedTargets
         .map((value) => normalizePath(value))
         .filter((value) => value && !bindingSet.has(value));
-    const retrievalHostScope = (input.retrievalRule?.host_base_type || [])
-        .map((value) => String(value || '').trim().toLowerCase())
-        .filter(Boolean);
-    const currentSymbolMatchesRetrievalScope = retrievalHostScope.length === 0
-        || retrievalHostScope.includes(String(input.symbolName || '').trim().toLowerCase());
-    const shouldSuppressRawResourceHops = !input.seedPath
-        && mappedIntersectBindings.length === 0
-        && currentSymbolMatchesRetrievalScope === false;
+    const shouldSuppressRawResourceHops = false;
     const candidateResources = shouldSuppressRawResourceHops ? [] : rankCandidateResources([
         ...(input.seedPath ? [{ target: normalizePath(input.seedPath), bucket: 0 }] : []),
         ...mappedIntersectBindings.map((target) => ({ target, bucket: 1 })),
@@ -506,14 +528,6 @@ export function buildNextHops(input) {
             next_command: `gitnexus query${repoArg} --unity-resources on --unity-hydration parity --resource-path-prefix "${target}" "${input.queryForSymbol}"`,
         });
     }
-    if (input.retrievalRule?.next_action) {
-        addHop({
-            kind: 'verify',
-            target: input.seedPath || input.symbolName,
-            why: `Retrieval rule ${input.retrievalRule.id} configured this follow-up action.`,
-            next_command: withRepoInCommand(input.retrievalRule.next_action),
-        });
-    }
     if (input.verificationHint?.target
         && !(shouldSuppressRawResourceHops && isUnityResourcePathLike(String(input.verificationHint.target)))) {
         addHop({
@@ -579,69 +593,6 @@ function scoreResourcePathNoise(resourcePath) {
         penalty += 6;
     return penalty;
 }
-async function resolveRetrievalRuleHint(input) {
-    const bundle = await loadCompiledRuleBundle(input.repoPath, 'retrieval_rules');
-    if (!bundle)
-        return undefined;
-    return pickRetrievalRuleHintFromBundle({
-        queryText: input.queryText,
-        symbolName: input.symbolName,
-        seedPath: input.seedPath,
-        rules: bundle.rules,
-    });
-}
-export function pickRetrievalRuleHintFromBundle(input) {
-    const haystack = [
-        String(input.queryText || ''),
-        String(input.symbolName || ''),
-        String(input.seedPath || ''),
-    ].join(' ').toLowerCase();
-    const rank = (rule) => {
-        let score = 0;
-        let matchedTrigger = false;
-        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;
-            }
-        }
-        for (const token of rule.host_base_type || []) {
-            const normalized = String(token || '').trim().toLowerCase();
-            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)) {
-                matchedEvidence = true;
-                score += 4 + normalized.length;
-            }
-        }
-        if (!matchedEvidence)
-            return Number.NEGATIVE_INFINITY;
-        if (!matchedTrigger)
-            score -= 3;
-        return score;
-    };
-    const matched = [...input.rules]
-        .map((rule) => ({ rule, score: rank(rule) }))
-        .filter((entry) => Number.isFinite(entry.score))
-        .sort((a, b) => (b.score - a.score) || a.rule.id.localeCompare(b.rule.id))[0]?.rule;
-    if (!matched || !String(matched.next_action || '').trim())
-        return undefined;
-    return {
-        id: matched.id,
-        next_action: matched.next_action,
-        host_base_type: matched.host_base_type,
-    };
-}
 export async function resolveSeedTargetsFromResourceFile(repoPath, seedPath) {
     if (!isUnityResourcePath(seedPath))
         return [];
@@ -1072,16 +1023,6 @@ export class LocalBackend {
                 return this.detectChanges(repo, params);
             case 'rename':
                 return this.rename(repo, params);
-            case 'rule_lab_analyze':
-                return this.ruleLabAnalyze(repo, params);
-            case 'rule_lab_review_pack':
-                return this.ruleLabReviewPack(repo, params);
-            case 'rule_lab_curate':
-                return this.ruleLabCurate(repo, params);
-            case 'rule_lab_promote':
-                return this.ruleLabPromote(repo, params);
-            case 'rule_lab_regress':
-                return this.ruleLabRegress(repo, params);
             // Legacy aliases for backwards compatibility
             case 'search':
                 return this.query(repo, params);
@@ -1118,136 +1059,6 @@ export class LocalBackend {
             return { error: err?.message || 'unity_ui_trace failed' };
         }
     }
-    async ruleLabAnalyze(repo, params) {
-        const runId = String(params?.run_id || params?.runId || '').trim();
-        const sliceId = String(params?.slice_id || params?.sliceId || '').trim();
-        if (!runId || !sliceId) {
-            return { error: 'run_id and slice_id are required for rule_lab_analyze' };
-        }
-        try {
-            const out = await analyzeRuleLabSlice({
-                repoPath: repo.repoPath,
-                runId,
-                sliceId,
-            });
-            return {
-                ...out,
-                artifact_paths: {
-                    candidates: out.paths.candidatesPath,
-                },
-            };
-        }
-        catch (err) {
-            return { error: err?.message || 'rule_lab_analyze failed' };
-        }
-    }
-    async ruleLabReviewPack(repo, params) {
-        const runId = String(params?.run_id || params?.runId || '').trim();
-        const sliceId = String(params?.slice_id || params?.sliceId || '').trim();
-        if (!runId || !sliceId) {
-            return { error: 'run_id and slice_id are required for rule_lab_review_pack' };
-        }
-        const maxTokens = Number.isFinite(Number(params?.max_tokens ?? params?.maxTokens))
-            ? Number(params?.max_tokens ?? params?.maxTokens)
-            : 6000;
-        try {
-            const out = await buildReviewPack({
-                repoPath: repo.repoPath,
-                runId,
-                sliceId,
-                maxTokens,
-            });
-            return {
-                ...out,
-                artifact_paths: {
-                    review_pack: out.paths.reviewCardsPath,
-                },
-            };
-        }
-        catch (err) {
-            return { error: err?.message || 'rule_lab_review_pack failed' };
-        }
-    }
-    async ruleLabCurate(repo, params) {
-        const runId = String(params?.run_id || params?.runId || '').trim();
-        const sliceId = String(params?.slice_id || params?.sliceId || '').trim();
-        const inputPath = String(params?.input_path || params?.inputPath || '').trim();
-        if (!runId || !sliceId || !inputPath) {
-            return { error: 'run_id, slice_id, and input_path are required for rule_lab_curate' };
-        }
-        try {
-            const out = await curateRuleLabSlice({
-                repoPath: repo.repoPath,
-                runId,
-                sliceId,
-                inputPath,
-            });
-            return {
-                ...out,
-                artifact_paths: {
-                    curated: out.paths.curatedPath,
-                },
-            };
-        }
-        catch (err) {
-            return { error: err?.message || 'rule_lab_curate failed' };
-        }
-    }
-    async ruleLabPromote(repo, params) {
-        const runId = String(params?.run_id || params?.runId || '').trim();
-        const sliceId = String(params?.slice_id || params?.sliceId || '').trim();
-        if (!runId || !sliceId) {
-            return { error: 'run_id and slice_id are required for rule_lab_promote' };
-        }
-        try {
-            const out = await promoteCuratedRules({
-                repoPath: repo.repoPath,
-                runId,
-                sliceId,
-                version: typeof params?.version === 'string' ? params.version : undefined,
-            });
-            return {
-                ...out,
-                artifact_paths: {
-                    catalog: path.join(out.paths.rulesRoot, 'catalog.json'),
-                    promoted_files: out.promotedFiles,
-                    compiled_bundles: out.compiledPaths,
-                },
-            };
-        }
-        catch (err) {
-            return { error: err?.message || 'rule_lab_promote failed' };
-        }
-    }
-    async ruleLabRegress(repo, params) {
-        const precision = Number(params?.precision);
-        const coverage = Number(params?.coverage);
-        if (!Number.isFinite(precision) || !Number.isFinite(coverage)) {
-            return { error: 'precision and coverage are required numeric fields for rule_lab_regress' };
-        }
-        try {
-            let probes = Array.isArray(params?.probes) ? params.probes : undefined;
-            const probesPath = String(params?.probes_path || params?.probesPath || '').trim();
-            if (!probes && probesPath) {
-                const raw = await fs.readFile(path.isAbsolute(probesPath) ? probesPath : path.join(repo.repoPath, probesPath), 'utf-8');
-                probes = JSON.parse(raw);
-            }
-            const out = await runRuleLabRegress({
-                precision,
-                coverage,
-                probes,
-                repoPath: repo.repoPath,
-                runId: String(params?.run_id || params?.runId || '').trim() || undefined,
-            });
-            return {
-                ...out,
-                artifact_paths: out.reportPath ? { report: out.reportPath } : {},
-            };
-        }
-        catch (err) {
-            return { error: err?.message || 'rule_lab_regress failed' };
-        }
-    }
     // ─── Tool Implementations ────────────────────────────────────────
     /**
      * Query tool — process-grouped search.
@@ -1692,18 +1503,23 @@ export class LocalBackend {
         const firstResourceBindings = Array.isArray(firstSymbolForHops?.resourceBindings)
             ? firstSymbolForHops.resourceBindings
             : [];
-        const retrievalRule = await resolveRetrievalRuleHint({
-            repoPath: repo.repoPath,
-            queryText: params.query,
-            symbolName: String(firstSymbolForHops?.name || searchQuery),
-            seedPath,
-        });
+        // Bindings→chains fallback: if resource_chains is empty but bindings exist, generate one-hop chains
+        if ((!result.resource_chains || result.resource_chains.length === 0) && firstResourceBindings.length > 0) {
+            result.resource_chains = firstResourceBindings.slice(0, 20).map((binding) => ({
+                sourceResourcePath: binding.resourcePath,
+                relationType: 'UNITY_GRAPH_NODE_SCRIPT_REF',
+                targetSymbol: {
+                    uid: firstSymbolForHops?.id || undefined,
+                    name: firstSymbolForHops?.name || undefined,
+                    filePath: firstSymbolForHops?.filePath || undefined,
+                },
+            }));
+        }
         result.next_hops = buildNextHops({
             seedPath,
             mappedSeedTargets,
             resourceBindings: firstResourceBindings,
             verificationHint: firstVerificationHint,
-            retrievalRule,
             repoName: repo.name,
             symbolName: String(firstSymbolForHops?.name || searchQuery),
             queryForSymbol: String(firstSymbolForHops?.name || searchQuery),
@@ -2462,18 +2278,23 @@ export class LocalBackend {
                     }],
             });
         }
-        const retrievalRule = await resolveRetrievalRuleHint({
-            repoPath: repo.repoPath,
-            queryText: name,
-            symbolName: symName || String(name || uid || ''),
-            seedPath,
-        });
+        // Bindings→chains fallback: if resource_chains is empty but bindings exist, generate one-hop chains
+        if ((!result.resource_chains || result.resource_chains.length === 0) && contextResourceBindings.length > 0) {
+            result.resource_chains = contextResourceBindings.slice(0, 20).map((binding) => ({
+                sourceResourcePath: binding.resourcePath,
+                relationType: 'UNITY_GRAPH_NODE_SCRIPT_REF',
+                targetSymbol: {
+                    uid: symNodeId || undefined,
+                    name: symName || undefined,
+                    filePath: symFilePath || undefined,
+                },
+            }));
+        }
         result.next_hops = buildNextHops({
             seedPath,
             mappedSeedTargets,
             resourceBindings: contextResourceBindings,
             verificationHint: topVerificationHint,
-            retrievalRule,
             repoName: repo.name,
             symbolName: symName || String(name || uid || ''),
             queryForSymbol: symName || String(name || uid || ''),

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

@@ -3,7 +3,6 @@ import os from 'node:os';
 import path from 'node:path';
 import { describe, expect, it } from 'vitest';
 import { verifyRuntimeChainOnDemand, verifyRuntimeClaimOnDemand } from './runtime-chain-verify.js';
-import { promoteCuratedRules } from '../../rule-lab/promote.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 });
@@ -590,52 +589,4 @@ describe('runtime chain verify', () => {
         expect(String(out.next_action || '')).toContain('Reload runtime start sequence');
         await fs.rm(repoPath, { recursive: true, force: true });
     });
-    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 });
-        await fs.writeFile(path.join(sliceDir, 'curated.json'), JSON.stringify({
-            run_id: 'run-x',
-            slice_id: 'slice-a',
-            curated: [
-                {
-                    id: 'candidate-startup-1',
-                    rule_id: 'demo.startup.v1',
-                    title: 'startup startup graph',
-                    confirmed_chain: {
-                        steps: [{ hop_type: 'resource', anchor: 'Assets/Rules/startup.asset:1', snippet: 'Startup Graph Trigger' }],
-                    },
-                    guarantees: ['startup trigger matching is confirmed'],
-                    non_guarantees: ['does not prove full runtime ordering'],
-                },
-            ],
-        }, null, 2), 'utf-8');
-        await promoteCuratedRules({ repoPath, runId: 'run-x', sliceId: 'slice-a', version: '1.0.0' });
-        const out = await verifyRuntimeClaimOnDemand({
-            repoPath,
-            queryText: 'Startup Graph Trigger',
-            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('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

@@ -1,10 +1,8 @@
-import type { UnityResourceBinding, LifecycleOverrides } from '../../rule-lab/types.js';
 export interface RuntimeClaimRuleCatalogEntry {
     id: string;
     version: string;
     file?: string;
     enabled?: boolean;
-    family?: 'analyze_rules' | 'verification_rules';
 }
 export interface RuntimeClaimRule {
     id: string;
@@ -24,9 +22,6 @@ export interface RuntimeClaimRule {
     guarantees: string[];
     non_guarantees: string[];
     next_action?: string;
-    family?: 'analyze_rules' | 'verification_rules';
-    resource_bindings?: UnityResourceBinding[];
-    lifecycle_overrides?: LifecycleOverrides;
     file_path: string;
     topology?: Array<{
         hop: string;
@@ -60,9 +55,3 @@ 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

@@ -1,6 +1,3 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { loadCompiledRuleBundle } from '../../rule-lab/compiled-bundles.js';
 export class RuleRegistryLoadError extends Error {
     code;
     details;
@@ -139,59 +136,6 @@ export function parseRuleYaml(raw, filePath) {
     const legacyGuarantees = readList(raw, 'guarantees');
     const legacyNonGuarantees = readList(raw, 'non_guarantees');
     const legacyNextAction = readScalar(raw, 'next_action');
-    // Parse resource_bindings
-    const rbLines = readSectionLines(raw, 'resource_bindings');
-    let resource_bindings;
-    if (rbLines.length > 0) {
-        resource_bindings = [];
-        const joined = rbLines.map((l) => l.replace(/^\s{2}/, '')).join('\n');
-        const entries = joined.split(/(?=^\s*- kind:)/m).filter((s) => s.trim());
-        for (const entry of entries) {
-            const kindMatch = entry.match(/- kind:\s*(.+)/);
-            if (!kindMatch)
-                continue;
-            const binding = { kind: decodeYamlScalar(kindMatch[1]) };
-            const scalar = (k) => {
-                const m = entry.match(new RegExp(`^\\s+${k}:\\s*(.+)$`, 'm'));
-                return m ? decodeYamlScalar(m[1]) : undefined;
-            };
-            const list = (k) => {
-                const lines = entry.split('\n');
-                const idx = lines.findIndex((l) => new RegExp(`^\\s+${k}:\\s*$`).test(l));
-                if (idx < 0)
-                    return undefined;
-                const out = [];
-                for (let i = idx + 1; i < lines.length; i++) {
-                    if (!/^\s+-\s+/.test(lines[i]))
-                        break;
-                    out.push(decodeYamlScalar(lines[i].replace(/^\s+-\s+/, '')));
-                }
-                return out.length > 0 ? out : undefined;
-            };
-            binding.ref_field_pattern = scalar('ref_field_pattern');
-            binding.target_entry_points = list('target_entry_points');
-            binding.host_class_pattern = scalar('host_class_pattern');
-            binding.field_name = scalar('field_name');
-            binding.loader_methods = list('loader_methods');
-            binding.scene_name = scalar('scene_name');
-            binding.source_class_pattern = scalar('source_class_pattern');
-            binding.source_method = scalar('source_method');
-            binding.target_class_pattern = scalar('target_class_pattern');
-            binding.target_method = scalar('target_method');
-            resource_bindings.push(binding);
-        }
-        if (resource_bindings.length === 0)
-            resource_bindings = undefined;
-    }
-    // Parse lifecycle_overrides
-    const loEntryPoints = readNestedList(raw, 'lifecycle_overrides', 'additional_entry_points');
-    const loScope = readNestedScalar(raw, 'lifecycle_overrides', 'scope');
-    const lifecycle_overrides = loEntryPoints.length > 0 || loScope
-        ? {
-            ...(loEntryPoints.length > 0 ? { additional_entry_points: loEntryPoints } : {}),
-            ...(loScope ? { scope: loScope } : {}),
-        }
-        : undefined;
     return {
         id,
         version,
@@ -209,109 +153,6 @@ export function parseRuleYaml(raw, filePath) {
         guarantees: claimGuarantees.length > 0 ? claimGuarantees : legacyGuarantees,
         non_guarantees: claimNonGuarantees.length > 0 ? claimNonGuarantees : legacyNonGuarantees,
         next_action: claimNextAction || legacyNextAction,
-        family: readScalar(raw, 'family') || 'verification_rules',
-        resource_bindings,
-        lifecycle_overrides,
         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
-        ? path.resolve(rulesRoot)
-        : path.join(normalizedRepoPath, '.gitnexus', 'rules');
-    const compiledVerificationBundle = await loadCompiledRuleBundle(normalizedRepoPath, 'verification_rules', root);
-    if (compiledVerificationBundle && compiledVerificationBundle.rules.length > 0) {
-        return {
-            repoPath: normalizedRepoPath,
-            rulesRoot: root,
-            catalogPath: path.join(root, 'compiled', 'verification_rules.v2.json'),
-            activeRules: compiledVerificationBundle.rules.map((rule) => ({
-                id: rule.id,
-                version: rule.version,
-                trigger_family: rule.trigger_family,
-                resource_types: rule.resource_types,
-                host_base_type: rule.host_base_type,
-                match: rule.match,
-                required_hops: rule.required_hops,
-                guarantees: rule.guarantees,
-                non_guarantees: rule.non_guarantees,
-                next_action: rule.next_action,
-                file_path: rule.file_path,
-                topology: rule.topology,
-                closure: rule.closure,
-                claims: rule.claims,
-            })),
-        };
-    }
-    const catalogPath = path.join(root, 'catalog.json');
-    let catalogRaw;
-    try {
-        catalogRaw = await fs.readFile(catalogPath, 'utf-8');
-    }
-    catch (error) {
-        if (error?.code === 'ENOENT') {
-            throw new RuleRegistryLoadError('rule_catalog_missing', `Runtime claim rule catalog not found: ${catalogPath}`, { repoPath: normalizedRepoPath, rulesRoot: root, catalogPath });
-        }
-        throw error;
-    }
-    let catalog;
-    try {
-        catalog = JSON.parse(catalogRaw);
-    }
-    catch {
-        throw new RuleRegistryLoadError('rule_catalog_invalid', `Runtime claim rule catalog is invalid JSON: ${catalogPath}`, { repoPath: normalizedRepoPath, rulesRoot: root, catalogPath });
-    }
-    const catalogRules = Array.isArray(catalog.rules) ? catalog.rules : [];
-    const activeRules = [];
-    for (const entry of catalogRules) {
-        if (entry.enabled === false)
-            continue;
-        const relativeRulePath = String(entry.file || path.join('approved', `${entry.id}.yaml`));
-        const rulePath = path.join(root, relativeRulePath);
-        let raw;
-        try {
-            raw = await fs.readFile(rulePath, 'utf-8');
-        }
-        catch (error) {
-            if (error?.code === 'ENOENT') {
-                throw new RuleRegistryLoadError('rule_file_missing', `Runtime claim rule file not found: ${rulePath}`, { repoPath: normalizedRepoPath, rulesRoot: root, catalogPath, rulePath, ruleId: entry.id });
-            }
-            throw error;
-        }
-        const parsed = parseRuleYaml(raw, rulePath);
-        if (parsed.id !== entry.id) {
-            throw new Error(`Rule id mismatch between catalog and yaml: ${entry.id} vs ${parsed.id}`);
-        }
-        activeRules.push({
-            ...parsed,
-            version: entry.version || parsed.version,
-            family: entry.family || parsed.family || 'verification_rules',
-        });
-    }
-    return {
-        repoPath: normalizedRepoPath,
-        rulesRoot: root,
-        catalogPath,
-        activeRules,
-    };
-}
-export async function loadAnalyzeRules(repoPath, rulesRoot) {
-    const normalizedRepoPath = path.resolve(repoPath);
-    const root = rulesRoot
-        ? path.resolve(rulesRoot)
-        : path.join(normalizedRepoPath, '.gitnexus', 'rules');
-    const analyzeBundle = await loadCompiledRuleBundle(normalizedRepoPath, 'analyze_rules', root);
-    if (analyzeBundle && analyzeBundle.rules.length > 0) {
-        return analyzeBundle.rules.map((rule) => ({
-            ...rule,
-            family: 'analyze_rules',
-        }));
-    }
-    const registry = await loadRuleRegistry(repoPath, rulesRoot);
-    return registry.activeRules.filter((r) => r.family === 'analyze_rules');
-}