sneakoscope 7.0.2 → 7.0.5

package/dist/core/providers/glm/naruto/glm-naruto-critical-path.js

@@ -1,50 +0,0 @@
-import path from 'node:path';
-import { writeJsonAtomic, writeTextAtomic } from '../../../fsx.js';
-export function buildGlmNarutoCriticalPathMetrics(input) {
-    const stageMs = (stage) => {
-        const matches = input.stages.filter((metric) => metric.stage === stage);
-        if (!matches.length)
-            return null;
-        return matches.reduce((sum, metric) => sum + metric.wall_clock_ms, 0);
-    };
-    const values = {
-        decomposition: input.decompositionMs,
-        patch_generation: stageMs('patch_generation') ?? 0,
-        worktree_materialization: stageMs('worktree_materialization'),
-        candidate_gate: stageMs('candidate_gate') ?? 0,
-        verifier: stageMs('verifier'),
-        conflict_merge: input.conflictMergeMs,
-        final_apply: input.finalApplyMs,
-        final_seal: input.finalSealMs
-    };
-    const slowest = Object.entries(values)
-        .filter(([, value]) => typeof value === 'number')
-        .sort((a, b) => Number(b[1]) - Number(a[1]))[0]?.[0] ?? 'unknown';
-    return {
-        schema: 'sks.glm-naruto-critical-path.v1',
-        total_wall_clock_ms: Math.max(0, input.totalWallClockMs),
-        stage_wall_clock_ms: values,
-        slowest_stage: slowest,
-        parallelism_warnings: input.parallelismWarnings
-    };
-}
-export async function writeGlmNarutoCriticalPathArtifacts(input) {
-    const dir = path.join(input.root, '.sneakoscope', 'glm-naruto', input.missionId);
-    await writeJsonAtomic(path.join(dir, 'critical-path.json'), input.metrics);
-    await writeTextAtomic(path.join(dir, 'speed-diagnosis.md'), renderSpeedDiagnosis(input.metrics));
-}
-function renderSpeedDiagnosis(metrics) {
-    return [
-        '# GLM Naruto Speed Diagnosis',
-        '',
-        `Total wall clock: ${metrics.total_wall_clock_ms}ms`,
-        `Slowest stage: ${metrics.slowest_stage}`,
-        '',
-        '## Stage Wall Clock',
-        ...Object.entries(metrics.stage_wall_clock_ms).map(([stage, ms]) => `- ${stage}: ${ms === null ? 'not_run' : `${ms}ms`}`),
-        '',
-        '## Parallelism Warnings',
-        metrics.parallelism_warnings.length ? metrics.parallelism_warnings.map((warning) => `- ${warning}`).join('\n') : '- none',
-        ''
-    ].join('\n');
-}

package/dist/core/providers/glm/naruto/glm-naruto-decomposer.js

