@veewo/gitnexus 1.5.0 → 1.5.2

package/dist/benchmark/agent-safe-query-context/subagent-live.d.ts

@@ -0,0 +1,47 @@
+import { type LiveFailureClass } from './semantic-tuple.js';
+import type { AgentSafeBenchmarkCase, SemanticTuple } from './types.js';
+export interface TelemetryStep {
+    tool: 'query' | 'context' | 'cypher';
+    input: Record<string, unknown>;
+    output: unknown;
+    durationMs: number;
+    totalTokensEst: number;
+    timestamp: string;
+}
+export interface SubagentFinalResult {
+    resource_anchor?: string;
+    symbol_anchor?: string;
+    proof_edge?: unknown;
+    proof_edges?: unknown;
+    closure_status?: SemanticTuple['closure_status'];
+    summary?: string;
+}
+export interface SubagentLiveResult {
+    prompt: string;
+    prompt_path: string;
+    result_path: string;
+    telemetry_path: string;
+    final_result: SubagentFinalResult;
+    steps: TelemetryStep[];
+    semantic_tuple: SemanticTuple;
+    normalized_tuple_pass: boolean;
+    evidence_validation_pass: boolean;
+    failure_class?: LiveFailureClass;
+    semantic_tuple_pass: boolean;
+    tool_calls_to_completion: number;
+    tokens_to_completion: number;
+    stop_reason: 'semantic_tuple_satisfied' | 'agent_result_incomplete';
+}
+export declare function buildSubagentPrompt(benchmarkCase: AgentSafeBenchmarkCase, options: {
+    repo: string;
+    runDir: string;
+    resultPath: string;
+}): string;
+export declare function prepareSubagentCaseRun(runDir: string, benchmarkCase: AgentSafeBenchmarkCase, options: {
+    repo: string;
+}): Promise<{
+    promptPath: string;
+    resultPath: string;
+    prompt: string;
+}>;
+export declare function loadSubagentLiveCaseResult(runDir: string, benchmarkCase: AgentSafeBenchmarkCase): Promise<SubagentLiveResult>;

package/dist/benchmark/agent-safe-query-context/subagent-live.js

