@veewo/gitnexus 1.5.0-rc.4 → 1.5.1

package/dist/benchmark/agent-safe-query-context/runner.test.js

@@ -0,0 +1,290 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { runWorkflowReplay } from './runner.js';
+const fakeCase = {
+    label: 'weapon_powerup',
+    start_query: 'weapon powerup equip chain',
+    retry_query: '1_weapon_orb_key.asset WeaponPowerUp HoldPickup EquipWithEvent Equip',
+    proof_contexts: ['WeaponPowerUp'],
+    proof_cypher: "MATCH (src)-[:CodeRelation {type: 'CALLS'}]->(dst) WHERE src.name IN ['HoldPickup', 'EquipWithEvent'] RETURN src.name, dst.name",
+    tool_plan: [
+        { tool: 'query', input: { query: 'weapon powerup equip chain' } },
+        { tool: 'context', input: { name: 'WeaponPowerUp' } },
+        { tool: 'cypher', input: { query: "MATCH (src)-[:CodeRelation {type: 'CALLS'}]->(dst) RETURN src.name, dst.name" } },
+    ],
+    live_task: {
+        objective: 'Investigate WeaponPowerUp from the provided asset seed and return the strongest supported pickup/equip runtime relation.',
+        symbol_seed: 'WeaponPowerUp',
+        resource_seed: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+    },
+    semantic_tuple: {
+        resource_anchor: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+        symbol_anchor: 'WeaponPowerUp',
+        proof_edges: [
+            'HoldPickup -> WeaponPowerUp.PickItUp',
+            'EquipWithEvent -> WeaponPowerUp.Equip',
+        ],
+        closure_status: 'not_verified_full',
+    },
+};
+test('workflow replay narrows query only when retry triggers fire', async () => {
+    const calls = [];
+    let queryCount = 0;
+    const fakeRunner = {
+        async query(input) {
+            calls.push({ tool: 'query', input });
+            queryCount += 1;
+            if (queryCount === 1) {
+                return {
+                    candidates: [{ name: 'FallbackCandidate' }],
+                    resource_hints: [{ path: 'Assets/Other/OffTarget.asset' }],
+                };
+            }
+            return {
+                candidates: [{ name: 'WeaponPowerUp' }],
+                resource_hints: [
+                    {
+                        path: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+                    },
+                ],
+            };
+        },
+        async context(input) {
+            calls.push({ tool: 'context', input });
+            return {
+                symbol: { name: 'WeaponPowerUp' },
+                incoming: {
+                    CALLS: [{ name: 'HoldPickup' }, { name: 'EquipWithEvent' }],
+                },
+                outgoing: {
+                    CALLS: [{ name: 'PickItUp' }, { name: 'Equip' }],
+                },
+            };
+        },
+        async cypher(input) {
+            calls.push({ tool: 'cypher', input });
+            return {
+                row_count: 2,
+                rows: [
+                    { src: 'HoldPickup', dst: 'PickItUp' },
+                    { src: 'EquipWithEvent', dst: 'Equip' },
+                ],
+            };
+        },
+    };
+    const result = await runWorkflowReplay(fakeCase, fakeRunner);
+    assert.equal(result.tool_calls_to_completion, 4);
+    assert.equal(result.retry_breakdown.query_retry_count, 1);
+    assert.equal(result.retry_breakdown.context_retry_count, 0);
+    assert.equal(result.semantic_tuple_pass, true);
+    assert.equal(result.stop_reason, 'semantic_tuple_satisfied');
+    assert.equal(calls.map((entry) => entry.tool).join(','), 'query,query,context,cypher');
+});
+test('workflow replay applies response_profile to query and context calls', async () => {
+    const calls = [];
+    const fakeRunner = {
+        async query(input) {
+            calls.push({ tool: 'query', input });
+            return {
+                candidates: [{ name: 'WeaponPowerUp' }],
+                resource_hints: [{ path: fakeCase.semantic_tuple.resource_anchor }],
+            };
+        },
+        async context(input) {
+            calls.push({ tool: 'context', input });
+            return {
+                symbol: { name: 'WeaponPowerUp' },
+                incoming: {
+                    CALLS: [{ name: 'HoldPickup' }, { name: 'EquipWithEvent' }],
+                },
+                outgoing: {
+                    CALLS: [{ name: 'PickItUp' }, { name: 'Equip' }],
+                },
+            };
+        },
+        async cypher(input) {
+            calls.push({ tool: 'cypher', input });
+            return {
+                row_count: 2,
+                rows: [
+                    { src: 'HoldPickup', dst: 'PickItUp' },
+                    { src: 'EquipWithEvent', dst: 'Equip' },
+                ],
+            };
+        },
+    };
+    const result = await runWorkflowReplay(fakeCase, fakeRunner, { responseProfile: 'slim' });
+    const queryCalls = calls.filter((entry) => entry.tool === 'query');
+    const contextCalls = calls.filter((entry) => entry.tool === 'context');
+    assert.equal(queryCalls.every((entry) => entry.input.response_profile === 'slim'), true);
+    assert.equal(contextCalls.every((entry) => entry.input.response_profile === 'slim'), true);
+    assert.equal(result.guid_invariance_pass, true);
+    assert.equal(result.guid_variant?.primary_candidate, result.base?.primary_candidate);
+    assert.equal(result.guid_variant?.recommended_follow_up, result.base?.recommended_follow_up);
+});
+test('workflow replay exposes drift-sensitive metrics from the first-hop output and ambiguity detours', async () => {
+    const fakeRunner = {
+        async query() {
+            return {
+                decision: {
+                    primary_candidate: 'FallbackCandidate',
+                    recommended_follow_up: 'resource_path_prefix=Assets/Other/OffTarget.asset',
+                },
+                candidates: [{ name: 'FallbackCandidate' }],
+                resource_hints: [{ target: 'Assets/Other/OffTarget.asset' }],
+            };
+        },
+        async context() {
+            return {
+                status: 'ambiguous',
+                candidates: [
+                    { name: 'WeaponPowerUp', uid: 'Class:A' },
+                    { name: 'WeaponPowerUp', uid: 'Class:B' },
+                ],
+            };
+        },
+        async cypher() {
+            return {
+                row_count: 2,
+                rows: [
+                    { src: 'HoldPickup', dst: 'PickItUp' },
+                    { src: 'EquipWithEvent', dst: 'Equip' },
+                ],
+            };
+        },
+    };
+    const result = await runWorkflowReplay(fakeCase, fakeRunner, { maxSteps: 3, responseProfile: 'slim' });
+    assert.equal(result.anchor_top1_pass, false);
+    assert.equal(result.recommended_follow_up_hit, false);
+    assert.equal(result.post_narrowing_anchor_pass, false);
+    assert.equal(result.post_narrowing_follow_up_hit, false);
+    assert.equal(result.ambiguity_detour_count, 1);
+});
+test('workflow replay tracks post-narrowing convergence separately from first-hop drift', async () => {
+    let queryCount = 0;
+    const fakeRunner = {
+        async query() {
+            queryCount += 1;
+            if (queryCount === 1) {
+                return {
+                    decision: {
+                        primary_candidate: 'FallbackCandidate',
+                        recommended_follow_up: 'resource_path_prefix=Assets/Other/OffTarget.asset',
+                    },
+                    candidates: [{ name: 'FallbackCandidate' }],
+                    resource_hints: [{ target: 'Assets/Other/OffTarget.asset' }],
+                };
+            }
+            return {
+                decision: {
+                    primary_candidate: 'WeaponPowerUp',
+                    recommended_follow_up: `resource_path_prefix=${fakeCase.semantic_tuple.resource_anchor}`,
+                },
+                candidates: [{ name: 'WeaponPowerUp' }],
+                resource_hints: [{ target: fakeCase.semantic_tuple.resource_anchor }],
+            };
+        },
+        async context() {
+            return {
+                status: 'ambiguous',
+                candidates: [{ name: 'WeaponPowerUp', uid: 'Class:A' }],
+            };
+        },
+        async cypher() {
+            return {
+                row_count: 2,
+                rows: [
+                    { src: 'HoldPickup', dst: 'PickItUp' },
+                    { src: 'EquipWithEvent', dst: 'Equip' },
+                ],
+            };
+        },
+    };
+    const result = await runWorkflowReplay(fakeCase, fakeRunner, { maxSteps: 4, responseProfile: 'slim' });
+    assert.equal(result.anchor_top1_pass, false);
+    assert.equal(result.recommended_follow_up_hit, false);
+    assert.equal(result.post_narrowing_anchor_pass, true);
+    assert.equal(result.post_narrowing_follow_up_hit, true);
+});
+test('workflow replay flags unrelated placeholder follow-up leakage', async () => {
+    const fakeRunner = {
+        async query() {
+            return {
+                decision: {
+                    primary_candidate: 'WeaponPowerUp',
+                    recommended_follow_up: 'resource_path_prefix=Reload NEON.Game.Graph.Nodes.Reloads',
+                },
+                summary: 'WeaponPowerUp flow',
+                candidates: [{ name: 'WeaponPowerUp' }],
+                resource_hints: [{ target: fakeCase.semantic_tuple.resource_anchor }],
+            };
+        },
+        async context() {
+            return {
+                symbol: { name: 'WeaponPowerUp' },
+            };
+        },
+        async cypher() {
+            return {
+                row_count: 2,
+                rows: [
+                    { src: 'HoldPickup', dst: 'PickItUp' },
+                    { src: 'EquipWithEvent', dst: 'Equip' },
+                ],
+            };
+        },
+    };
+    const result = await runWorkflowReplay(fakeCase, fakeRunner, { maxSteps: 4, responseProfile: 'slim' });
+    assert.equal(result.semantic_tuple_pass, true);
+    assert.equal(result.placeholder_leak_detected, true);
+    assert.equal(result.live_tool_evidence_pass, true);
+    assert.equal(result.freeze_ready, (result.confirmed_chain?.steps.length ?? 0) > 0
+        && !result.placeholder_leak_detected
+        && Boolean(result.live_tool_evidence_pass)
+        && result.guid_invariance_pass);
+    assert.equal((result.confirmed_chain?.steps.length ?? 0) > 0, false);
+});
+test('workflow replay surfaces heuristic first-screen drift separately from semantic tuple pass', async () => {
+    const fakeRunner = {
+        async query() {
+            return {
+                summary: 'runtime heuristic clue',
+                decision: {
+                    primary_candidate: 'WeaponPowerUp',
+                    recommended_follow_up: `resource_path_prefix=${fakeCase.semantic_tuple.resource_anchor}`,
+                },
+                process_hints: [
+                    {
+                        summary: 'runtime heuristic clue',
+                        confidence: 'low',
+                        evidence_mode: 'resource_heuristic',
+                    },
+                    {
+                        summary: 'Unity-runtime-root -> WeaponPowerUp',
+                        confidence: 'high',
+                        evidence_mode: 'direct_step',
+                    },
+                ],
+                candidates: [{ name: 'WeaponPowerUp' }],
+                resource_hints: [{ target: fakeCase.semantic_tuple.resource_anchor }],
+            };
+        },
+        async context() {
+            return {
+                symbol: { name: 'WeaponPowerUp' },
+            };
+        },
+        async cypher() {
+            return {
+                row_count: 2,
+                rows: [
+                    { src: 'HoldPickup', dst: 'PickItUp' },
+                    { src: 'EquipWithEvent', dst: 'Equip' },
+                ],
+            };
+        },
+    };
+    const result = await runWorkflowReplay(fakeCase, fakeRunner, { maxSteps: 4, responseProfile: 'slim' });
+    assert.equal(result.semantic_tuple_pass, true);
+    assert.equal(result.heuristic_top_summary_detected, true);
+});