@@ -1,148 +0,0 @@
-import crypto from 'node:crypto';
-import { GLM_NARUTO_DEFAULTS, NARUTO_PATCH_STRATEGIES } from './glm-naruto-types.js';
-export function decomposeTask(input) {
-    const shards = [];
-    const dependencies = [];
-    const mutableShardIds = [];
-    const verificationShardIds = [];
-    const paths = discoverTargetPaths(input);
-    if (paths.length === 0) {
-        const scoutShard = {
-            id: 'shard-scout-paths',
-            kind: 'verification',
-            task: `Discover target paths before mutation for: ${input.task}`,
-            target_paths: [],
-            forbidden_paths: ['.github/', 'dist/', 'node_modules/'],
-            base_digest: digestBase(input),
-            strategy: 'minimal_patch',
-            patches_per_shard: 0,
-            max_tokens: 2048,
-            reasoning: 'low',
-            mutable: false
-        };
-        return {
-            schema: 'sks.glm-naruto-work-graph.v1',
-            mission_id: input.missionId,
-            task: input.task,
-            shards: [scoutShard],
-            dependencies,
-            parallel_groups: [],
-            mutable_shards: [],
-            verification_shards: [scoutShard.id]
-        };
-    }
-    let shardIndex = 0;
-    for (const targetPath of paths) {
-        const shardId = `shard-${shardIndex}`;
-        const strategy = NARUTO_PATCH_STRATEGIES[shardIndex % NARUTO_PATCH_STRATEGIES.length] || 'minimal_patch';
-        const isCritical = paths.length <= 2;
-        const shard = {
-            id: shardId,
-            kind: classifyShardKind(targetPath),
-            task: input.task,
-            target_paths: [targetPath],
-            forbidden_paths: ['.github/', 'dist/', 'node_modules/'],
-            base_digest: digestBase(input),
-            strategy,
-            patches_per_shard: isCritical ? GLM_NARUTO_DEFAULTS.critical_patches_per_shard : GLM_NARUTO_DEFAULTS.default_patches_per_shard,
-            max_tokens: GLM_NARUTO_DEFAULTS.default_max_tokens,
-            reasoning: 'none',
-            mutable: true
-        };
-        shards.push(shard);
-        mutableShardIds.push(shardId);
-        shardIndex++;
-    }
-    const verifyShard = {
-        id: 'shard-verify',
-        kind: 'verification',
-        task: `Verify all patches for: ${input.task}`,
-        target_paths: paths,
-        forbidden_paths: ['.github/', 'dist/', 'node_modules/'],
-        base_digest: digestBase(input),
-        strategy: 'minimal_patch',
-        patches_per_shard: 0,
-        max_tokens: 4096,
-        reasoning: 'low',
-        mutable: false
-    };
-    shards.push(verifyShard);
-    verificationShardIds.push(verifyShard.id);
-    for (const mutableId of mutableShardIds) {
-        dependencies.push({ from: mutableId, to: verifyShard.id, kind: 'verifies' });
-    }
-    const parallelGroup = {
-        id: 'parallel-patch-wave',
-        shard_ids: mutableShardIds,
-        parallel: true
-    };
-    return {
-        schema: 'sks.glm-naruto-work-graph.v1',
-        mission_id: input.missionId,
-        task: input.task,
-        shards,
-        dependencies,
-        parallel_groups: [parallelGroup],
-        mutable_shards: mutableShardIds,
-        verification_shards: verificationShardIds
-    };
-}
-function discoverTargetPaths(input) {
-    const candidates = new Set();
-    for (const mentioned of input.mentionedPaths)
-        candidates.add(mentioned);
-    for (const line of (input.gitStatus || '').split(/\r?\n/)) {
-        const match = line.match(/^\s*(?:[AMDRCU?!]{1,2})\s+(.+)$/);
-        if (!match)
-            continue;
-        const file = match[1].split(/\s+->\s+/).pop().trim();
-        if (isMutableCandidate(file))
-            candidates.add(file);
-    }
-    for (const source of [input.task, input.lastError || '']) {
-        for (const match of source.matchAll(/\b([A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+\.(?:ts|tsx|js|mjs|cjs|json|md|yml|yaml|toml))\b/g)) {
-            if (isMutableCandidate(match[1]))
-                candidates.add(match[1]);
-        }
-    }
-    return [...candidates];
-}
-function isMutableCandidate(file) {
-    return Boolean(file)
-        && !file.startsWith('.github/')
-        && !file.startsWith('dist/')
-        && !file.startsWith('node_modules/')
-        && !file.endsWith('/');
-}
-function classifyShardKind(path) {
-    if (path.includes('test') || path.includes('__tests__') || path.includes('.test.'))
-        return 'test_fix';
-    if (path.endsWith('.md') || path.endsWith('.txt'))
-        return 'doc_patch';
-    if (path.endsWith('.json') || path.endsWith('.yaml') || path.endsWith('.yml') || path.endsWith('.toml'))
-        return 'config_patch';
-    if (path.endsWith('.ts') || path.endsWith('.js') || path.endsWith('.mjs'))
-        return 'file_patch';
-    return 'file_patch';
-}
-function digestBase(input) {
-    return crypto.createHash('sha256').update(JSON.stringify({
-        task: input.task,
-        gitStatus: input.gitStatus || '',
-        paths: input.mentionedPaths
-    })).digest('hex').slice(0, 16);
-}
-export function validateWorkGraph(graph, isVerifyOnly) {
-    if (isVerifyOnly)
-        return { ok: true };
-    const mutableCount = graph.mutable_shards.length;
-    if (mutableCount === 0)
-        return { ok: false, reason: 'glm_naruto_needs_target_path_context' };
-    // Check ratio of mutable shards to total shards (excluding verification shards from the denominator)
-    const totalWorkShards = graph.shards.filter(s => s.mutable || s.kind !== 'verification').length;
-    const ratio = totalWorkShards > 0 ? mutableCount / totalWorkShards : 0;
-    if (ratio < GLM_NARUTO_DEFAULTS.patch_worker_ratio) {
-        return { ok: false, reason: 'glm_naruto_insufficient_patch_workers' };
-    }
-    return { ok: true };
-}

package/dist/core/providers/glm/naruto/glm-naruto-file-lease.js

@@ -1,22 +0,0 @@
-export function planFileLeases(shardTargetPaths) {
-    const pathToShards = new Map();
-    for (const [shardId, paths] of shardTargetPaths) {
-        for (const p of paths) {
-            const list = pathToShards.get(p) || [];
-            list.push(shardId);
-            pathToShards.set(p, list);
-        }
-    }
-    const leases = [];
-    for (const [path, shardIds] of pathToShards) {
-        leases.push({
-            path,
-            shardIds,
-            exclusive: shardIds.length === 1
-        });
-    }
-    return leases;
-}
-export function hasLeaseConflict(leases, shardId) {
-    return leases.some((lease) => !lease.exclusive && lease.shardIds.includes(shardId));
-}

package/dist/core/providers/glm/naruto/glm-naruto-final-seal.js

@@ -1,81 +0,0 @@
-import path from 'node:path';
-import { writeJsonAtomic } from '../../../fsx.js';
-import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
-export async function writeGlmNarutoFinalSeal(input) {
-    const mismatches = [
-        ...input.envelopes.filter((env) => env.model !== GLM_52_OPENROUTER_MODEL || env.gpt_fallback_allowed !== false).map((env) => `envelope:${env.worker_id}`),
-        ...input.traces.filter((trace) => trace.model !== GLM_52_OPENROUTER_MODEL).map((trace) => `trace:${trace.worker_id}`)
-    ];
-    const isolationViolations = input.isolationPolicy.selected === 'blocked' ? input.isolationPolicy.blockers : [];
-    const status = finalSealStatus({
-        result: input.result,
-        secretOk: input.secretAudit.ok,
-        mismatches,
-        isolationViolations,
-        queueDrained: input.scheduler.queue_drained,
-        requirementCoveragePassed: input.requirementCoverage?.passed ?? true
-    });
-    const seal = {
-        schema: 'sks.glm-naruto-final-seal.v1',
-        mission_id: input.missionId,
-        status,
-        model_lock: {
-            model: GLM_52_OPENROUTER_MODEL,
-            gpt_fallback_allowed: false,
-            requests_checked: input.envelopes.length + input.traces.length,
-            mismatches
-        },
-        isolation: {
-            selected: input.isolationPolicy.selected,
-            workers_write_main_workspace: false,
-            violations: isolationViolations
-        },
-        scheduler: {
-            bounded: true,
-            max_observed_active_workers: input.scheduler.max_observed_active_workers,
-            queue_drained: input.scheduler.queue_drained,
-            backpressure_events: input.scheduler.backpressure_events
-        },
-        candidates: {
-            total: input.envelopes.length,
-            gate_passed: input.envelopes.filter((env) => env.status === 'gate_passed').length,
-            verifier_passed: input.envelopes.filter((env) => env.verification_passed === true).length,
-            selected: input.selectedPatchIds
-        },
-        requirement_coverage: {
-            required_total: input.requirementCoverage?.required_total ?? 0,
-            required_covered: input.requirementCoverage?.required_covered ?? 0,
-            passed: input.requirementCoverage?.passed ?? true,
-            uncovered_required_requirements: input.requirementCoverage?.uncovered_required_requirements ?? []
-        },
-        apply: {
-            attempted: input.applyTransaction !== null,
-            transaction_path: input.applyTransaction ? path.join(input.artifactDir, 'apply-transaction.json') : null,
-            final_status: input.applyTransaction?.final_status ?? null,
-            rollback_attempted: input.applyTransaction?.rollback_attempted ?? false,
-            rollback_passed: input.applyTransaction?.rollback_passed ?? null
-        },
-        secret_audit: {
-            ok: input.secretAudit.ok,
-            findings: input.secretAudit.findings ?? []
-        },
-        stop_gate: {
-            path: input.stopGatePath,
-            passed: input.stopGatePassed
-        }
-    };
-    const out = path.join(input.artifactDir, 'final-seal.json');
-    await writeJsonAtomic(out, seal);
-    return { seal, path: out, passed: seal.status === 'passed' };
-}
-function finalSealStatus(input) {
-    if (!input.secretOk || input.mismatches.length > 0 || input.isolationViolations.length > 0 || !input.queueDrained || !input.requirementCoveragePassed)
-        return 'blocked';
-    if (input.result.ok)
-        return 'passed';
-    if (input.result.status === 'partial_candidates')
-        return 'partial';
-    if (input.result.status === 'blocked')
-        return 'blocked';
-    return 'failed';
-}

package/dist/core/providers/glm/naruto/glm-naruto-finalizer.js

@@ -1,22 +0,0 @@
-import { planMerge } from './glm-naruto-merge-planner.js';
-import { buildConflictGraph } from './glm-naruto-conflict-graph.js';
-export function finalizeMergePlan(input) {
-    const passedEnvelopes = input.envelopes.filter((e) => e.status === 'gate_passed');
-    const nodes = passedEnvelopes.map((env) => ({
-        patch_id: env.worker_id,
-        shard_id: env.shard_id,
-        target_paths: env.target_paths,
-        score: Math.max(0, 100 - Math.floor(env.patch.length / 100)),
-        gate_passed: true,
-        patch_sha256: env.patch_sha256
-    }));
-    const conflictGraph = buildConflictGraph(passedEnvelopes, nodes);
-    const strategy = input.useJudge && input.judgeResult ? 'judge' : 'deterministic';
-    return planMerge({
-        missionId: input.missionId,
-        graph: conflictGraph,
-        ...(input.scoreboard ? { scoreboard: input.scoreboard } : {}),
-        strategy,
-        ...(input.judgeResult ? { judgeRanking: input.judgeResult.ranked_patch_ids } : {})
-    });
-}

package/dist/core/providers/glm/naruto/glm-naruto-hunk-conflict.js

@@ -1,15 +0,0 @@
-import { hunksOverlap, parseUnifiedDiffHunks } from './glm-naruto-hunk-parser.js';
-export function envelopesHaveHunkConflict(left, right) {
-    const leftHunks = parseUnifiedDiffHunks(left.patch);
-    const rightHunks = parseUnifiedDiffHunks(right.patch);
-    if (leftHunks.length === 0 || rightHunks.length === 0)
-        return sharesPath(left, right);
-    return leftHunks.some((leftHunk) => rightHunks.some((rightHunk) => hunksOverlap(leftHunk, rightHunk)));
-}
-export function envelopesShareFileButNotHunk(left, right) {
-    return sharesPath(left, right) && !envelopesHaveHunkConflict(left, right);
-}
-function sharesPath(left, right) {
-    const rightPaths = new Set(right.target_paths);
-    return left.target_paths.some((file) => rightPaths.has(file));
-}

package/dist/core/providers/glm/naruto/glm-naruto-hunk-parser.js

@@ -1,35 +0,0 @@
-export function parseUnifiedDiffHunks(patch) {
-    const hunks = [];
-    let currentFile = null;
-    for (const line of patch.split(/\r?\n/)) {
-        const diff = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
-        if (diff?.[2]) {
-            currentFile = diff[2];
-            continue;
-        }
-        const file = line.match(/^\+\+\+ b\/(.+)$/);
-        if (file?.[1] && file[1] !== '/dev/null')
-            currentFile = file[1];
-        const hunk = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/);
-        if (hunk && currentFile) {
-            hunks.push({
-                file: currentFile,
-                old_start: Number(hunk[1]),
-                old_lines: Number(hunk[2] || 1),
-                new_start: Number(hunk[3]),
-                new_lines: Number(hunk[4] || 1),
-                header: line
-            });
-        }
-    }
-    return hunks;
-}
-export function hunksOverlap(left, right) {
-    if (left.file !== right.file)
-        return false;
-    return rangesOverlap(left.old_start, left.old_start + Math.max(1, left.old_lines) - 1, right.old_start, right.old_start + Math.max(1, right.old_lines) - 1)
-        || rangesOverlap(left.new_start, left.new_start + Math.max(1, left.new_lines) - 1, right.new_start, right.new_start + Math.max(1, right.new_lines) - 1);
-}
-function rangesOverlap(aStart, aEnd, bStart, bEnd) {
-    return aStart <= bEnd && bStart <= aEnd;
-}

