sneakoscope 7.0.2 → 7.0.5

package/dist/core/commands/glm-command.js

@@ -1,93 +0,0 @@
-import { flag, positionalArgs } from '../../cli/args.js';
-import { runGlmBenchmark } from '../providers/glm/bench/glm-benchmark-runner.js';
-import { printJson } from '../../cli/output.js';
-import { runGlmDirectSpeedRun } from '../providers/glm/glm-direct-run.js';
-import { runGlmReadinessAndExit } from '../providers/glm/glm-readiness.js';
-import { runGlmInteractiveLaunch } from '../providers/glm/glm-interactive-launch.js';
-import { glmNarutoCommand } from '../providers/glm/naruto/glm-naruto-command.js';
-import { stripGlmSlashModelArgs } from '../providers/glm/glm-profile-resolver.js';
-import { findRetiredGlobalExecutionArgumentErrors } from '../../cli/global-mode-router.js';
-export async function glmCommand(args = []) {
-    const argumentErrors = findRetiredGlobalExecutionArgumentErrors(args);
-    if (argumentErrors.length)
-        return blockRetiredGlmArguments(args, argumentErrors);
-    if (positionalArgs(args)[0] === 'naruto') {
-        const narutoIndex = args.indexOf('naruto');
-        const narutoArgs = [...args.slice(0, narutoIndex), ...args.slice(narutoIndex + 1)];
-        return glmNarutoCommand(narutoArgs);
-    }
-    if (flag(args, '--bench')) {
-        const result = await runGlmBenchmark(process.cwd(), args);
-        if (result.status === 'blocked')
-            process.exitCode = 1;
-        if (flag(args, '--json'))
-            printJson(result);
-        else if (result.status === 'blocked')
-            console.error(`GLM benchmark blocked: ${result.warnings.join(', ')}`);
-        else if (result.status === 'dry_run')
-            console.log(`GLM benchmark: dry-run (use --live for real measurement)`);
-        else {
-            const direct = result.cases.find((c) => c.implementation_path === 'direct-glm');
-            if (direct)
-                console.log(`  Direct GLM: ${direct.wall_clock_ms}ms`);
-            console.log(`  Recommendation: ${result.comparison.recommendation}`);
-        }
-        return result;
-    }
-    const task = extractGlmTask(args);
-    const interactive = flag(args, '--interactive') || flag(args, '--open') || flag(args, '--zellij') || positionalArgs(args)[0] === 'session';
-    if (interactive) {
-        const readiness = await runGlmReadinessAndExit(args);
-        if (!readiness.ok)
-            return readiness;
-        return runGlmInteractiveLaunch(args, readiness);
-    }
-    if (!task || flag(args, '--repair') || flag(args, '--status')) {
-        return runGlmReadinessAndExit(args);
-    }
-    const result = await runGlmDirectSpeedRun({
-        cwd: process.cwd(),
-        task,
-        args,
-        dryRun: flag(args, '--dry-run')
-    });
-    if (flag(args, '--json'))
-        printJson(result);
-    else if (result.ok)
-        console.log(`GLM direct run completed: ${result.termination_reason}`);
-    else
-        console.error(`GLM direct run ${result.status}: ${result.blockers.join(', ') || result.termination_reason}`);
-    if (!result.ok)
-        process.exitCode = 1;
-    return result;
-}
-function blockRetiredGlmArguments(args, argumentErrors) {
-    const result = {
-        schema: 'sks.glm-argument-error.v1',
-        ok: false,
-        status: 'blocked',
-        reason: 'invalid_glm_arguments',
-        argument_errors: [...argumentErrors],
-        blockers: [...argumentErrors],
-        hint: 'Use `sks --mad --glm` or the canonical `sks --mad --glm naruto` surface.'
-    };
-    process.exitCode = 1;
-    if (flag(args, '--json'))
-        printJson(result);
-    else {
-        console.error('SKS GLM argument error.');
-        for (const error of argumentErrors)
-            console.error(`- ${error}`);
-    }
-    return result;
-}
-function extractGlmTask(args) {
-    const positional = positionalArgs(stripGlmSlashModelArgs(args)).map(String);
-    if (positional[0] === 'run')
-        return positional.slice(1).join(' ').trim() || null;
-    if (positional[0] === 'session')
-        return null;
-    if (positional[0] === 'naruto')
-        return null;
-    return positional.join(' ').trim() || null;
-}

