@veewo/gitnexus 1.5.6 → 1.5.8

package/dist/rule-lab/review-pack.js

@@ -1,165 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { getRuleLabPaths } from './paths.js';
-function estimateTokens(value) {
-    return Math.ceil(JSON.stringify(value).length / 4);
-}
-function parseCandidates(raw) {
-    return raw
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .map((line) => JSON.parse(line));
-}
-function unique(values) {
-    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))];
-}
-function mergeFailureMaps(candidates) {
-    const out = {};
-    for (const candidate of candidates) {
-        const failureMap = candidate.closure?.failure_map || {};
-        for (const [key, value] of Object.entries(failureMap)) {
-            if (String(key || '').trim() && String(value || '').trim()) {
-                out[key] = value;
-            }
-        }
-    }
-    return out;
-}
-function collectRequiredHops(candidates) {
-    const fromClosure = candidates.flatMap((candidate) => {
-        const closure = candidate.closure;
-        return Array.isArray(closure?.required_hops) ? closure.required_hops : [];
-    });
-    if (fromClosure.length > 0)
-        return unique(fromClosure);
-    return unique(candidates.flatMap((candidate) => (candidate.topology || []).map((hop) => hop.hop)));
-}
-function collectClaims(candidates) {
-    const guarantees = unique(candidates.flatMap((candidate) => {
-        const claims = candidate.claims;
-        return Array.isArray(claims?.guarantees) ? claims.guarantees : [];
-    }));
-    const nonGuarantees = unique(candidates.flatMap((candidate) => {
-        const claims = candidate.claims;
-        return Array.isArray(claims?.non_guarantees) ? claims.non_guarantees : [];
-    }));
-    return {
-        guarantees,
-        non_guarantees: nonGuarantees,
-    };
-}
-function collectDraftRuleIds(candidates) {
-    return unique(candidates.map((candidate) => String(candidate.draft_rule_id || '').trim()).filter(Boolean));
-}
-function collectAggregationModes(candidates) {
-    return unique(candidates.map((candidate) => String(candidate.aggregation_mode || '').trim()).filter(Boolean));
-}
-function collectBindingKinds(candidates) {
-    return unique(candidates.map((candidate) => String(candidate.binding_kind || '').trim()).filter(Boolean));
-}
-function buildCards(candidates) {
-    const cards = [];
-    const chunkSize = 4;
-    for (let i = 0; i < candidates.length; i += chunkSize) {
-        const chunk = candidates.slice(i, i + chunkSize);
-        const claims = collectClaims(chunk);
-        cards.push({
-            card_id: `card-${Math.floor(i / chunkSize) + 1}`,
-            title: `Rule Lab Card ${Math.floor(i / chunkSize) + 1}`,
-            candidate_ids: chunk.map((item) => item.id),
-            decision_inputs: {
-                required_hops: collectRequiredHops(chunk),
-                failure_map: mergeFailureMaps(chunk),
-                guarantees: claims.guarantees,
-                non_guarantees: claims.non_guarantees,
-                draft_rule_ids: collectDraftRuleIds(chunk),
-                aggregation_modes: collectAggregationModes(chunk),
-                binding_kinds: collectBindingKinds(chunk),
-            },
-        });
-    }
-    return cards;
-}
-function renderReviewPack(meta, cards) {
-    const lines = [];
-    lines.push('# Rule Lab Review Pack');
-    lines.push('');
-    lines.push('## Meta');
-    lines.push(`- token_budget: ${meta.token_budget}`);
-    lines.push(`- token_budget_estimate: ${meta.token_budget_estimate}`);
-    lines.push(`- truncated: ${meta.truncated}`);
-    lines.push(`- total_candidates: ${meta.total_candidates}`);
-    lines.push(`- included_candidates: ${meta.included_candidates}`);
-    lines.push('');
-    for (const card of cards) {
-        lines.push(`## ${card.title}`);
-        lines.push(`- card_id: ${card.card_id}`);
-        lines.push(`- candidate_ids: ${card.candidate_ids.join(', ')}`);
-        lines.push(`- required_hops: ${card.decision_inputs.required_hops.join(', ')}`);
-        lines.push(`- guarantees: ${card.decision_inputs.guarantees.join(', ')}`);
-        lines.push(`- non_guarantees: ${card.decision_inputs.non_guarantees.join(', ')}`);
-        lines.push(`- draft_rule_ids: ${card.decision_inputs.draft_rule_ids.join(', ')}`);
-        lines.push(`- aggregation_modes: ${card.decision_inputs.aggregation_modes.join(', ')}`);
-        lines.push(`- binding_kinds: ${card.decision_inputs.binding_kinds.join(', ')}`);
-        lines.push(`- failure_map: ${JSON.stringify(card.decision_inputs.failure_map)}`);
-        lines.push('');
-    }
-    return `${lines.join('\n')}\n`;
-}
-function isENOENT(error) {
-    return typeof error === 'object' && error !== null && error.code === 'ENOENT';
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function readCandidatesFileWithRetry(candidatesPath, analyzeCommandHint, timeoutMs = 3000, intervalMs = 100) {
-    const deadline = Date.now() + timeoutMs;
-    while (true) {
-        try {
-            return await fs.readFile(candidatesPath, 'utf-8');
-        }
-        catch (error) {
-            if (!isENOENT(error))
-                throw error;
-            if (Date.now() >= deadline) {
-                throw new Error(`Missing candidates file for review-pack: ${candidatesPath}\n` +
-                    `Run analyze first and wait for completion, then retry review-pack.\n` +
-                    `Suggested command: ${analyzeCommandHint}`);
-            }
-            await sleep(intervalMs);
-        }
-    }
-}
-export async function buildReviewPack(input) {
-    const normalizedRepoPath = path.resolve(input.repoPath);
-    const paths = getRuleLabPaths(normalizedRepoPath, input.runId, input.sliceId);
-    const analyzeCommandHint = `gitnexus rule-lab analyze --repo-path "${normalizedRepoPath}" --run-id "${input.runId}" --slice-id "${input.sliceId}"`;
-    const raw = await readCandidatesFileWithRetry(paths.candidatesPath, analyzeCommandHint);
-    const candidates = parseCandidates(raw);
-    const included = [];
-    let tokenEstimate = 0;
-    for (const candidate of candidates) {
-        const nextTokens = estimateTokens(candidate);
-        if (tokenEstimate + nextTokens > input.maxTokens) {
-            break;
-        }
-        included.push(candidate);
-        tokenEstimate += nextTokens;
-    }
-    const meta = {
-        token_budget: input.maxTokens,
-        token_budget_estimate: tokenEstimate,
-        truncated: included.length < candidates.length,
-        total_candidates: candidates.length,
-        included_candidates: included.length,
-    };
-    const cards = buildCards(included);
-    await fs.mkdir(path.dirname(paths.reviewCardsPath), { recursive: true });
-    await fs.writeFile(paths.reviewCardsPath, renderReviewPack(meta, cards), 'utf-8');
-    return {
-        paths,
-        meta,
-        cards,
-    };
-}

package/dist/rule-lab/review-pack.test.d.ts

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

package/dist/rule-lab/review-pack.test.js

@@ -1,116 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { buildReviewPack } from './review-pack.js';
-describe('rule-lab review-pack', () => {
-    it('splits cards to keep token budget <= 6000', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-review-pack-'));
-        const sliceDir = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', 'run-x', 'slices', 'slice-a');
-        await fs.mkdir(sliceDir, { recursive: true });
-        const candidate = {
-            id: 'cand-1',
-            title: 'reload candidate',
-            topology: [
-                {
-                    hop: 'resource',
-                    from: { entity: 'resource' },
-                    to: { entity: 'script' },
-                    edge: { kind: 'binds_script' },
-                },
-            ],
-            closure: {
-                required_hops: ['resource'],
-                failure_map: { missing_evidence: 'rule_matched_but_evidence_missing' },
-            },
-            claims: {
-                guarantees: ['reload_chain_closed'],
-                non_guarantees: ['no_runtime_execution'],
-            },
-            evidence: {
-                hops: [
-                    { hop_type: 'resource', anchor: 'Assets/Example.prefab:42', snippet: 'ReloadGraph' },
-                ],
-            },
-        };
-        const lines = Array.from({ length: 12 }).map((_, i) => JSON.stringify({ ...candidate, id: `cand-${i}` }));
-        await fs.writeFile(path.join(sliceDir, 'candidates.jsonl'), `${lines.join('\n')}\n`, 'utf-8');
-        const out = await buildReviewPack({ repoPath: repoRoot, runId: 'run-x', sliceId: 'slice-a', maxTokens: 6000 });
-        expect(out.meta.token_budget_estimate).toBeLessThanOrEqual(6000);
-        expect(out.meta.truncated || out.cards.length > 0).toBe(true);
-        expect(out.cards[0]).toHaveProperty('decision_inputs.required_hops');
-        expect(out.cards[0]).toHaveProperty('decision_inputs.failure_map');
-        expect(out.cards[0]).toHaveProperty('decision_inputs.guarantees');
-        expect(out.cards[0]).toHaveProperty('decision_inputs.non_guarantees');
-        const persisted = await fs.readFile(out.paths.reviewCardsPath, 'utf-8');
-        expect(persisted).toContain('token_budget_estimate');
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('shows actionable guidance when candidates are missing', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-review-pack-missing-'));
-        const sliceDir = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', 'run-y', 'slices', 'slice-b');
-        await fs.mkdir(sliceDir, { recursive: true });
-        const err = await buildReviewPack({ repoPath: repoRoot, runId: 'run-y', sliceId: 'slice-b', maxTokens: 6000 })
-            .then(() => null)
-            .catch((error) => error);
-        expect(err).toBeTruthy();
-        expect(String(err?.message || '')).toMatch(/Missing candidates file for review-pack/);
-        expect(String(err?.message || '')).toMatch(/rule-lab analyze --repo-path/);
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('waits briefly for candidates to avoid analyze/review-pack races', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-review-pack-race-'));
-        const sliceDir = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', 'run-z', 'slices', 'slice-c');
-        await fs.mkdir(sliceDir, { recursive: true });
-        const candidatesPath = path.join(sliceDir, 'candidates.jsonl');
-        const line = JSON.stringify({
-            id: 'cand-race',
-            title: 'race candidate',
-            topology: [{ hop: 'resource', from: { entity: 'resource' }, to: { entity: 'script' }, edge: { kind: 'binds_script' } }],
-            evidence: { hops: [{ hop_type: 'resource', anchor: 'Assets/Test.prefab:1', snippet: 'Race' }] },
-        });
-        const delayedWrite = new Promise((resolve, reject) => {
-            setTimeout(() => {
-                fs.writeFile(candidatesPath, `${line}\n`, 'utf-8').then(() => resolve()).catch(reject);
-            }, 150);
-        });
-        const out = await buildReviewPack({ repoPath: repoRoot, runId: 'run-z', sliceId: 'slice-c', maxTokens: 6000 });
-        await delayedWrite;
-        expect(out.meta.total_candidates).toBe(1);
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-    it('renders decision inputs without lineage-only fields', async () => {
-        const repoRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'rule-lab-review-pack-direct-'));
-        const sliceDir = path.join(repoRoot, '.gitnexus', 'rules', 'lab', 'runs', 'run-h', 'slices', 'slice-h');
-        await fs.mkdir(sliceDir, { recursive: true });
-        const rows = [
-            {
-                id: 'proposal-1',
-                title: 'event_delegate proposal accepted-a',
-                proposal_kind: 'per_anchor_rule',
-                aggregation_mode: 'per_anchor_rules',
-                draft_rule_id: 'unity.event.netplayer-gameover-syncvar-hook-ondeadchange.v1',
-                binding_kind: 'method_triggers_method',
-                topology: [{ hop: 'code_runtime', from: { entity: 'script' }, to: { entity: 'runtime' }, edge: { kind: 'calls' } }],
-                evidence: { hops: [{ hop_type: 'code_runtime', anchor: 'Assets/A.cs:1', snippet: 'A' }] },
-            },
-            {
-                id: 'proposal-2',
-                title: 'event_delegate proposal accepted-b',
-                proposal_kind: 'per_anchor_rule',
-                aggregation_mode: 'per_anchor_rules',
-                draft_rule_id: 'unity.event.mirrorbattlemgr-createnetplayer-syncvar-hook-changeroomgrid.v1',
-                binding_kind: 'method_triggers_method',
-                topology: [{ hop: 'code_runtime', from: { entity: 'script' }, to: { entity: 'runtime' }, edge: { kind: 'calls' } }],
-                evidence: { hops: [{ hop_type: 'code_runtime', anchor: 'Assets/B.cs:2', snippet: 'B' }] },
-            },
-        ];
-        await fs.writeFile(path.join(sliceDir, 'candidates.jsonl'), `${rows.map((row) => JSON.stringify(row)).join('\n')}\n`, 'utf-8');
-        const out = await buildReviewPack({ repoPath: repoRoot, runId: 'run-h', sliceId: 'slice-h', maxTokens: 6000 });
-        const persisted = await fs.readFile(out.paths.reviewCardsPath, 'utf-8');
-        expect(persisted).not.toContain('Handoff Summary');
-        expect(persisted).not.toContain('source_gap_candidate_ids');
-        expect(persisted).toContain('draft_rule_ids: unity.event.netplayer-gameover-syncvar-hook-ondeadchange.v1, unity.event.mirrorbattlemgr-createnetplayer-syncvar-hook-changeroomgrid.v1');
-        await fs.rm(repoRoot, { recursive: true, force: true });
-    });
-});

package/dist/rule-lab/types.d.ts

@@ -1,135 +0,0 @@
-export type RuleLabScope = 'full' | 'diff';
-export type RuntimeClaimFailureReason = 'rule_not_matched' | 'rule_matched_but_evidence_missing' | 'rule_matched_but_verification_failed' | 'gate_disabled';
-export interface RuleLabSlice {
-    id: string;
-    trigger_family: string;
-    resource_types: string[];
-    host_base_type: string[];
-    required_hops?: string[];
-    exact_pairs?: RuleLabExactPair[];
-}
-export interface RuleLabManifest {
-    run_id: string;
-    repo_path: string;
-    scope: RuleLabScope;
-    generated_at: string;
-    slices: RuleLabSlice[];
-    next_actions: string[];
-    stages: string[];
-}
-export interface RuleLabCandidateHop {
-    hop_type: string;
-    anchor: string;
-    snippet: string;
-}
-export interface RuleLabCandidate {
-    id: string;
-    title: string;
-    rule_hint?: string;
-    proposal_kind?: 'per_anchor_rule' | 'aggregate_rule';
-    source_slice_id?: string;
-    aggregation_mode?: 'per_anchor_rules' | 'aggregate_single_rule';
-    binding_kind?: string;
-    draft_rule_id?: string;
-    topology?: Array<{
-        hop: string;
-        from: Record<string, unknown>;
-        to: Record<string, unknown>;
-        edge: {
-            kind: string;
-        };
-        constraints?: Record<string, unknown>;
-    }>;
-    stats?: {
-        covered: number;
-        total: number;
-        conflicts: number;
-        coverage_rate: number;
-        conflict_rate: number;
-    };
-    counter_examples?: Array<{
-        reason: string;
-        missing_hop?: string;
-        evidence_anchor?: string;
-    }>;
-    closure?: {
-        required_hops: string[];
-        failure_map: Record<string, RuntimeClaimFailureReason | string>;
-    };
-    claims?: {
-        guarantees: string[];
-        non_guarantees: string[];
-        next_action: string;
-    };
-    proposal_evidence_keys?: string[];
-    exact_pair?: RuleLabExactPair;
-    evidence: {
-        hops: RuleLabCandidateHop[];
-    };
-}
-export interface RuleLabExactPairAnchor {
-    file: string;
-    line?: number;
-    symbol?: string;
-}
-export interface RuleLabExactPair {
-    id?: string;
-    binding_kind?: UnityResourceBinding['kind'];
-    draft_rule_id?: string;
-    source_anchor: RuleLabExactPairAnchor;
-    target_anchor: RuleLabExactPairAnchor;
-}
-export interface RuleDslMatch {
-    trigger_tokens: string[];
-    symbol_kind?: string[];
-    module_scope?: string[];
-    resource_types?: string[];
-    host_base_type?: string[];
-}
-export interface RuleDslTopologyHop {
-    hop: string;
-    from: Record<string, unknown>;
-    to: Record<string, unknown>;
-    edge: {
-        kind: string;
-    };
-    constraints?: Record<string, unknown>;
-}
-export interface RuleDslClosure {
-    required_hops: string[];
-    failure_map: Partial<Record<string, RuntimeClaimFailureReason>>;
-}
-export interface RuleDslClaims {
-    guarantees: string[];
-    non_guarantees: string[];
-    next_action: string;
-}
-export interface UnityResourceBinding {
-    kind: 'asset_ref_loads_components' | 'method_triggers_field_load' | 'method_triggers_scene_load' | 'method_triggers_method';
-    description?: string;
-    ref_field_pattern?: string;
-    target_entry_points?: string[];
-    host_class_pattern?: string;
-    field_name?: string;
-    loader_methods?: string[];
-    scene_name?: string;
-    source_class_pattern?: string;
-    source_method?: string;
-    target_class_pattern?: string;
-    target_method?: string;
-}
-export interface LifecycleOverrides {
-    additional_entry_points?: string[];
-    scope?: string;
-}
-export interface RuleDslDraft {
-    id: string;
-    version: string;
-    description?: string;
-    match: RuleDslMatch;
-    topology: RuleDslTopologyHop[];
-    closure: RuleDslClosure;
-    claims: RuleDslClaims;
-    resource_bindings?: UnityResourceBinding[];
-    lifecycle_overrides?: LifecycleOverrides;
-}

package/dist/rule-lab/types.js

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

package/skills/_shared/unity-rule-authoring-contract.md

@@ -1,64 +0,0 @@
-# Unity Rule Authoring Contract
-
-## Scope
-
-This contract defines the stable public authoring workflow for
-`gitnexus-unity-rule-gen`.
-
-The only public path is direct rule authoring and validation:
-
-`approved/*.yaml -> rule-lab compile -> analyze -> CLI validation`
-
-## Workflow Position
-
-1. `gap-lab` is historical context only and not part of the active workflow.
-2. Default authoring path is reduced `rule-lab` for sparse irregular gaps.
-3. Query-time runtime closure remains graph-only.
-
-## Input Schema
-
-Each authoring item must be an exact source/target pair (or explicit pair set):
-
-- `source_class`
-- `source_method`
-- `target_class`
-- `target_method`
-- `expected_missing_hop` (short text)
-
-If multiple anchors match, user must select the intended anchor explicitly.
-Auto-guessing ambiguous anchors is forbidden.
-
-## Mandatory Guards
-
-1. Duplicate-prevention:
-   - Block proposals already covered by `.gitnexus/rules/approved/*.yaml`.
-2. Fail-closed binding resolution:
-   - Unresolved bindings block progress.
-   - `UnknownClass` / `UnknownMethod` placeholders are forbidden.
-3. Non-empty evidence before promote:
-   - `confirmed_chain.steps` (or equivalent) must be non-empty.
-
-## Artifact Expectations
-
-Primary artifacts are under `.gitnexus/rules/lab/runs/<run_id>/...`.
-
-Run/slice identifiers are internal artifact locators. Public operator guidance must
-not require run orchestration as the primary flow.
-
-## Event/Delegate Boundary
-
-Event/delegate system-wide coverage is analyzer-native scope:
-
-- capture `assignment_expression` (`+=`, `-=`)
-- index delegate/action field symbols
-- capture generic event-type metadata (`Raise<T>` / `Listen<T>`)
-
-Rule authoring is only for sparse, explicitly scoped residual gaps.
-
-## Verification Contract
-
-1. Promote only after mandatory guards pass.
-2. Compile approved rules before analyze.
-3. Verify in a fresh CLI process (`gitnexus cypher` / `gitnexus query`).
-4. Under `hydration_policy=strict` with `fallbackToCompact=true`, parity rerun
-   is required before final closure conclusion.

package/skills/gitnexus-unity-rule-gen.md

@@ -1,107 +0,0 @@
----
-name: gitnexus-unity-rule-gen
-description: "Reduced rule-lab workflow for Unity analyze_rules authoring from exact source/target gaps. Use when: 'create unity rules', 'generate analyze rules', 'fill sparse runtime gap'."
----
-
-# Unity Reduced Rule-Lab Authoring
-
-This skill is the post-rollback workflow.
-
-Primary path:
-
-1. Gather user-confirmed exact source/target pair(s).
-2. Curate/promote to `rules/approved/*.yaml`.
-3. Compile approved rules.
-4. Re-run analyze and verify via CLI graph checks (not MCP session query/context).
-
-`gap-lab` is migration history only and is not part of active operator guidance.
-
-Read first:
-
-- `gitnexus/skills/_shared/unity-rule-authoring-contract.md`
-- `docs/unity-runtime-process-source-of-truth.md`
-- `docs/gap-lab-rule-lab-architecture.md`
-
-## Hard Boundaries
-
-1. Query-time runtime closure remains graph-only.
-2. Event/delegate large-scale gaps are analyzer work, not rule-authoring work.
-3. This skill is for sparse irregular gaps only.
-
-## Input Contract (required)
-
-Provide exact pair intent for each candidate:
-
-- source class + source method
-- target class + target method
-- expected missing runtime hop
-
-If anchors are ambiguous (multiple candidate methods/classes), stop and ask user to choose explicit options. Do not auto-guess.
-
-## Direct Public Flow
-
-### Phase A: Prepare exact pairs
-
-1. Confirm repo and index freshness.
-2. Normalize candidate pairs into explicit source/target tuples.
-3. Run duplicate precheck against `.gitnexus/rules/approved/*.yaml`.
-
-### Phase B: Review and curate
-
-```bash
-gitnexus rule-lab analyze --repo-path "$REPO_PATH"
-RUN_ID="$(ls -1t "$REPO_PATH/.gitnexus/rules/lab/runs" | head -n 1)"
-SLICE_ID="$(find "$REPO_PATH/.gitnexus/rules/lab/runs/$RUN_ID/slices" -name 'slice.json' -maxdepth 2 | head -n 1 | xargs -I{} basename "$(dirname "{}")")"
-gitnexus rule-lab review-pack --repo-path "$REPO_PATH" --run-id "$RUN_ID" --slice-id "$SLICE_ID"
-gitnexus rule-lab curate --repo-path "$REPO_PATH" --run-id "$RUN_ID" --slice-id "$SLICE_ID" --input-path "$CURATION_JSON_PATH"
-```
-
-Use `analyze` as proposal generation for exact pairs, then curate/promote only proposals that pass guards.
-Do not ask users to provide `run-id`/`slice-id`; resolve them from generated artifacts.
-
-### Phase C: Promote approved rule
-
-```bash
-gitnexus rule-lab promote --repo-path "$REPO_PATH" --run-id "$RUN_ID" --slice-id "$SLICE_ID"
-```
-
-### Phase D: Compile and re-index
-
-```bash
-gitnexus rule-lab compile --repo-path "$REPO_PATH" --family analyze_rules
-gitnexus analyze -f "$REPO_PATH"
-```
-
-## Three Mandatory Guards
-
-1. Duplicate-prevention:
-   - Block if pair already covered by `rules/approved/*.yaml`.
-2. Fail-closed binding resolution:
-   - Block if unresolved binding remains.
-   - `UnknownClass` / `UnknownMethod` placeholders are forbidden.
-3. Non-empty evidence before promote:
-   - `confirmed_chain.steps` (or equivalent) must be non-empty.
-
-## Verification
-
-1. Verify synthetic edges with **CLI in a fresh process** (for example `gitnexus cypher` / `gitnexus query`).
-2. Do not use current MCP session `query/context` as synthetic-edge acceptance evidence immediately after analyze/rebuild.
-3. Inspect analyze summary `rule_binding.*` diagnostics:
-   - `rule_binding.agent_report: should_report=false` → no anomaly to report.
-   - `rule_binding.agent_report: should_report=true` → summarize `rule_binding.anomaly:*` in your run report.
-4. Keep closure claims aligned to graph-only semantics.
-5. Under `hydration_policy=strict` with `fallbackToCompact=true`, run parity before final closure conclusion.
-
-Suggested acceptance check (example):
-
-```bash
-gitnexus cypher --repo "$REPO_ALIAS" \
-  "MATCH (a)-[r:CodeRelation {type:'CALLS'}]->(b)
-   WHERE r.reason STARTS WITH 'unity-rule-'
-   RETURN a.name, b.name, r.reason
-   LIMIT 50"
-```
-
-## Legacy Note
-
-If historical `.gitnexus/gap-lab/runs/**` artifacts exist, treat them as migration evidence only. Do not require gap-lab parity/coverage gates for direct `approved -> compile -> analyze -> CLI validation` loops.