package/dist/core/providers/glm/naruto/glm-naruto-isolation-policy.js

@@ -1,37 +0,0 @@
-export function resolveGlmNarutoIsolationPolicy(input) {
-    const requested = input.useWorktree ? 'git-worktree' : input.patchEnvelopeOnly ? 'patch-envelope-only' : 'auto';
-    if (input.patchEnvelopeOnly || !input.useWorktree) {
-        return {
-            schema: 'sks.glm-naruto-isolation-policy.v1',
-            requested,
-            selected: 'patch-envelope-only',
-            honest: true,
-            reason: input.patchEnvelopeOnly ? 'patch_envelope_only_requested' : 'worktree_not_requested',
-            blockers: [],
-            fallback_allowed: Boolean(input.fallbackAllowed),
-            workers_write_main_workspace: false
-        };
-    }
-    if (input.gitAvailable) {
-        return {
-            schema: 'sks.glm-naruto-isolation-policy.v1',
-            requested,
-            selected: 'git-worktree',
-            honest: true,
-            reason: 'git_worktree_available',
-            blockers: [],
-            fallback_allowed: Boolean(input.fallbackAllowed),
-            workers_write_main_workspace: false
-        };
-    }
-    return {
-        schema: 'sks.glm-naruto-isolation-policy.v1',
-        requested,
-        selected: input.fallbackAllowed ? 'patch-envelope-only' : 'blocked',
-        honest: true,
-        reason: input.fallbackAllowed ? 'git_worktree_unavailable_fallback_allowed' : 'git_worktree_unavailable',
-        blockers: input.fallbackAllowed ? [] : ['glm_naruto_worktree_not_implemented_or_unavailable'],
-        fallback_allowed: Boolean(input.fallbackAllowed),
-        workers_write_main_workspace: false
-    };
-}