@@ -0,0 +1,128 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { scoreLiveTuple } from './semantic-tuple.js';
+const ALLOWED_TOOLS = new Set(['query', 'context', 'cypher']);
+export function buildSubagentPrompt(benchmarkCase, options) {
+    const wrapperCommand = [
+        'node gitnexus/dist/benchmark/agent-safe-query-context/telemetry-tool.js',
+        `--run-dir "${options.runDir}"`,
+        '--tool <query|context|cypher>',
+        `--input '<JSON>'`,
+    ].join(' ');
+    return [
+        'You are running a benchmarked GitNexus investigation.',
+        '',
+        `Case: ${benchmarkCase.label}`,
+        `Repo: ${options.repo}`,
+        `Goal category: ${benchmarkCase.live_task.objective}`,
+        '',
+        'Starting seeds:',
+        `- Symbol/class seed: ${benchmarkCase.live_task.symbol_seed}`,
+        `- Resource seed: ${benchmarkCase.live_task.resource_seed}`,
+        '',
+        'Use only this wrapper command for benchmarked evidence collection:',
+        wrapperCommand,
+        '',
+        'Rules:',
+        '- Investigate normally from the seeds. Do not assume the answer.',
+        '- Stay within the goal category and avoid switching to unrelated relation categories.',
+        '- For benchmarked GitNexus evidence collection, use only query/context/cypher through the wrapper command above.',
+        '- Stop when you have enough evidence to return your best result.',
+        '',
+        `Write your final result as JSON to: ${options.resultPath}`,
+        'Final JSON schema:',
+        '{',
+        '  "resource_anchor": "string",',
+        '  "symbol_anchor": "string",',
+        '  "proof_edge": "string (optional)",',
+        '  "proof_edges": ["string"] (optional),',
+        '  "closure_status": "not_verified_full|verified_partial|verified_full|failed",',
+        '  "summary": "short explanation"',
+        '}',
+        '',
+        'Do not include any extra wrapper calls after you have enough evidence.',
+    ].join('\n');
+}
+export async function prepareSubagentCaseRun(runDir, benchmarkCase, options) {
+    await fs.mkdir(runDir, { recursive: true });
+    const promptPath = path.join(runDir, 'prompt.txt');
+    const resultPath = path.join(runDir, 'result.json');
+    const prompt = buildSubagentPrompt(benchmarkCase, {
+        repo: options.repo,
+        runDir,
+        resultPath,
+    });
+    assertPromptContract(prompt, benchmarkCase.semantic_tuple);
+    await fs.writeFile(promptPath, prompt, 'utf-8');
+    return { promptPath, resultPath, prompt };
+}
+export async function loadSubagentLiveCaseResult(runDir, benchmarkCase) {
+    const promptPath = path.join(runDir, 'prompt.txt');
+    const telemetryPath = path.join(runDir, 'telemetry.jsonl');
+    const resultPath = path.join(runDir, 'result.json');
+    const prompt = await fs.readFile(promptPath, 'utf-8');
+    assertPromptContract(prompt, benchmarkCase.semantic_tuple);
+    const telemetryText = await fs.readFile(telemetryPath, 'utf-8');
+    const steps = telemetryText
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => validateTelemetryRow(JSON.parse(line)));
+    if (steps.length === 0) {
+        throw new Error(`missing telemetry rows: ${runDir}`);
+    }
+    const finalResult = JSON.parse(await fs.readFile(resultPath, 'utf-8'));
+    const scoring = scoreLiveTuple(benchmarkCase.semantic_tuple, finalResult, steps.map((step) => step.output), { toolCalls: steps.length });
+    const passed = scoring.normalized_tuple_pass && scoring.evidence_validation_pass;
+    return {
+        prompt,
+        prompt_path: promptPath,
+        result_path: resultPath,
+        telemetry_path: telemetryPath,
+        final_result: finalResult,
+        steps,
+        semantic_tuple: scoring.normalized_tuple,
+        normalized_tuple_pass: scoring.normalized_tuple_pass,
+        evidence_validation_pass: scoring.evidence_validation_pass,
+        failure_class: scoring.failure_class,
+        semantic_tuple_pass: passed,
+        tool_calls_to_completion: steps.length,
+        tokens_to_completion: steps.reduce((sum, step) => sum + step.totalTokensEst, 0),
+        stop_reason: passed ? 'semantic_tuple_satisfied' : 'agent_result_incomplete',
+    };
+}
+function assertPromptContract(prompt, tuple) {
+    if (!prompt.includes('telemetry-tool.js')) {
+        throw new Error('prompt missing wrapper command');
+    }
+    if (!prompt.includes('Final JSON schema:')) {
+        throw new Error('prompt missing final JSON schema');
+    }
+    if (prompt.includes('strongest supported relation') || prompt.includes('strongest validated runtime relation')) {
+        throw new Error('prompt uses open-ended strongest-relation objective wording');
+    }
+    if (tuple.proof_edge && prompt.includes(tuple.proof_edge)) {
+        throw new Error('prompt leaks canonical proof_edge');
+    }
+    if (tuple.proof_edges && tuple.proof_edges.every((edge) => prompt.includes(edge))) {
+        throw new Error('prompt leaks canonical proof_edges');
+    }
+}
+function validateTelemetryRow(row) {
+    if (!row || typeof row !== 'object') {
+        throw new Error('invalid telemetry row');
+    }
+    if (!ALLOWED_TOOLS.has(row.tool)) {
+        throw new Error(`telemetry row contains non-allowlisted tool: ${String(row.tool)}`);
+    }
+    if (!('input' in row) || !('output' in row)) {
+        throw new Error('telemetry row missing input/output');
+    }
+    if (typeof row.durationMs !== 'number' || typeof row.totalTokensEst !== 'number') {
+        throw new Error('telemetry row missing duration/token estimates');
+    }
+    if (typeof row.timestamp !== 'string' || row.timestamp.length === 0) {
+        throw new Error('telemetry row missing timestamp');
+    }
+    return row;
+}