package/dist/core/providers/glm/bench/glm-bench-comparison.js

@@ -1,47 +0,0 @@
-export function computeGlmBenchmarkComparison(cases) {
-    const directCase = cases.find((c) => c.implementation_path === 'direct-glm');
-    const narutoCases = cases.filter((c) => c.implementation_path === 'glm-naruto');
-    const directSucceeded = Boolean(directCase && (directCase.patch_generated === true || directCase.patch_gate_passed === true));
-    const directWallClockMs = directCase && directSucceeded ? directCase.wall_clock_ms : null;
-    const eligibleNaruto = narutoCases.filter((c) => (c.gate_pass_rate !== null && c.gate_pass_rate > 0) || c.merge_success === true);
-    let bestNaruto = null;
-    for (const naruto of eligibleNaruto) {
-        if (!bestNaruto || naruto.wall_clock_ms < bestNaruto.wall_clock_ms) {
-            bestNaruto = naruto;
-        }
-    }
-    const bestNarutoWallClockMs = bestNaruto ? bestNaruto.wall_clock_ms : null;
-    const bestNarutoRunnerId = bestNaruto ? bestNaruto.runner_id : null;
-    let speedup = null;
-    if (directWallClockMs !== null && bestNarutoWallClockMs !== null && bestNarutoWallClockMs > 0) {
-        speedup = Number((directWallClockMs / bestNarutoWallClockMs).toFixed(3));
-    }
-    let recommendation = 'inconclusive';
-    let reason = 'Insufficient measured data to recommend a path.';
-    if (directWallClockMs !== null && bestNarutoWallClockMs === null) {
-        recommendation = 'direct-glm';
-        reason = 'Direct GLM succeeded and no Naruto case produced gate-passed or merged results.';
-    }
-    else if (directWallClockMs !== null && bestNarutoWallClockMs !== null && speedup !== null) {
-        if (speedup >= 1.2) {
-            recommendation = 'glm-naruto';
-            reason = `GLM Naruto (${bestNarutoRunnerId}) was ${speedup.toFixed(2)}x faster than direct GLM for this task.`;
-        }
-        else {
-            recommendation = 'direct-glm';
-            reason = `Direct GLM was faster for this tiny single-file task (speedup ratio ${speedup.toFixed(2)}).`;
-        }
-    }
-    else if (directWallClockMs === null && bestNarutoWallClockMs !== null) {
-        recommendation = 'glm-naruto';
-        reason = `GLM Naruto (${bestNarutoRunnerId}) produced results while direct GLM did not complete.`;
-    }
-    return {
-        direct_wall_clock_ms: directWallClockMs,
-        best_naruto_wall_clock_ms: bestNarutoWallClockMs,
-        best_naruto_runner_id: bestNarutoRunnerId,
-        naruto_speedup_vs_direct: speedup,
-        recommendation,
-        reason
-    };
-}

package/dist/core/providers/glm/bench/glm-bench-fixture.js