package/dist/core/providers/glm/naruto/glm-naruto-judge.js

@@ -1,83 +0,0 @@
-import { buildGlm52Request } from '../glm-52-request.js';
-import { sendOpenRouterChatCompletionStream } from '../../openrouter/openrouter-stream.js';
-import { assertGlm52ActualModel } from '../glm-52-response-guard.js';
-import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
-export async function runGlmJudge(input) {
-    const validEnvelopes = input.envelopes.filter((e) => e.status === 'gate_passed');
-    if (validEnvelopes.length === 0) {
-        return {
-            schema: 'sks.glm-naruto-judge.v1',
-            ranked_patch_ids: [],
-            reject_patch_ids: [],
-            mergeable_sets: [],
-            risks: ['no_gate_passed_candidates'],
-            requires_repair_wave: false
-        };
-    }
-    const systemPrompt = `You are a GLM Naruto judge. Rank patch candidates by quality. Output strict JSON with schema: {"ranked_patch_ids":["id1","id2"],"reject_patch_ids":["id3"],"mergeable_sets":[["id1","id2"]],"risks":[],"requires_repair_wave":false}. Model: ${GLM_52_OPENROUTER_MODEL}. No GPT fallback.`;
-    const candidateDescriptions = validEnvelopes.map((e) => ({
-        patch_id: e.worker_id,
-        shard_id: e.shard_id,
-        target_paths: e.target_paths,
-        patch_sha256: e.patch_sha256.slice(0, 12),
-        strategy: e.strategy,
-        patch_size: e.patch.length
-    }));
-    const userContent = JSON.stringify({
-        mission_id: input.missionId,
-        candidates: candidateDescriptions,
-        instruction: 'Rank by: gate pass, minimal diff, correct target paths, no protected paths. Return mergeable non-conflicting sets.'
-    });
-    const messages = [
-        { role: 'system', content: systemPrompt },
-        { role: 'user', content: userContent }
-    ];
-    const request = buildGlm52Request({
-        profile: 'deep',
-        messages,
-        maxTokens: 8192,
-        reasoningEffort: 'high',
-        toolChoice: 'none',
-        parallelToolCalls: false
-    });
-    const response = await sendOpenRouterChatCompletionStream({
-        apiKey: input.apiKey,
-        request: { ...request, session_id: `sks-glm-naruto-judge-${input.missionId}` },
-        timeoutMs: input.timeoutMs || 120_000
-    });
-    if (!response.ok) {
-        return fallbackJudgeResult(validEnvelopes, [`judge_request_failed:${response.error.code}`]);
-    }
-    const modelGuard = assertGlm52ActualModel(response.value.model);
-    if (!modelGuard.ok) {
-        return fallbackJudgeResult(validEnvelopes, [`judge_model_guard:${modelGuard.code}`]);
-    }
-    try {
-        const jsonMatch = response.value.content.match(/\{[\s\S]*\}/);
-        if (!jsonMatch)
-            return fallbackJudgeResult(validEnvelopes, ['judge_no_json_output']);
-        const parsed = JSON.parse(jsonMatch[0]);
-        return {
-            schema: 'sks.glm-naruto-judge.v1',
-            ranked_patch_ids: Array.isArray(parsed.ranked_patch_ids) ? parsed.ranked_patch_ids : [],
-            reject_patch_ids: Array.isArray(parsed.reject_patch_ids) ? parsed.reject_patch_ids : [],
-            mergeable_sets: Array.isArray(parsed.mergeable_sets) ? parsed.mergeable_sets : [],
-            risks: Array.isArray(parsed.risks) ? parsed.risks : [],
-            requires_repair_wave: Boolean(parsed.requires_repair_wave)
-        };
-    }
-    catch {
-        return fallbackJudgeResult(validEnvelopes, ['judge_json_parse_failed']);
-    }
-}
-function fallbackJudgeResult(envelopes, risks) {
-    const sorted = [...envelopes].sort((a, b) => a.patch.length - b.patch.length);
-    return {
-        schema: 'sks.glm-naruto-judge.v1',
-        ranked_patch_ids: sorted.map((e) => e.worker_id),
-        reject_patch_ids: [],
-        mergeable_sets: sorted.length > 0 ? [[sorted[0].worker_id]] : [],
-        risks,
-        requires_repair_wave: false
-    };
-}