package/dist/benchmark/agent-safe-query-context/subagent-live.test.d.ts

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

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

@@ -0,0 +1,155 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { buildSubagentPrompt, loadSubagentLiveCaseResult, prepareSubagentCaseRun } from './subagent-live.js';
+const fakeCase = {
+    label: 'weapon_powerup',
+    start_query: 'weapon powerup equip chain',
+    retry_query: 'retry',
+    proof_contexts: ['HoldPickup', 'EquipWithEvent'],
+    proof_cypher: "MATCH (src)-[:CodeRelation {type: 'CALLS'}]->(dst) WHERE (src.name = 'HoldPickup' AND dst.name = 'PickItUp') OR (src.name = 'EquipWithEvent' AND dst.name = 'Equip') RETURN src.name, dst.name",
+    tool_plan: [{ tool: 'query', input: { query: 'WeaponPowerUp' } }],
+    live_task: {
+        objective: 'pickup/equip bridge proof',
+        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('buildSubagentPrompt includes wrapper command and final JSON schema without leaking canonical proof edges', () => {
+    const prompt = buildSubagentPrompt(fakeCase, {
+        repo: 'neonspark-core',
+        runDir: '/tmp/run',
+        resultPath: '/tmp/run/result.json',
+    });
+    assert.equal(prompt.includes('telemetry-tool.js'), true);
+    assert.equal(prompt.includes('Final JSON schema:'), true);
+    assert.equal(prompt.includes('strongest supported relation'), false);
+    assert.equal(prompt.includes('pickup/equip bridge proof'), true);
+    assert.equal(prompt.includes('HoldPickup -> WeaponPowerUp.PickItUp'), false);
+    assert.equal(prompt.includes('EquipWithEvent -> WeaponPowerUp.Equip'), false);
+});
+test('prepareSubagentCaseRun writes prompt artifact', async () => {
+    const runDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-safe-run-'));
+    const prepared = await prepareSubagentCaseRun(runDir, fakeCase, { repo: 'neonspark-core' });
+    const prompt = await fs.readFile(prepared.promptPath, 'utf-8');
+    assert.equal(prompt.includes('WeaponPowerUp'), true);
+    assert.equal(prompt.includes('telemetry-tool.js'), true);
+});
+test('loadSubagentLiveCaseResult validates telemetry rows and derives semantic tuple from tool evidence', async () => {
+    const runDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-safe-run-'));
+    const promptPath = path.join(runDir, 'prompt.txt');
+    const resultPath = path.join(runDir, 'result.json');
+    const telemetryPath = path.join(runDir, 'telemetry.jsonl');
+    await fs.writeFile(promptPath, buildSubagentPrompt(fakeCase, {
+        repo: 'neonspark-core',
+        runDir,
+        resultPath,
+    }), 'utf-8');
+    await fs.writeFile(resultPath, JSON.stringify({
+        resource_anchor: fakeCase.semantic_tuple.resource_anchor,
+        symbol_anchor: fakeCase.semantic_tuple.symbol_anchor,
+        proof_edges: fakeCase.semantic_tuple.proof_edges,
+        closure_status: 'not_verified_full',
+        summary: 'Found supporting pickup/equip evidence.',
+    }, null, 2));
+    await fs.writeFile(telemetryPath, [
+        JSON.stringify({
+            tool: 'query',
+            input: { query: 'WeaponPowerUp', repo: 'neonspark-core' },
+            output: {
+                candidates: [{ name: 'WeaponPowerUp' }],
+                resource_hints: [{ target: fakeCase.semantic_tuple.resource_anchor }],
+            },
+            durationMs: 12,
+            totalTokensEst: 120,
+            timestamp: '2026-04-08T00:00:00.000Z',
+        }),
+        JSON.stringify({
+            tool: 'cypher',
+            input: { query: fakeCase.proof_cypher, repo: 'neonspark-core' },
+            output: {
+                markdown: '| src.name | dst.name |\n| --- | --- |\n| HoldPickup | PickItUp |\n| EquipWithEvent | Equip |',
+                row_count: 2,
+            },
+            durationMs: 8,
+            totalTokensEst: 80,
+            timestamp: '2026-04-08T00:00:01.000Z',
+        }),
+    ].join('\n'), 'utf-8');
+    const result = await loadSubagentLiveCaseResult(runDir, fakeCase);
+    assert.equal(result.normalized_tuple_pass, true);
+    assert.equal(result.evidence_validation_pass, true);
+    assert.equal(result.failure_class, undefined);
+    assert.equal(result.semantic_tuple_pass, true);
+    assert.equal(result.tool_calls_to_completion, 2);
+    assert.equal(result.tokens_to_completion, 200);
+});
+test('loadSubagentLiveCaseResult keeps case non-passing when evidence validation fails', async () => {
+    const runDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-safe-run-'));
+    const promptPath = path.join(runDir, 'prompt.txt');
+    const resultPath = path.join(runDir, 'result.json');
+    const telemetryPath = path.join(runDir, 'telemetry.jsonl');
+    await fs.writeFile(promptPath, buildSubagentPrompt(fakeCase, {
+        repo: 'neonspark-core',
+        runDir,
+        resultPath,
+    }), 'utf-8');
+    await fs.writeFile(resultPath, JSON.stringify({
+        resource_anchor: fakeCase.semantic_tuple.resource_anchor,
+        symbol_anchor: 'Game.Runtime.WeaponPowerUp',
+        proof_edges: [
+            { caller: 'HoldPickup', callee: 'WeaponPowerUp.PickItUp' },
+            { caller: 'EquipWithEvent', callee: 'WeaponPowerUp.Equip' },
+        ],
+        closure_status: 'not_verified_full',
+        summary: 'Normalized tuple inferred from final response.',
+    }, null, 2));
+    await fs.writeFile(telemetryPath, JSON.stringify({
+        tool: 'query',
+        input: { query: 'WeaponPowerUp', repo: 'neonspark-core' },
+        output: {
+            candidates: [{ name: 'WeaponPowerUp' }],
+            resource_hints: [{ target: fakeCase.semantic_tuple.resource_anchor }],
+        },
+        durationMs: 12,
+        totalTokensEst: 120,
+        timestamp: '2026-04-08T00:00:00.000Z',
+    }), 'utf-8');
+    const result = await loadSubagentLiveCaseResult(runDir, fakeCase);
+    assert.equal(result.normalized_tuple_pass, true);
+    assert.equal(result.evidence_validation_pass, false);
+    assert.equal(result.semantic_tuple_pass, false);
+    assert.equal(result.failure_class, 'evidence_missing');
+});
+test('loadSubagentLiveCaseResult rejects non-allowlisted tools', async () => {
+    const runDir = await fs.mkdtemp(path.join(os.tmpdir(), 'agent-safe-run-'));
+    const promptPath = path.join(runDir, 'prompt.txt');
+    const resultPath = path.join(runDir, 'result.json');
+    const telemetryPath = path.join(runDir, 'telemetry.jsonl');
+    await fs.writeFile(promptPath, buildSubagentPrompt(fakeCase, {
+        repo: 'neonspark-core',
+        runDir,
+        resultPath,
+    }), 'utf-8');
+    await fs.writeFile(resultPath, JSON.stringify({ summary: 'noop' }), 'utf-8');
+    await fs.writeFile(telemetryPath, JSON.stringify({
+        tool: 'impact',
+        input: {},
+        output: {},
+        durationMs: 1,
+        totalTokensEst: 1,
+        timestamp: '2026-04-08T00:00:00.000Z',
+    }), 'utf-8');
+    await assert.rejects(() => loadSubagentLiveCaseResult(runDir, fakeCase), /non-allowlisted tool/);
+});

package/dist/benchmark/agent-safe-query-context/telemetry-tool.d.ts

@@ -0,0 +1,9 @@
+type TelemetryToolName = 'query' | 'context' | 'cypher';
+interface TelemetryToolOptions {
+    runDir: string;
+    tool: TelemetryToolName;
+    input: Record<string, unknown>;
+}
+export declare function invokeTelemetryTool(options: TelemetryToolOptions): Promise<unknown>;
+export declare function telemetryToolMain(argv: string[]): Promise<void>;
+export {};

package/dist/benchmark/agent-safe-query-context/telemetry-tool.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs/promises';
+import { writeSync } from 'node:fs';
+import path from 'node:path';
+import { closeLbug } from '../../mcp/core/lbug-adapter.js';
+import { LocalBackend } from '../../mcp/local/local-backend.js';
+import { estimateTokens } from '../u2-e2e/metrics.js';
+export async function invokeTelemetryTool(options) {
+    const backend = new LocalBackend();
+    const ok = await backend.init();
+    if (!ok) {
+        throw new Error('No indexed repositories found. Run analyze first.');
+    }
+    const started = performance.now();
+    try {
+        const output = await backend.callTool(options.tool, options.input);
+        const durationMs = Number((performance.now() - started).toFixed(1));
+        const row = {
+            tool: options.tool,
+            input: options.input,
+            output,
+            durationMs,
+            totalTokensEst: estimateTokens(JSON.stringify(options.input)) + estimateTokens(JSON.stringify(output)),
+            timestamp: new Date().toISOString(),
+        };
+        await fs.mkdir(options.runDir, { recursive: true });
+        await fs.appendFile(path.join(options.runDir, 'telemetry.jsonl'), `${JSON.stringify(row)}\n`, 'utf-8');
+        return output;
+    }
+    finally {
+        await closeLbug();
+    }
+}
+export async function telemetryToolMain(argv) {
+    const parsed = parseArgs(argv);
+    const output = await invokeTelemetryTool(parsed);
+    writeSync(1, `${JSON.stringify(output, null, 2)}\n`);
+}
+function parseArgs(argv) {
+    let runDir = '';
+    let tool = '';
+    let inputText = '';
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--run-dir') {
+            runDir = argv[index + 1] || '';
+            index += 1;
+            continue;
+        }
+        if (token === '--tool') {
+            tool = (argv[index + 1] || '');
+            index += 1;
+            continue;
+        }
+        if (token === '--input') {
+            inputText = argv[index + 1] || '';
+            index += 1;
+            continue;
+        }
+    }
+    if (!runDir || !tool || !inputText) {
+        throw new Error('Usage: telemetry-tool --run-dir <dir> --tool <query|context|cypher> --input <json>');
+    }
+    if (!['query', 'context', 'cypher'].includes(tool)) {
+        throw new Error(`Unsupported tool: ${tool}`);
+    }
+    return {
+        runDir,
+        tool,
+        input: JSON.parse(inputText),
+    };
+}
+if (process.argv[1] && import.meta.url === `file://${process.argv[1]}`) {
+    telemetryToolMain(process.argv.slice(2)).catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}

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