package/dist/benchmark/agent-safe-query-context/semantic-tuple.d.ts

@@ -0,0 +1,20 @@
+import type { SemanticTuple } from './types.js';
+export type LiveFailureClass = 'semantic_drift' | 'evidence_missing' | 'expression_mismatch' | 'over_investigated';
+export interface LiveTupleScore {
+    normalized_tuple: SemanticTuple;
+    normalized_tuple_pass: boolean;
+    evidence_validation_pass: boolean;
+    failure_class?: LiveFailureClass;
+}
+export declare function semanticTuplePass(actual: SemanticTuple, expected: SemanticTuple): boolean;
+export declare function scoreLiveTuple(expected: SemanticTuple, finalResult: {
+    resource_anchor?: unknown;
+    symbol_anchor?: unknown;
+    proof_edge?: unknown;
+    proof_edges?: unknown;
+    closure_status?: unknown;
+}, outputs: unknown[], options?: {
+    toolCalls?: number;
+    overInvestigatedThreshold?: number;
+}): LiveTupleScore;
+export declare function deriveSemanticTuple(expected: SemanticTuple, outputs: unknown[]): SemanticTuple;

package/dist/benchmark/agent-safe-query-context/semantic-tuple.js

@@ -0,0 +1,225 @@
+export function semanticTuplePass(actual, expected) {
+    return JSON.stringify(normalizeTuple(actual)) === JSON.stringify(normalizeTuple(expected));
+}
+export function scoreLiveTuple(expected, finalResult, outputs, options = {}) {
+    const normalizedTuple = normalizeLiveTuple(expected, finalResult);
+    const normalizedTuplePass = semanticTuplePass(normalizedTuple, expected);
+    const evidenceTuple = deriveSemanticTuple(expected, outputs);
+    const evidenceValidationPass = semanticTuplePass(evidenceTuple, expected);
+    const failureClass = classifyLiveFailure(expected, normalizedTuple, normalizedTuplePass, evidenceValidationPass, options);
+    return {
+        normalized_tuple: normalizedTuple,
+        normalized_tuple_pass: normalizedTuplePass,
+        evidence_validation_pass: evidenceValidationPass,
+        failure_class: failureClass,
+    };
+}
+export function deriveSemanticTuple(expected, outputs) {
+    return {
+        resource_anchor: hasExactString(outputs, expected.resource_anchor) ? expected.resource_anchor : '',
+        symbol_anchor: hasExactString(outputs, expected.symbol_anchor) ? expected.symbol_anchor : '',
+        proof_edge: expected.proof_edge && hasProofEdge(outputs, expected.proof_edge) ? expected.proof_edge : undefined,
+        proof_edges: expected.proof_edges?.filter((edge) => hasProofEdge(outputs, edge)),
+        closure_status: expected.closure_status,
+    };
+}
+function normalizeLiveTuple(expected, finalResult) {
+    const normalizedResourceAnchor = normalizeResourceAnchor(expected.resource_anchor, finalResult.resource_anchor);
+    const normalizedSymbolAnchor = normalizeSymbolAnchor(expected.symbol_anchor, finalResult.symbol_anchor);
+    const reportedEdges = collectReportedEdges(finalResult.proof_edge, finalResult.proof_edges);
+    const normalizedProofEdge = expected.proof_edge && containsExpectedEdge(expected.proof_edge, reportedEdges)
+        ? expected.proof_edge
+        : undefined;
+    const normalizedProofEdges = expected.proof_edges?.filter((edge) => containsExpectedEdge(edge, reportedEdges));
+    const closureStatus = isClosureStatus(finalResult.closure_status) ? finalResult.closure_status : expected.closure_status;
+    return {
+        resource_anchor: normalizedResourceAnchor,
+        symbol_anchor: normalizedSymbolAnchor,
+        proof_edge: normalizedProofEdge,
+        proof_edges: normalizedProofEdges,
+        closure_status: closureStatus,
+    };
+}
+function normalizeTuple(tuple) {
+    return {
+        resource_anchor: tuple.resource_anchor,
+        symbol_anchor: tuple.symbol_anchor,
+        proof_edge: tuple.proof_edge,
+        proof_edges: tuple.proof_edges ? [...tuple.proof_edges].sort() : undefined,
+        closure_status: tuple.closure_status,
+    };
+}
+function hasExactString(outputs, expected) {
+    return outputs.some((output) => valueContainsString(output, expected));
+}
+function hasProofEdge(outputs, edge) {
+    if (hasExactString(outputs, edge)) {
+        return true;
+    }
+    const parsed = parseProofEdge(edge);
+    if (!parsed) {
+        return false;
+    }
+    return outputs.some((output) => valueContainsEdge(output, parsed.source, parsed.targetMethod));
+}
+function containsExpectedEdge(expectedEdge, reportedEdges) {
+    const parsedExpected = parseProofEdge(expectedEdge);
+    if (!parsedExpected) {
+        return false;
+    }
+    return reportedEdges.some((edge) => edge.source === parsedExpected.source && edge.targetMethod === parsedExpected.targetMethod);
+}
+function normalizeResourceAnchor(expectedResource, candidate) {
+    if (typeof candidate !== 'string') {
+        return '';
+    }
+    return candidate === expectedResource ? expectedResource : '';
+}
+function normalizeSymbolAnchor(expectedSymbol, candidate) {
+    if (typeof candidate !== 'string') {
+        return '';
+    }
+    const normalizedCandidate = candidate.trim();
+    if (normalizedCandidate === expectedSymbol || normalizedCandidate.endsWith(`.${expectedSymbol}`)) {
+        return expectedSymbol;
+    }
+    return '';
+}
+function collectReportedEdges(proofEdge, proofEdges) {
+    const collected = [];
+    collectEdgesRecursive(proofEdge, collected);
+    collectEdgesRecursive(proofEdges, collected);
+    return collected;
+}
+function collectEdgesRecursive(value, collected) {
+    if (!value) {
+        return;
+    }
+    if (typeof value === 'string') {
+        const parsed = parseProofEdge(value);
+        if (parsed) {
+            collected.push(parsed);
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry) => collectEdgesRecursive(entry, collected));
+        return;
+    }
+    if (typeof value !== 'object') {
+        return;
+    }
+    const record = value;
+    const pairs = [
+        [record.src, record.dst],
+        [record.source, record.target],
+        [record.caller, record.callee],
+        [record.from, record.to],
+    ];
+    for (const [left, right] of pairs) {
+        const parsed = parseEdgeFromPair(left, right);
+        if (parsed) {
+            collected.push(parsed);
+        }
+    }
+    Object.values(record).forEach((entry) => collectEdgesRecursive(entry, collected));
+}
+function parseEdgeFromPair(left, right) {
+    const source = extractName(left);
+    const target = extractName(right);
+    if (!source || !target) {
+        return null;
+    }
+    const targetMethod = target.split('.').pop() || target;
+    return { source, targetMethod };
+}
+function extractName(value) {
+    if (typeof value === 'string') {
+        return value.split('.').pop() || value;
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        return (extractName(record.name) ||
+            extractName(record.id) ||
+            extractName(record.uid) ||
+            extractName(record.symbol) ||
+            null);
+    }
+    return null;
+}
+function classifyLiveFailure(expected, normalizedTuple, normalizedTuplePass, evidenceValidationPass, options) {
+    if (normalizedTuplePass && evidenceValidationPass) {
+        return undefined;
+    }
+    if (normalizedTuplePass && !evidenceValidationPass) {
+        return 'evidence_missing';
+    }
+    const overInvestigatedThreshold = options.overInvestigatedThreshold ?? 6;
+    if ((options.toolCalls ?? 0) > overInvestigatedThreshold) {
+        return 'over_investigated';
+    }
+    const anchorDrift = normalizedTuple.resource_anchor !== expected.resource_anchor
+        || normalizedTuple.symbol_anchor !== expected.symbol_anchor;
+    return anchorDrift ? 'semantic_drift' : 'expression_mismatch';
+}
+function isClosureStatus(value) {
+    return value === 'not_verified_full' || value === 'verified_partial' || value === 'verified_full' || value === 'failed';
+}
+function valueContainsString(value, expected) {
+    if (typeof value === 'string') {
+        return value.includes(expected);
+    }
+    if (Array.isArray(value)) {
+        return value.some((entry) => valueContainsString(entry, expected));
+    }
+    if (value && typeof value === 'object') {
+        return Object.values(value).some((entry) => valueContainsString(entry, expected));
+    }
+    return false;
+}
+function valueContainsEdge(value, source, targetMethod) {
+    if (typeof value === 'string') {
+        return (value.includes(`| ${source} | ${targetMethod} |`)
+            || value.includes(`${source} -> ${targetMethod}`));
+    }
+    if (Array.isArray(value)) {
+        return value.some((entry) => valueContainsEdge(entry, source, targetMethod));
+    }
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const record = value;
+    const pairs = [
+        [record.src, record.dst],
+        [record.source, record.target],
+        [record.caller, record.callee],
+        [record.from, record.to],
+    ];
+    for (const [left, right] of pairs) {
+        if (matchName(left, source) && matchName(right, targetMethod)) {
+            return true;
+        }
+    }
+    return Object.values(record).some((entry) => valueContainsEdge(entry, source, targetMethod));
+}
+function matchName(value, expected) {
+    if (typeof value === 'string') {
+        return value === expected || value.endsWith(`.${expected}`);
+    }
+    if (value && typeof value === 'object') {
+        const record = value;
+        return (matchName(record.name, expected) ||
+            matchName(record.id, expected) ||
+            matchName(record.uid, expected));
+    }
+    return false;
+}
+function parseProofEdge(edge) {
+    const [sourcePart, targetPart] = edge.split('->').map((part) => part.trim());
+    if (!sourcePart || !targetPart) {
+        return null;
+    }
+    const source = sourcePart.split('.').pop() || sourcePart;
+    const targetMethod = targetPart.split('.').pop() || targetPart;
+    return { source, targetMethod };
+}