package/dist/core/providers/glm/naruto/glm-naruto-merge-planner.js

@@ -1,61 +0,0 @@
-import { getNonConflictingSets } from './glm-naruto-conflict-graph.js';
-export function planMerge(input) {
-    const scoreByPatch = new Map((input.scoreboard?.scores ?? []).map((score) => [score.patch_id, score]));
-    const passedNodes = input.graph.nodes.filter((n) => n.gate_passed && !scoreByPatch.get(n.patch_id)?.disqualified);
-    const filteredGraph = {
-        ...input.graph,
-        nodes: passedNodes
-    };
-    const nonConflictingSets = getNonConflictingSets(filteredGraph);
-    const candidates = nonConflictingSets.map((patchIds) => {
-        const nodes = passedNodes.filter((n) => patchIds.includes(n.patch_id));
-        const totalScore = nodes.reduce((sum, n) => sum + (scoreByPatch.get(n.patch_id)?.total_score ?? n.score), 0);
-        return { patch_ids: patchIds, total_score: totalScore, conflict_free: true };
-    }).filter((candidate) => candidate.patch_ids.every((id) => passedNodes.some((node) => node.patch_id === id)));
-    candidates.sort((a, b) => b.total_score - a.total_score);
-    let selected = [];
-    let rationale = '';
-    if (input.strategy === 'judge' && input.judgeRanking && input.judgeRanking.length > 0) {
-        const ranked = input.judgeRanking.filter((id) => passedNodes.some((n) => n.patch_id === id));
-        const bestSet = candidates.find((set) => set.patch_ids.every((id) => ranked.includes(id))) || candidates[0];
-        selected = bestSet ? bestSet.patch_ids : [];
-        rationale = 'judge_ranked_deterministic_gated';
-    }
-    else if (input.strategy === 'quorum') {
-        const quorumMap = new Map();
-        for (const node of passedNodes) {
-            const key = node.shard_id;
-            quorumMap.set(key, (quorumMap.get(key) || 0) + 1);
-        }
-        const bestSet = candidates[0];
-        selected = bestSet ? bestSet.patch_ids : [];
-        rationale = 'quorum_consensus_deterministic_gated';
-    }
-    else {
-        const bestSet = candidates[0];
-        selected = bestSet ? bestSet.patch_ids : [];
-        rationale = 'highest_score_non_conflicting';
-    }
-    return {
-        schema: 'sks.glm-naruto-merge-plan.v1',
-        mission_id: input.missionId,
-        strategy: input.strategy,
-        selected_patches: selected,
-        candidates,
-        rationale
-    };
-}
-export function scoreCandidate(input) {
-    let score = 0;
-    if (input.node.gate_passed)
-        score += 100;
-    score -= input.patchSize / 100;
-    score -= input.touchedPathsCount * 5;
-    if (input.protectedPath)
-        score -= 200;
-    if (input.testFailure)
-        score -= 50;
-    if (input.judgeRank !== null && input.judgeRank !== undefined)
-        score += Math.max(0, 50 - input.judgeRank * 10);
-    return Math.round(score);
-}