@@ -0,0 +1,61 @@
+import type { AgentContextToolStep } from '../agent-context/types.js';
+export declare const AGENT_SAFE_CASE_KEYS: readonly ["weapon_powerup", "reload"];
+export type AgentSafeCaseKey = (typeof AGENT_SAFE_CASE_KEYS)[number];
+export declare const AGENT_SAFE_TRACK_KEYS: readonly ["workflow_replay_full", "workflow_replay_slim", "same_script_full", "same_script_slim", "subagent_live"];
+export type AgentSafeTrackKey = (typeof AGENT_SAFE_TRACK_KEYS)[number];
+export interface SemanticTuple {
+    resource_anchor: string;
+    symbol_anchor: string;
+    proof_edge?: string;
+    proof_edges?: string[];
+    closure_status: 'not_verified_full' | 'verified_partial' | 'verified_full' | 'failed';
+}
+export interface SemanticDriftMetrics {
+    anchor_top1_pass: boolean;
+    recommended_follow_up_hit: boolean;
+    post_narrowing_anchor_pass: boolean;
+    post_narrowing_follow_up_hit: boolean;
+    ambiguity_detour_count: number;
+    placeholder_leak_detected: boolean;
+    heuristic_top_summary_detected: boolean;
+    live_tool_evidence_pass: boolean;
+    freeze_ready: boolean;
+    guid_invariance_pass: boolean;
+    tier_envelope: {
+        facts_present: boolean;
+        closure_present: boolean;
+        clues_present: boolean;
+        semantic_order_pass: boolean;
+        summary_source: string;
+    };
+}
+export interface AgentSafeLiveTask {
+    objective: string;
+    symbol_seed: string;
+    resource_seed: string;
+}
+export interface AgentSafeBenchmarkCase {
+    label: string;
+    start_query: string;
+    retry_query: string;
+    start_query_input?: Record<string, unknown>;
+    retry_query_input?: Record<string, unknown>;
+    proof_contexts: string[];
+    proof_cypher: string;
+    tool_plan: AgentContextToolStep[];
+    live_task: AgentSafeLiveTask;
+    semantic_tuple: SemanticTuple;
+}
+export interface AgentSafeBenchmarkThresholds {
+    workflowReplay: {
+        maxSteps: number;
+    };
+    tokenReduction: {
+        weapon_powerup: number;
+        reload: number;
+    };
+}
+export interface AgentSafeBenchmarkSuite {
+    thresholds: AgentSafeBenchmarkThresholds;
+    cases: Record<AgentSafeCaseKey, AgentSafeBenchmarkCase>;
+}