@@ -1,64 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import fsp from 'node:fs/promises';
-import { spawn } from 'node:child_process';
-export const BENCH_FIXTURE_TASK = 'Change src/bench-target.ts so value is 2. Return the smallest patch only.';
-export const BENCH_FIXTURE_TARGET_FILE = 'src/bench-target.ts';
-export const BENCH_FIXTURE_INITIAL = 'export const value = 1;\n';
-export const BENCH_FIXTURE_EXPECTED = 'export const value = 2;\n';
-export async function createGlmBenchFixture(baseDir) {
-    const fixtureDir = await fsp.mkdtemp(path.join(baseDir || os.tmpdir(), 'sks-glm-bench-fixture-'));
-    await fsp.mkdir(path.join(fixtureDir, 'src'), { recursive: true });
-    await fsp.writeFile(path.join(fixtureDir, BENCH_FIXTURE_TARGET_FILE), BENCH_FIXTURE_INITIAL, 'utf8');
-    await gitInit(fixtureDir);
-    await gitAdd(fixtureDir, '.');
-    await gitCommit(fixtureDir, 'bench fixture initial');
-    return {
-        schema: 'sks.glm-bench-fixture.v1',
-        fixture_dir: fixtureDir,
-        task: BENCH_FIXTURE_TASK,
-        target_file: BENCH_FIXTURE_TARGET_FILE,
-        initial_content: BENCH_FIXTURE_INITIAL,
-        expected_content: BENCH_FIXTURE_EXPECTED
-    };
-}
-export async function cloneFixture(source, label) {
-    const cloneDir = await fsp.mkdtemp(path.join(os.tmpdir(), `sks-glm-bench-${label}-`));
-    await gitClone(source.fixture_dir, cloneDir);
-    return { ...source, fixture_dir: cloneDir };
-}
-export async function resetFixture(fixture) {
-    await runGit(['reset', '--hard', 'HEAD'], fixture.fixture_dir);
-    await runGit(['clean', '-fdx'], fixture.fixture_dir);
-}
-export async function cleanupFixture(fixture) {
-    await fsp.rm(fixture.fixture_dir, { recursive: true, force: true }).catch(() => undefined);
-}
-async function gitInit(dir) {
-    await runGit(['init', '-q'], dir);
-    await runGit(['config', 'user.name', 'sks-bench'], dir);
-    await runGit(['config', 'user.email', 'bench@sks.local'], dir);
-}
-async function gitAdd(dir, file) {
-    await runGit(['add', file], dir);
-}
-async function gitCommit(dir, message) {
-    await runGit(['commit', '-q', '-m', message], dir);
-}
-async function gitClone(source, dest) {
-    await runGit(['clone', '-q', source, dest], dest);
-}
-function runGit(args, cwd) {
-    return new Promise((resolve, reject) => {
-        const child = spawn('git', [...args], { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
-        let stderr = '';
-        child.stderr.on('data', (chunk) => { stderr += String(chunk); });
-        child.on('close', (code) => {
-            if (code === 0)
-                resolve();
-            else
-                reject(new Error(`git ${args.join(' ')} exited ${code}: ${stderr.trim()}`));
-        });
-        child.on('error', reject);
-    });
-}

package/dist/core/providers/glm/bench/glm-bench-model-lock-proof.js

@@ -1,52 +0,0 @@
-import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
-export function buildGlmBenchModelLockProof(cases, proofInput = {}) {
-    const checkedCases = cases.map((c) => c.runner_id);
-    const mismatches = [];
-    const requestSummaries = proofInput.requestSummaries ?? [];
-    let fallbackArraysFound = 0;
-    let openaiKeyUsed = false;
-    for (const caseResult of cases) {
-        if (caseResult.model !== GLM_52_OPENROUTER_MODEL) {
-            mismatches.push(`${caseResult.runner_id}: model is ${caseResult.model}, expected ${GLM_52_OPENROUTER_MODEL}`);
-        }
-        if (caseResult.gpt_fallback_allowed !== false) {
-            mismatches.push(`${caseResult.runner_id}: gpt_fallback_allowed is not false`);
-        }
-    }
-    for (const summary of requestSummaries) {
-        if (summary.model !== undefined && summary.model !== GLM_52_OPENROUTER_MODEL) {
-            mismatches.push(`request-summary:${String(summary.worker_id ?? summary.runner_id ?? 'unknown')}: model is ${String(summary.model)}`);
-        }
-        const models = Array.isArray(summary.models) ? summary.models : [];
-        const fallbackModelsCount = typeof summary.fallback_models_count === 'number' ? summary.fallback_models_count : models.length;
-        if (fallbackModelsCount > 0)
-            fallbackArraysFound += 1;
-        if (summary.openai_key_used === true || summary.authorization_source === 'openai')
-            openaiKeyUsed = true;
-        if (summary.gpt_fallback_allowed !== undefined && summary.gpt_fallback_allowed !== false) {
-            mismatches.push(`request-summary:${String(summary.worker_id ?? summary.runner_id ?? 'unknown')}: gpt_fallback_allowed is not false`);
-        }
-    }
-    if (fallbackArraysFound > 0)
-        mismatches.push(`fallback_arrays_found:${fallbackArraysFound}`);
-    if (openaiKeyUsed)
-        mismatches.push('openai_key_used');
-    const requestSummaryStatus = requestSummaries.length > 0 ? 'checked' : 'unavailable';
-    return {
-        schema: 'sks.glm-bench-model-lock-proof.v1',
-        checked_cases: checkedCases,
-        model: GLM_52_OPENROUTER_MODEL,
-        gpt_fallback_allowed: false,
-        request_summary_status: requestSummaryStatus,
-        request_summaries_checked: requestSummaries.length,
-        request_summaries_unavailable: Math.max(0, cases.length - requestSummaries.length),
-        naruto_request_summaries_checked: requestSummaries.filter((summary) => String(summary.worker_id ?? '').startsWith('worker-')).length,
-        direct_trace_checked: proofInput.directTraceChecked === true,
-        fallback_arrays_found: fallbackArraysFound,
-        openai_key_used: openaiKeyUsed,
-        fallback_array_scan: requestSummaryStatus,
-        openai_key_usage_scan: requestSummaryStatus,
-        mismatches,
-        passed: mismatches.length === 0
-    };
-}

package/dist/core/providers/glm/bench/glm-bench-report.js

@@ -1,74 +0,0 @@
-import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
-import { writeTextAtomic, nowIso } from '../../../fsx.js';
-import path from 'node:path';
-export async function writeGlmBenchReport(benchDir, result) {
-    const reportPath = path.join(benchDir, 'bench-report.md');
-    const lines = [];
-    lines.push('# GLM Benchmark Report — True Direct vs Naruto', '');
-    lines.push(`Generated: ${result.generated_at}`);
-    lines.push(`Model: ${GLM_52_OPENROUTER_MODEL}`);
-    lines.push(`GPT fallback allowed: false`);
-    lines.push(`Status: ${result.status}`);
-    lines.push('');
-    if (result.fixture) {
-        lines.push('## Fixture', '');
-        lines.push(`- Task: ${result.fixture.task}`);
-        lines.push(`- Target: ${result.fixture.target_file}`);
-        lines.push(`- Temp repo: ${result.fixture.fixture_dir}`);
-        lines.push('');
-    }
-    lines.push('## Cases', '');
-    lines.push('| Case | Kind | Workers | Wall ms | TTFT p50 | Total p50 | Candidates | Gate pass | Verifier | Merge | Patch gen | Patch gate | Metric |');
-    lines.push('| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- | --- | --- | --- |');
-    for (const c of result.cases) {
-        lines.push(formatCaseRow(c));
-    }
-    lines.push('');
-    const direct = result.cases.find((c) => c.implementation_path === 'direct-glm');
-    const narutoBest = result.cases
-        .filter((c) => c.implementation_path === 'glm-naruto')
-        .sort((a, b) => a.wall_clock_ms - b.wall_clock_ms)[0];
-    lines.push('## Comparison', '');
-    if (direct) {
-        lines.push(`- Direct GLM: ${direct.wall_clock_ms}ms`);
-    }
-    if (narutoBest) {
-        lines.push(`- Best Naruto: ${narutoBest.name} at ${narutoBest.wall_clock_ms}ms`);
-    }
-    lines.push(`- Recommendation: ${result.comparison.recommendation}`);
-    lines.push(`- Reason: ${result.comparison.reason}`);
-    lines.push('');
-    lines.push('## Limitations', '');
-    lines.push('- This benchmark uses a tiny single-file task; tiny tasks may favor direct GLM.');
-    lines.push('- Multi-file parallelizable tasks may favor GLM Naruto.');
-    lines.push('- Missing usage metrics are reported as `unavailable` or `n/a`, never as fake zero.');
-    lines.push('- Direct GLM candidate/verifier/merge metrics are `not_applicable`.');
-    lines.push('');
-    if (result.model_lock_proof) {
-        lines.push('## Model Lock Proof', '');
-        lines.push(`- Passed: ${result.model_lock_proof.passed}`);
-        lines.push(`- Mismatches: ${result.model_lock_proof.mismatches.length}`);
-        lines.push('');
-    }
-    if (result.no_mutation_proof) {
-        lines.push('## No Mutation Proof', '');
-        lines.push(`- Passed: ${result.no_mutation_proof.passed}`);
-        lines.push(`- User CWD unchanged: ${result.no_mutation_proof.user_cwd_unchanged}`);
-        lines.push('');
-    }
-    lines.push(`_Report generated at ${nowIso()}_`, '');
-    await writeTextAtomic(reportPath, lines.join('\n'));
-    return reportPath;
-}
-function formatCaseRow(c) {
-    const ttft = c.p50_ttft_ms !== null ? String(c.p50_ttft_ms) : 'unavailable';
-    const total = c.p50_total_ms !== null ? String(c.p50_total_ms) : 'unavailable';
-    const candidates = c.candidate_count !== null ? String(c.candidate_count) : 'n/a';
-    const gate = c.gate_pass_rate !== null ? c.gate_pass_rate.toFixed(2) : 'n/a';
-    const verifier = c.verifier_pass_rate !== null ? c.verifier_pass_rate.toFixed(2) : 'n/a';
-    const merge = c.merge_success !== null ? String(c.merge_success) : 'n/a';
-    const patchGen = c.patch_generated !== null ? String(c.patch_generated) : 'n/a';
-    const patchGate = c.patch_gate_passed !== null ? String(c.patch_gate_passed) : 'n/a';
-    const metricLatency = c.metric_status.latency;
-    return `| ${c.name} | ${c.kind} | ${c.workers} | ${c.wall_clock_ms} | ${ttft} | ${total} | ${candidates} | ${gate} | ${verifier} | ${merge} | ${patchGen} | ${patchGate} | ${metricLatency} |`;
-}

package/dist/core/providers/glm/bench/glm-benchmark-runner.js

@@ -1,243 +0,0 @@
-import os from 'node:os';
-import path from 'node:path';
-import fsp from 'node:fs/promises';
-import { spawn } from 'node:child_process';
-import { nowIso, writeJsonAtomic } from '../../../fsx.js';
-import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
-import { resolveOpenRouterApiKey } from '../../openrouter/openrouter-secret-store.js';
-import { runGlmNarutoMission } from '../naruto/glm-naruto-orchestrator.js';
-import { summarizeGlmNarutoWorkerMetrics } from '../naruto/glm-naruto-metrics.js';
-import { runGlmDirectSpeedRun } from '../glm-direct-run.js';
-import { createGlmBenchFixture, cloneFixture, resetFixture, cleanupFixture } from './glm-bench-fixture.js';
-import { runGlmDirectBenchCase } from './glm-direct-bench-runner.js';
-import { computeGlmBenchmarkComparison } from './glm-bench-comparison.js';
-import { buildGlmBenchModelLockProof } from './glm-bench-model-lock-proof.js';
-import { writeGlmBenchReport } from './glm-bench-report.js';
-import { GLM_BENCHMARK_VERSION } from './glm-benchmark-types.js';
-const NARUTO_WORKER_COUNTS = [1, 4, 8, 12];
-export async function runGlmBenchmark(root, args = [], deps = {}) {
-    const live = args.includes('--live');
-    const execute = args.includes('--execute');
-    const noApply = args.includes('--no-apply') || true;
-    const applyTemp = args.includes('--apply-temp');
-    const started = Date.now();
-    if (execute && !live) {
-        return blockedResult(root, ['execute_requires_live_flag']);
-    }
-    if (!live) {
-        return dryRunResult(root, started);
-    }
-    const key = await resolveOpenRouterApiKey({ env: process.env });
-    if (!key.key) {
-        return blockedResult(root, ['live_bench_requires_openrouter_key']);
-    }
-    const userCwd = process.cwd();
-    const userCwdBefore = await captureGitStatus(userCwd);
-    const benchId = `bench-${nowIso().replace(/[:.]/g, '-')}`;
-    const benchDir = path.join(root, '.sneakoscope', 'glm-bench', benchId);
-    await fsp.mkdir(benchDir, { recursive: true });
-    const sharedFixture = await createGlmBenchFixture();
-    const cases = [];
-    // Direct GLM case — does NOT call runGlmNarutoMission
-    const directFixture = await cloneFixture(sharedFixture, 'direct');
-    const directCaseDir = path.join(benchDir, 'cases', 'direct-glm-speed');
-    const directCase = await runGlmDirectBenchCase({
-        root,
-        fixture: directFixture,
-        apiKey: key.key,
-        noApply: true,
-        timeoutMs: 120_000,
-        sessionId: `sks-bench-direct-${benchId}`,
-        caseDir: directCaseDir
-    }, deps.runDirect ? { runDirect: deps.runDirect } : {});
-    cases.push(directCase);
-    await cleanupFixture(directFixture);
-    // Naruto cases — each calls runGlmNarutoMission with different worker counts
-    for (const workers of NARUTO_WORKER_COUNTS) {
-        const narutoFixture = await cloneFixture(sharedFixture, `naruto-${workers}`);
-        const caseDir = path.join(benchDir, 'cases', `glm-naruto-${workers}`);
-        await fsp.mkdir(caseDir, { recursive: true });
-        const caseStarted = Date.now();
-        const runNaruto = deps.runNaruto ?? runGlmNarutoMission;
-        const narutoResult = await runNaruto({
-            cwd: narutoFixture.fixture_dir,
-            task: sharedFixture.task,
-            args: ['--bench', '--live', '--no-apply'],
-            missionId: `glm-bench-naruto-${workers}-${benchId}`,
-            maxWorkers: workers,
-            noApply: true
-        });
-        const traces = await readWorkerTraces(narutoResult.artifact_dir);
-        const metrics = summarizeGlmNarutoWorkerMetrics(traces);
-        const wallClockMs = Date.now() - caseStarted;
-        const narutoCase = {
-            schema: 'sks.glm-benchmark-case.v1',
-            name: `GLM Naruto ${workers} worker${workers === 1 ? '' : 's'}`,
-            kind: 'glm-naruto',
-            runner_id: `glm-naruto-${workers}`,
-            implementation_path: 'glm-naruto',
-            workers,
-            model: GLM_52_OPENROUTER_MODEL,
-            gpt_fallback_allowed: false,
-            no_apply: true,
-            mutation_performed: false,
-            wall_clock_ms: wallClockMs,
-            p50_ttft_ms: metrics.p50_ttft_ms,
-            p90_ttft_ms: metrics.p90_ttft_ms,
-            p50_total_ms: metrics.p50_total_ms,
-            p90_total_ms: metrics.p90_total_ms,
-            candidate_count: narutoResult.patch_candidates,
-            gate_pass_rate: narutoResult.patch_candidates ? narutoResult.gate_passed_candidates / narutoResult.patch_candidates : null,
-            verifier_pass_rate: metrics.verifier_pass_rate > 0 ? metrics.verifier_pass_rate : (traces.length > 0 ? 0 : null),
-            merge_success: narutoResult.mergeable_candidates > 0,
-            patch_generated: narutoResult.patch_candidates > 0,
-            patch_gate_passed: narutoResult.gate_passed_candidates > 0,
-            cached_tokens_sum: metrics.cached_tokens_sum,
-            cache_write_tokens_sum: metrics.cache_write_tokens_sum,
-            reasoning_tokens_sum: metrics.reasoning_tokens_sum,
-            metric_status: {
-                latency: metrics.p50_total_ms === null && metrics.p50_ttft_ms === null ? 'unavailable' : 'measured',
-                usage: metrics.cached_tokens_sum === null && metrics.reasoning_tokens_sum === null ? 'unavailable' : 'measured',
-                candidate: 'measured',
-                verifier: 'measured',
-                merge: 'measured'
-            },
-            artifacts: {
-                case_dir: caseDir,
-                trace_path: null,
-                mission_artifact_dir: narutoResult.artifact_dir || null
-            },
-            blockers: narutoResult.blockers,
-            warnings: narutoResult.warnings
-        };
-        await writeJsonAtomic(path.join(caseDir, 'case-result.json'), narutoCase);
-        cases.push(narutoCase);
-        await cleanupFixture(narutoFixture);
-    }
-    await cleanupFixture(sharedFixture);
-    const comparison = computeGlmBenchmarkComparison(cases);
-    const modelLockProof = buildGlmBenchModelLockProof(cases, {
-        requestSummaries: await collectRequestSummaries(cases),
-        directTraceChecked: cases.some((c) => c.runner_id === 'direct-glm-speed' && c.artifacts.trace_path !== null)
-    });
-    const userCwdAfter = await captureGitStatus(userCwd);
-    const userCwdUnchanged = userCwdBefore === userCwdAfter;
-    const noMutationProof = {
-        schema: 'sks.glm-bench-no-mutation-proof.v1',
-        user_cwd_unchanged: userCwdUnchanged,
-        fixture_mutated_only_under_apply_temp: !applyTemp,
-        cases_report_no_mutation: true,
-        passed: userCwdUnchanged && cases.every((c) => c.mutation_performed === false)
-    };
-    const result = {
-        schema: 'sks.glm-benchmark-result.v1',
-        version: GLM_BENCHMARK_VERSION,
-        generated_at: nowIso(),
-        status: 'live',
-        model: GLM_52_OPENROUTER_MODEL,
-        gpt_fallback_allowed: false,
-        fixture: {
-            schema: 'sks.glm-bench-fixture.v1',
-            fixture_dir: '(cleaned up)',
-            task: sharedFixture.task,
-            target_file: sharedFixture.target_file,
-            initial_content: sharedFixture.initial_content,
-            expected_content: sharedFixture.expected_content
-        },
-        cases,
-        comparison,
-        model_lock_proof: modelLockProof,
-        no_mutation_proof: noMutationProof,
-        warnings: ['live_bench_no_apply_temp_repo']
-    };
-    await writeJsonAtomic(path.join(benchDir, 'bench-result.json'), result);
-    await writeJsonAtomic(path.join(benchDir, 'model-lock-proof.json'), modelLockProof);
-    await writeGlmBenchReport(benchDir, result);
-    return result;
-}
-function dryRunResult(root, startedMs) {
-    return {
-        schema: 'sks.glm-benchmark-result.v1',
-        version: GLM_BENCHMARK_VERSION,
-        generated_at: nowIso(),
-        status: 'dry_run',
-        model: GLM_52_OPENROUTER_MODEL,
-        gpt_fallback_allowed: false,
-        fixture: null,
-        cases: [],
-        comparison: {
-            direct_wall_clock_ms: null,
-            best_naruto_wall_clock_ms: null,
-            best_naruto_runner_id: null,
-            naruto_speedup_vs_direct: null,
-            recommendation: 'inconclusive',
-            reason: 'Dry run — no live API calls made.'
-        },
-        model_lock_proof: null,
-        no_mutation_proof: null,
-        warnings: ['dry_run_no_live_api_calls']
-    };
-}
-function blockedResult(root, warnings) {
-    return {
-        schema: 'sks.glm-benchmark-result.v1',
-        version: GLM_BENCHMARK_VERSION,
-        generated_at: nowIso(),
-        status: 'blocked',
-        model: GLM_52_OPENROUTER_MODEL,
-        gpt_fallback_allowed: false,
-        fixture: null,
-        cases: [],
-        comparison: {
-            direct_wall_clock_ms: null,
-            best_naruto_wall_clock_ms: null,
-            best_naruto_runner_id: null,
-            naruto_speedup_vs_direct: null,
-            recommendation: 'inconclusive',
-            reason: 'Benchmark blocked.'
-        },
-        model_lock_proof: null,
-        no_mutation_proof: null,
-        warnings
-    };
-}
-async function readWorkerTraces(artifactDir) {
-    if (!artifactDir)
-        return [];
-    try {
-        return JSON.parse(await fsp.readFile(path.join(artifactDir, 'worker-traces.json'), 'utf8'));
-    }
-    catch {
-        return [];
-    }
-}
-async function collectRequestSummaries(cases) {
-    const summaries = [];
-    for (const caseResult of cases) {
-        const dir = caseResult.artifacts.mission_artifact_dir;
-        if (!dir)
-            continue;
-        try {
-            const workerRoot = path.join(dir, 'workers');
-            const workerIds = await fsp.readdir(workerRoot);
-            for (const workerId of workerIds) {
-                try {
-                    const summary = JSON.parse(await fsp.readFile(path.join(workerRoot, workerId, 'request-summary.json'), 'utf8'));
-                    summaries.push(summary);
-                }
-                catch { }
-            }
-        }
-        catch { }
-    }
-    return summaries;
-}
-async function captureGitStatus(cwd) {
-    return new Promise((resolve) => {
-        const child = spawn('git', ['status', '--short'], { cwd, stdio: ['ignore', 'pipe', 'ignore'] });
-        let stdout = '';
-        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
-        child.on('close', () => resolve(stdout.trim()));
-        child.on('error', () => resolve(''));
-    });
-}

package/dist/core/providers/glm/bench/glm-benchmark-types.js

@@ -1 +0,0 @@
-export const GLM_BENCHMARK_VERSION = '4.2.0';

package/dist/core/providers/glm/bench/glm-direct-bench-runner.js

@@ -1,72 +0,0 @@
-import path from 'node:path';
-import fsp from 'node:fs/promises';
-import { writeJsonAtomic } from '../../../fsx.js';
-import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
-import { runGlmDirectSpeedRun } from '../glm-direct-run.js';
-export async function runGlmDirectBenchCase(input, deps = {}) {
-    const runDirect = deps.runDirect ?? runGlmDirectSpeedRun;
-    await fsp.mkdir(input.caseDir, { recursive: true });
-    const started = Date.now();
-    const directResult = await runDirect({
-        cwd: input.fixture.fixture_dir,
-        task: input.fixture.task,
-        args: ['--bench', '--live', '--dry-run'],
-        dryRun: true
-    });
-    const wallClockMs = Date.now() - started;
-    const patchGenerated = directResult.ok || directResult.status === 'blocked';
-    const patchGatePassed = directResult.ok;
-    const tracePath = path.join(input.caseDir, 'trace.json');
-    await writeJsonAtomic(tracePath, {
-        schema: 'sks.glm-direct-bench-trace.v1',
-        runner_id: 'direct-glm-speed',
-        implementation_path: 'direct-glm',
-        wall_clock_ms: wallClockMs,
-        direct_result: directResult,
-        called_naruto: false,
-        model: GLM_52_OPENROUTER_MODEL
-    });
-    const latencyMeasured = wallClockMs > 0;
-    const result = {
-        schema: 'sks.glm-benchmark-case.v1',
-        name: 'Direct GLM speed path',
-        kind: 'direct-glm',
-        runner_id: 'direct-glm-speed',
-        implementation_path: 'direct-glm',
-        workers: 1,
-        model: GLM_52_OPENROUTER_MODEL,
-        gpt_fallback_allowed: false,
-        no_apply: true,
-        mutation_performed: false,
-        wall_clock_ms: wallClockMs,
-        p50_ttft_ms: null,
-        p90_ttft_ms: null,
-        p50_total_ms: null,
-        p90_total_ms: null,
-        candidate_count: null,
-        gate_pass_rate: null,
-        verifier_pass_rate: null,
-        merge_success: null,
-        patch_generated: patchGenerated ? true : (patchGenerated === false ? false : null),
-        patch_gate_passed: patchGatePassed ? true : (patchGatePassed === false ? false : null),
-        cached_tokens_sum: null,
-        cache_write_tokens_sum: null,
-        reasoning_tokens_sum: null,
-        metric_status: {
-            latency: latencyMeasured ? 'measured' : 'unavailable',
-            usage: 'unavailable',
-            candidate: 'not_applicable',
-            verifier: 'not_applicable',
-            merge: 'not_applicable'
-        },
-        artifacts: {
-            case_dir: input.caseDir,
-            trace_path: tracePath,
-            mission_artifact_dir: null
-        },
-        blockers: directResult.blockers,
-        warnings: directResult.warnings
-    };
-    await writeJsonAtomic(path.join(input.caseDir, 'case-result.json'), result);
-    return result;
-}