package/dist/core/providers/glm/naruto/glm-naruto-metrics.js

@@ -1,33 +0,0 @@
-export function summarizeGlmNarutoWorkerMetrics(traces) {
-    const ttft = traces.map((trace) => trace.ttft_ms).filter(isNumber).sort((a, b) => a - b);
-    const totals = traces.map((trace) => trace.total_ms).filter(isNumber).sort((a, b) => a - b);
-    const verifier = traces.filter((trace) => trace.status === 'verification_passed' || trace.status === 'verification_failed');
-    const verifierPassed = verifier.filter((trace) => trace.status === 'verification_passed').length;
-    return {
-        p50_ttft_ms: percentile(ttft, 0.5),
-        p90_ttft_ms: percentile(ttft, 0.9),
-        p50_total_ms: percentile(totals, 0.5),
-        p90_total_ms: percentile(totals, 0.9),
-        cached_tokens_sum: sumNullable(traces.map((trace) => trace.cached_tokens ?? null)),
-        cache_write_tokens_sum: sumNullable(traces.map((trace) => trace.cache_write_tokens ?? null)),
-        reasoning_tokens_sum: sumNullable(traces.map((trace) => trace.reasoning_tokens ?? null)),
-        workers_completed: traces.filter((trace) => trace.status === 'completed').length,
-        workers_failed: traces.filter((trace) => trace.status === 'failed').length,
-        verifier_pass_rate: verifier.length ? verifierPassed / verifier.length : 0
-    };
-}
-function percentile(values, quantile) {
-    if (!values.length)
-        return null;
-    const index = Math.min(values.length - 1, Math.max(0, Math.ceil(values.length * quantile) - 1));
-    return values[index] ?? null;
-}
-function sumNullable(values) {
-    const present = values.filter(isNumber);
-    if (!present.length)
-        return null;
-    return present.reduce((sum, value) => sum + value, 0);
-}
-function isNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value);
-}