package/dist/benchmark/agent-safe-query-context/types.js

@@ -0,0 +1,8 @@
+export const AGENT_SAFE_CASE_KEYS = ['weapon_powerup', 'reload'];
+export const AGENT_SAFE_TRACK_KEYS = [
+    'workflow_replay_full',
+    'workflow_replay_slim',
+    'same_script_full',
+    'same_script_slim',
+    'subagent_live',
+];

package/dist/benchmark/runtime-poc/provenance-artifact.d.ts

@@ -0,0 +1,47 @@
+export interface RuntimeProvenanceInputRecord {
+    scenario_id: string;
+    query_text: string;
+    symbol_name?: string;
+    resource_seed_path?: string;
+    mapped_seed_targets?: string[];
+    runtime_claim: {
+        status: string;
+        evidence_level: string;
+        reason?: string;
+        hops_count?: number;
+        gaps_count?: number;
+    };
+}
+export interface RuntimeProvenanceArtifact {
+    generated_at: string;
+    repo: string;
+    mode: 'offline_provenance_only';
+    records: RuntimeProvenanceInputRecord[];
+}
+export interface RuntimeProvenanceIndexEntry {
+    generated_at: string;
+    repo: string;
+    artifact_path: string;
+    sha256: string;
+    record_count: number;
+    generator: 'runtime-poc-provenance-v1';
+}
+export interface RuntimeProvenanceIndex {
+    version: '1.0.0';
+    entries: RuntimeProvenanceIndexEntry[];
+}
+export declare function buildRuntimeProvenanceArtifact(input: {
+    repo: string;
+    records: RuntimeProvenanceInputRecord[];
+    generatedAt?: string;
+}): RuntimeProvenanceArtifact;
+export declare function writeRuntimeProvenanceArtifact(input: {
+    reportDir: string;
+    repo: string;
+    records: RuntimeProvenanceInputRecord[];
+}): Promise<{
+    artifactPath: string;
+    indexPath: string;
+    sha256: string;
+    artifact: RuntimeProvenanceArtifact;
+}>;