package/dist/benchmark/agent-safe-query-context/semantic-tuple.test.d.ts

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

package/dist/benchmark/agent-safe-query-context/semantic-tuple.test.js

@@ -0,0 +1,122 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { scoreLiveTuple, semanticTuplePass } from './semantic-tuple.js';
+test('semanticTuplePass returns true for identical tuples', () => {
+    const tuple = {
+        resource_anchor: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+        symbol_anchor: 'WeaponPowerUp',
+        proof_edges: [
+            'HoldPickup -> WeaponPowerUp.PickItUp',
+            'EquipWithEvent -> WeaponPowerUp.Equip',
+        ],
+        closure_status: 'not_verified_full',
+    };
+    assert.equal(semanticTuplePass(tuple, tuple), true);
+});
+test('semanticTuplePass returns false when any tuple field differs', () => {
+    const left = {
+        resource_anchor: 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset',
+        symbol_anchor: 'ReloadBase',
+        proof_edge: 'ReloadBase.GetValue -> ReloadBase.CheckReload',
+        closure_status: 'not_verified_full',
+    };
+    const right = {
+        ...left,
+        proof_edge: 'ReloadBase.GetValue -> ReloadBase.ReloadRoutine',
+    };
+    assert.equal(semanticTuplePass(left, right), false);
+});
+test('scoreLiveTuple normalizes fully-qualified symbol identity to canonical anchor', () => {
+    const expected = {
+        resource_anchor: 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset',
+        symbol_anchor: 'ReloadBase',
+        proof_edge: 'ReloadBase.GetValue -> ReloadBase.CheckReload',
+        closure_status: 'not_verified_full',
+    };
+    const score = scoreLiveTuple(expected, {
+        resource_anchor: expected.resource_anchor,
+        symbol_anchor: 'Game.Runtime.ReloadBase',
+        proof_edge: 'ReloadBase.GetValue -> ReloadBase.CheckReload',
+        closure_status: 'not_verified_full',
+    }, [
+        { text: expected.resource_anchor },
+        { symbol: 'ReloadBase' },
+        { src: 'GetValue', dst: 'CheckReload' },
+    ]);
+    assert.equal(score.normalized_tuple.symbol_anchor, 'ReloadBase');
+    assert.equal(score.normalized_tuple_pass, true);
+    assert.equal(score.evidence_validation_pass, true);
+});
+test('scoreLiveTuple normalizes caller/callee objects to canonical proof edges', () => {
+    const expected = {
+        resource_anchor: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+        symbol_anchor: 'WeaponPowerUp',
+        proof_edges: [
+            'HoldPickup -> WeaponPowerUp.PickItUp',
+            'EquipWithEvent -> WeaponPowerUp.Equip',
+        ],
+        closure_status: 'not_verified_full',
+    };
+    const score = scoreLiveTuple(expected, {
+        resource_anchor: expected.resource_anchor,
+        symbol_anchor: expected.symbol_anchor,
+        proof_edges: [
+            { caller: 'HoldPickup', callee: 'WeaponPowerUp.PickItUp' },
+            { caller: 'EquipWithEvent', callee: 'WeaponPowerUp.Equip' },
+        ],
+        closure_status: 'not_verified_full',
+    }, [
+        { value: expected.resource_anchor },
+        { symbol: 'WeaponPowerUp' },
+        { src: 'HoldPickup', dst: 'PickItUp' },
+        { src: 'EquipWithEvent', dst: 'Equip' },
+    ]);
+    assert.equal(score.normalized_tuple_pass, true);
+    assert.equal(score.evidence_validation_pass, true);
+});
+test('scoreLiveTuple classifies evidence_missing when normalized tuple passes without telemetry evidence', () => {
+    const expected = {
+        resource_anchor: 'Assets/NEON/Graphs/PlayerGun/Gungraph_use/1_weapon_orb_key.asset',
+        symbol_anchor: 'ReloadBase',
+        proof_edge: 'ReloadBase.GetValue -> ReloadBase.CheckReload',
+        closure_status: 'not_verified_full',
+    };
+    const score = scoreLiveTuple(expected, {
+        resource_anchor: expected.resource_anchor,
+        symbol_anchor: expected.symbol_anchor,
+        proof_edge: expected.proof_edge,
+        closure_status: 'not_verified_full',
+    }, [{ output: 'no reload edge evidence here' }]);
+    assert.equal(score.normalized_tuple_pass, true);
+    assert.equal(score.evidence_validation_pass, false);
+    assert.equal(score.failure_class, 'evidence_missing');
+});
+test('scoreLiveTuple emits semantic_drift, expression_mismatch, and over_investigated failure classes', () => {
+    const expected = {
+        resource_anchor: 'Assets/NEON/DataAssets/Powerups/1_newWeapon/0_pick/法器_Orb/1_weapon_orb_key.asset',
+        symbol_anchor: 'WeaponPowerUp',
+        proof_edges: [
+            'HoldPickup -> WeaponPowerUp.PickItUp',
+            'EquipWithEvent -> WeaponPowerUp.Equip',
+        ],
+        closure_status: 'not_verified_full',
+    };
+    const semanticDrift = scoreLiveTuple(expected, {
+        resource_anchor: expected.resource_anchor,
+        symbol_anchor: 'WrongSymbol',
+        proof_edges: [{ caller: 'HoldPickup', callee: 'WeaponPowerUp.PickItUp' }],
+    }, []);
+    assert.equal(semanticDrift.failure_class, 'semantic_drift');
+    const expressionMismatch = scoreLiveTuple(expected, {
+        resource_anchor: expected.resource_anchor,
+        symbol_anchor: expected.symbol_anchor,
+        proof_edges: [{ caller: 'HoldPickup', callee: 'WeaponPowerUp.NotEquip' }],
+    }, []);
+    assert.equal(expressionMismatch.failure_class, 'expression_mismatch');
+    const overInvestigated = scoreLiveTuple(expected, {
+        resource_anchor: expected.resource_anchor,
+        symbol_anchor: expected.symbol_anchor,
+        proof_edges: [{ caller: 'HoldPickup', callee: 'WeaponPowerUp.NotEquip' }],
+    }, [], { toolCalls: 8, overInvestigatedThreshold: 6 });
+    assert.equal(overInvestigated.failure_class, 'over_investigated');
+});