package/dist/benchmark/runtime-poc/provenance-artifact.js

@@ -0,0 +1,89 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+function normalizeRecord(input) {
+    return {
+        scenario_id: String(input.scenario_id || '').trim(),
+        query_text: String(input.query_text || '').trim(),
+        ...(String(input.symbol_name || '').trim() ? { symbol_name: String(input.symbol_name).trim() } : {}),
+        ...(String(input.resource_seed_path || '').trim()
+            ? { resource_seed_path: String(input.resource_seed_path).trim() }
+            : {}),
+        mapped_seed_targets: Array.isArray(input.mapped_seed_targets)
+            ? input.mapped_seed_targets.map((value) => String(value || '').trim()).filter(Boolean)
+            : [],
+        runtime_claim: {
+            status: String(input.runtime_claim?.status || 'failed').trim(),
+            evidence_level: String(input.runtime_claim?.evidence_level || 'none').trim(),
+            ...(String(input.runtime_claim?.reason || '').trim()
+                ? { reason: String(input.runtime_claim?.reason).trim() }
+                : {}),
+            ...(Number.isFinite(Number(input.runtime_claim?.hops_count))
+                ? { hops_count: Number(input.runtime_claim?.hops_count) }
+                : {}),
+            ...(Number.isFinite(Number(input.runtime_claim?.gaps_count))
+                ? { gaps_count: Number(input.runtime_claim?.gaps_count) }
+                : {}),
+        },
+    };
+}
+function toIsoStamp(date = new Date()) {
+    return date.toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+export function buildRuntimeProvenanceArtifact(input) {
+    return {
+        generated_at: String(input.generatedAt || toIsoStamp()),
+        repo: String(input.repo || '').trim(),
+        mode: 'offline_provenance_only',
+        records: (input.records || []).map((record) => normalizeRecord(record)),
+    };
+}
+function buildSha256(raw) {
+    return crypto.createHash('sha256').update(raw).digest('hex');
+}
+export async function writeRuntimeProvenanceArtifact(input) {
+    const reportDir = path.resolve(input.reportDir);
+    await fs.mkdir(reportDir, { recursive: true });
+    const artifact = buildRuntimeProvenanceArtifact({
+        repo: input.repo,
+        records: input.records,
+    });
+    const stampForFile = artifact.generated_at.replace(/[:]/g, '-');
+    const artifactPath = path.join(reportDir, `provenance-${stampForFile}.json`);
+    const artifactRaw = JSON.stringify(artifact, null, 2);
+    await fs.writeFile(artifactPath, `${artifactRaw}\n`, 'utf-8');
+    const sha256 = buildSha256(artifactRaw);
+    const indexPath = path.join(reportDir, 'provenance-index.json');
+    let index = {
+        version: '1.0.0',
+        entries: [],
+    };
+    try {
+        const existing = JSON.parse(await fs.readFile(indexPath, 'utf-8'));
+        if (existing && Array.isArray(existing.entries)) {
+            index = {
+                version: '1.0.0',
+                entries: existing.entries,
+            };
+        }
+    }
+    catch {
+        // Keep default empty index.
+    }
+    const entry = {
+        generated_at: artifact.generated_at,
+        repo: artifact.repo,
+        artifact_path: artifactPath,
+        sha256,
+        record_count: artifact.records.length,
+        generator: 'runtime-poc-provenance-v1',
+    };
+    index.entries = [entry, ...index.entries.filter((row) => String(row.artifact_path || '') !== artifactPath)];
+    await fs.writeFile(indexPath, `${JSON.stringify(index, null, 2)}\n`, 'utf-8');
+    return {
+        artifactPath,
+        indexPath,
+        sha256,
+        artifact,
+    };
+}

package/dist/benchmark/runtime-poc/runner.d.ts

@@ -0,0 +1,31 @@
+type RuntimeStatus = 'verified_full' | 'verified_partial' | 'failed';
+type RuntimeEvidenceLevel = 'verified_chain' | 'verified_segment' | 'clue' | 'none';
+export interface RuntimePocCase {
+    case_id: string;
+    query_text: string;
+    symbol_name?: string;
+    resource_seed_path?: string;
+    mapped_seed_targets?: string[];
+    baseline: {
+        status: RuntimeStatus;
+        evidence_level: RuntimeEvidenceLevel;
+        reason?: string;
+    };
+    graph_only: {
+        status: RuntimeStatus;
+        evidence_level: RuntimeEvidenceLevel;
+        reason?: string;
+    };
+}
+export interface RuntimePocBenchmarkResult {
+    comparisonPath: string;
+    summaryPath: string;
+    provenanceArtifactPath: string;
+    provenanceIndexPath: string;
+}
+export declare function runRuntimePocBenchmark(input: {
+    repo: string;
+    reportDir: string;
+    casesPath?: string;
+}): Promise<RuntimePocBenchmarkResult>;
+export {};