sneakoscope 4.0.6 → 4.0.8

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

@@ -0,0 +1,84 @@
+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 || GLM_52_OPENROUTER_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
+    };
+}
+//# sourceMappingURL=glm-naruto-judge.js.map

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

@@ -0,0 +1,57 @@
+import { getNonConflictingSets } from './glm-naruto-conflict-graph.js';
+export function planMerge(input) {
+    const passedNodes = input.graph.nodes.filter((n) => n.gate_passed);
+    const nonConflictingSets = getNonConflictingSets(input.graph);
+    const candidates = nonConflictingSets.map((patchIds) => {
+        const nodes = passedNodes.filter((n) => patchIds.includes(n.patch_id));
+        const totalScore = nodes.reduce((sum, n) => sum + n.score, 0);
+        return { patch_ids: patchIds, total_score: totalScore, conflict_free: true };
+    });
+    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);
+}
+//# sourceMappingURL=glm-naruto-merge-planner.js.map

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

@@ -0,0 +1,224 @@
+import path from 'node:path';
+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 { checkAndApplyGlmPatch } from '../glm-patch-apply.js';
+import { decomposeTask, validateWorkGraph } from './glm-naruto-decomposer.js';
+import { planShardCandidates, computeInitialLaneMix } from './glm-naruto-shard-planner.js';
+import { runPatchWorkerPool } from './glm-naruto-worker-pool.js';
+import { buildConflictGraph } from './glm-naruto-conflict-graph.js';
+import { planMerge } from './glm-naruto-merge-planner.js';
+import { finalizeMergePlan } from './glm-naruto-finalizer.js';
+import { planRepairWave } from './glm-naruto-repair-wave.js';
+import { createBudget, checkBudget, recordRequest } from './glm-naruto-budget.js';
+import { createProviderHealthTracker } from '../../openrouter/openrouter-provider-health.js';
+import { createMissionTrace, recordWorkerTrace, writeMissionArtifacts, buildMissionSummary } from './glm-naruto-trace.js';
+import { runGlmJudge } from './glm-naruto-judge.js';
+import { GLM_NARUTO_LIMITS } from './glm-naruto-types.js';
+export async function runGlmNarutoMission(input) {
+    const missionId = input.missionId || `glm-naruto-${nowIso().replace(/[:.]/g, '-')}`;
+    const cwd = input.cwd;
+    const startedMs = Date.now();
+    const key = await resolveOpenRouterApiKey({ env: process.env });
+    if (!key.key) {
+        return missionResult(missionId, input.task, 'blocked', 'glm_missing_openrouter_key', 0, startedMs, [], [], ['glm_missing_openrouter_key'], []);
+    }
+    const mentionedPaths = extractMentionedPaths(input.task);
+    const gitStatus = await readGitStatus(cwd);
+    const graph = decomposeTask({
+        missionId,
+        task: input.task,
+        gitStatus,
+        mentionedPaths
+    });
+    const isVerifyOnly = input.task.trim().toLowerCase().startsWith('verify');
+    const validation = validateWorkGraph(graph, isVerifyOnly);
+    if (!validation.ok) {
+        return missionResult(missionId, input.task, 'blocked', validation.reason || 'invalid_work_graph', 0, startedMs, [], [], [validation.reason || 'invalid_work_graph'], []);
+    }
+    const budget = createBudget(missionId, input.deep || false);
+    const budgetCheck = checkBudget(budget);
+    if (!budgetCheck.ok) {
+        return missionResult(missionId, input.task, 'budget_exhausted', budgetCheck.reason, 0, startedMs, [], [], [budgetCheck.reason], []);
+    }
+    const laneMix = computeInitialLaneMix(graph);
+    const strategies = planShardCandidates(graph);
+    const strategyMap = new Map();
+    for (const entry of strategies) {
+        strategyMap.set(entry.shard.id, entry.strategies);
+    }
+    const healthTracker = createProviderHealthTracker();
+    let traceState = createMissionTrace(missionId);
+    // Wave 1: parallel patch candidate generation
+    const poolResult = await runPatchWorkerPool({
+        apiKey: key.key,
+        missionId,
+        cwd,
+        shards: graph.shards,
+        contextSummary: JSON.stringify({ task: input.task, git_status: gitStatus || '' }),
+        maxWorkers: input.maxWorkers || laneMix.patch_workers,
+        workerTimeoutMs: GLM_NARUTO_LIMITS.max_worker_runtime_ms,
+        strategies: strategyMap
+    });
+    for (const trace of poolResult.traces) {
+        traceState = recordWorkerTrace(traceState, trace);
+    }
+    healthTracker.record({ provider_slug: 'openrouter', model: GLM_52_OPENROUTER_MODEL, count_429: 0, count_5xx: 0 });
+    let envelopes = poolResult.envelopes;
+    let failedShardIds = poolResult.failedShardIds;
+    let repairWaves = 0;
+    // Repair wave if needed
+    if (failedShardIds.length > 0 && repairWaves < GLM_NARUTO_LIMITS.max_repair_waves) {
+        const repairPlan = planRepairWave({
+            failedEnvelopes: envelopes.filter((e) => e.status === 'gate_failed'),
+            shards: graph.shards,
+            repairWaveCount: repairWaves
+        });
+        if (repairPlan.canRepair && repairPlan.shardsToRepair.length > 0) {
+            repairWaves++;
+            const repairPool = await runPatchWorkerPool({
+                apiKey: key.key,
+                missionId,
+                cwd,
+                shards: repairPlan.shardsToRepair,
+                contextSummary: JSON.stringify({ task: input.task, repair: true }),
+                maxWorkers: input.maxWorkers || 3,
+                workerTimeoutMs: GLM_NARUTO_LIMITS.max_worker_runtime_ms,
+                strategies: new Map(repairPlan.shardsToRepair.map((s) => [s.id, [s.strategy]]))
+            });
+            envelopes = [...envelopes, ...repairPool.envelopes];
+            for (const trace of repairPool.traces) {
+                traceState = recordWorkerTrace(traceState, trace);
+            }
+            failedShardIds = [...failedShardIds, ...repairPool.failedShardIds];
+        }
+    }
+    // Build conflict graph and merge plan
+    const passedEnvelopes = 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);
+    let judgeResult = null;
+    if (input.useJudge && passedEnvelopes.length > 1) {
+        judgeResult = await runGlmJudge({
+            apiKey: key.key,
+            missionId,
+            envelopes: passedEnvelopes,
+            timeoutMs: 120_000
+        });
+    }
+    const mergePlan = finalizeMergePlan({
+        missionId,
+        envelopes: passedEnvelopes,
+        ...(judgeResult ? { judgeResult } : {}),
+        useJudge: input.useJudge || false,
+        xhighFinalizer: input.xhighFinalizer || false
+    });
+    // Apply winning merge plan
+    let appliedPatches = 0;
+    let applyResult = null;
+    if (!input.noApply && mergePlan.selected_patches.length > 0) {
+        for (const patchId of mergePlan.selected_patches) {
+            const envelope = envelopes.find((e) => e.worker_id === patchId);
+            if (!envelope)
+                continue;
+            const applied = await checkAndApplyGlmPatch({ cwd, patch: envelope.patch, apply: true });
+            if (applied.ok) {
+                appliedPatches++;
+            }
+        }
+        applyResult = { ok: appliedPatches > 0, applied: mergePlan.selected_patches };
+    }
+    const terminalState = appliedPatches > 0 ? 'completed' : passedEnvelopes.length > 0 ? 'partial_candidates' : 'blocked';
+    const terminationReason = appliedPatches > 0 ? 'completed_merge_applied' : passedEnvelopes.length > 0 ? 'partial_no_apply' : 'no_gate_passed_candidates';
+    const summary = buildMissionSummary({
+        missionId,
+        startedMs,
+        workerTraces: traceState.workerTraces,
+        patchCandidates: envelopes.length,
+        gatePassed: passedEnvelopes.length,
+        mergeable: mergePlan.candidates.length,
+        appliedPatches,
+        failedShards: failedShardIds.length,
+        repairWaves
+    });
+    const result = {
+        schema: 'sks.glm-naruto-mission-result.v1',
+        ok: terminalState === 'completed',
+        status: terminalState,
+        mission_id: missionId,
+        task: input.task,
+        model: GLM_52_OPENROUTER_MODEL,
+        gpt_fallback_allowed: false,
+        termination_reason: terminationReason,
+        workers_started: summary.workers_started,
+        workers_completed: summary.workers_completed,
+        patch_candidates: summary.patch_candidates,
+        gate_passed_candidates: summary.gate_passed_candidates,
+        mergeable_candidates: summary.mergeable_candidates,
+        applied_patches: summary.applied_patches,
+        failed_shards: summary.failed_shards,
+        repair_waves: summary.repair_waves,
+        budget_used_ms: summary.budget_used_ms,
+        blockers: terminalState === 'blocked' ? ['no_gate_passed_candidates'] : [],
+        warnings: []
+    };
+    const artifactDir = await writeMissionArtifacts({
+        root: cwd,
+        missionId,
+        workGraph: graph,
+        conflictGraph,
+        mergePlan,
+        ...(judgeResult ? { judgeResult } : {}),
+        workerTraces: traceState.workerTraces,
+        providerHealth: healthTracker.snapshot(),
+        termination: { schema: 'sks.glm-naruto-termination.v1', mission_id: missionId, terminal_state: terminalState, reason: terminationReason, wall_clock_ms: summary.wall_clock_ms },
+        ...(applyResult ? { applyResult: { ...applyResult, schema: 'sks.glm-naruto-apply-result.v1' } } : {}),
+        verificationSummary: { schema: 'sks.glm-naruto-verification.v1', verified: passedEnvelopes.length, total: envelopes.length },
+        missionResult: result
+    });
+    return { ...result, artifact_dir: artifactDir };
+}
+function missionResult(missionId, task, status, reason, patchCandidates, startedMs, envelopes, traces, blockers, warnings) {
+    return {
+        schema: 'sks.glm-naruto-mission-result.v1',
+        ok: status === 'completed',
+        status,
+        mission_id: missionId,
+        task,
+        model: GLM_52_OPENROUTER_MODEL,
+        gpt_fallback_allowed: false,
+        termination_reason: reason,
+        workers_started: traces.length,
+        workers_completed: traces.filter((t) => t.status === 'completed').length,
+        patch_candidates: envelopes.length,
+        gate_passed_candidates: envelopes.filter((e) => e.status === 'gate_passed').length,
+        mergeable_candidates: 0,
+        applied_patches: 0,
+        failed_shards: 0,
+        repair_waves: 0,
+        budget_used_ms: Date.now() - startedMs,
+        blockers,
+        warnings
+    };
+}
+async function readGitStatus(cwd) {
+    const { spawn } = await import('node:child_process');
+    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() || undefined));
+    });
+}
+function extractMentionedPaths(task) {
+    const matches = task.match(/(?:^|\s|[`"'])([A-Za-z0-9_.-]+\/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+)(?:\s|[`"']|$)/g) || [];
+    return [...new Set(matches.map((value) => value.trim().replace(/^[`"']|[`"']$/g, '')))];
+}
+//# sourceMappingURL=glm-naruto-orchestrator.js.map

package/dist/core/providers/glm/naruto/glm-naruto-patch-envelope.js

@@ -0,0 +1,55 @@
+import crypto from 'node:crypto';
+import { nowIso } from '../../../fsx.js';
+import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
+import { parseUnifiedDiffPatch } from '../glm-patch-parser.js';
+export function createPatchEnvelope(input) {
+    const parsed = parseUnifiedDiffPatch(input.patch);
+    return {
+        schema: 'sks.glm-naruto-patch-envelope.v1',
+        mission_id: input.missionId,
+        worker_id: input.workerId,
+        shard_id: input.shardId,
+        base_digest: input.baseDigest,
+        target_paths: parsed.touchedPaths,
+        patch: input.patch,
+        patch_sha256: crypto.createHash('sha256').update(input.patch).digest('hex'),
+        model: GLM_52_OPENROUTER_MODEL,
+        provider: 'openrouter',
+        reasoning_effort: input.reasoningEffort,
+        gpt_fallback_allowed: false,
+        generated_at: nowIso(),
+        status: input.status || 'candidate',
+        blockers: input.blockers || [],
+        warnings: input.warnings || [],
+        strategy: input.strategy
+    };
+}
+export function normalizePatchForDigest(patch) {
+    return patch.replace(/\s+/g, ' ').trim();
+}
+export function digestPatch(patch) {
+    return crypto.createHash('sha256').update(normalizePatchForDigest(patch)).digest('hex');
+}
+export function parsePatchCandidateOutput(text) {
+    const patchStart = text.indexOf('<sks_patch_candidate>');
+    const patchEnd = text.indexOf('</sks_patch_candidate>');
+    if (patchStart >= 0 && patchEnd > patchStart) {
+        return { kind: 'patch', content: text.slice(patchStart + '<sks_patch_candidate>'.length, patchEnd).trim() };
+    }
+    const needStart = text.indexOf('<sks_need_context>');
+    const needEnd = text.indexOf('</sks_need_context>');
+    if (needStart >= 0 && needEnd > needStart) {
+        const body = text.slice(needStart + '<sks_need_context>'.length, needEnd).trim();
+        const paths = body.split(/\r?\n/).map((line) => line.match(/^\s*-\s*(.+?)\s*$/)?.[1]).filter((v) => Boolean(v));
+        return { kind: 'need_context', content: body, paths };
+    }
+    const blockedStart = text.indexOf('<sks_blocked>');
+    const blockedEnd = text.indexOf('</sks_blocked>');
+    if (blockedStart >= 0 && blockedEnd > blockedStart) {
+        const body = text.slice(blockedStart + '<sks_blocked>'.length, blockedEnd).trim();
+        const reason = body.match(/reason:\s*(.+)/i)?.[1]?.trim() || body;
+        return { kind: 'blocked', content: body, reason };
+    }
+    return { kind: 'malformed', content: text.trim(), reason: 'missing_glm_naruto_output_envelope' };
+}
+//# sourceMappingURL=glm-naruto-patch-envelope.js.map

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

@@ -0,0 +1,37 @@
+import { digestPatch } from './glm-naruto-patch-envelope.js';
+export function evaluateQuorum(envelopes) {
+    const byShard = new Map();
+    for (const env of envelopes) {
+        if (env.status !== 'gate_passed' && env.status !== 'candidate')
+            continue;
+        const list = byShard.get(env.shard_id) || [];
+        list.push(env);
+        byShard.set(env.shard_id, list);
+    }
+    const results = [];
+    for (const [shardId, envs] of byShard) {
+        const digestCounts = new Map();
+        for (const env of envs) {
+            const digest = digestPatch(env.patch);
+            const existing = digestCounts.get(digest) || { count: 0, patches: [] };
+            existing.count++;
+            existing.patches.push(env.patch);
+            digestCounts.set(digest, existing);
+        }
+        let best = null;
+        for (const [digest, info] of digestCounts) {
+            if (!best || info.count > best.count) {
+                best = { count: info.count, patches: info.patches, digest };
+            }
+        }
+        results.push({
+            shardId,
+            consensusDigest: best ? best.digest : null,
+            voteCount: best ? best.count : 0,
+            totalCandidates: envs.length,
+            consensusPatches: best ? best.patches : []
+        });
+    }
+    return results;
+}
+//# sourceMappingURL=glm-naruto-quorum.js.map

package/dist/core/providers/glm/naruto/glm-naruto-rate-limiter.js

@@ -0,0 +1,18 @@
+export function createRateLimitState() {
+    return { rateLimited: false, retryAfterMs: 0, consecutive429: 0, last429At: null };
+}
+export function handleRateLimit(state, retryAfterMs) {
+    return {
+        rateLimited: true,
+        retryAfterMs,
+        consecutive429: state.consecutive429 + 1,
+        last429At: Date.now()
+    };
+}
+export function clearRateLimit(state) {
+    return { rateLimited: false, retryAfterMs: 0, consecutive429: 0, last429At: state.last429At };
+}
+export function shouldBackoff(state) {
+    return state.consecutive429 > 3 || (state.last429At !== null && Date.now() - state.last429At < state.retryAfterMs);
+}
+//# sourceMappingURL=glm-naruto-rate-limiter.js.map

package/dist/core/providers/glm/naruto/glm-naruto-repair-wave.js

@@ -0,0 +1,21 @@
+import { GLM_NARUTO_LIMITS } from './glm-naruto-types.js';
+export function planRepairWave(input) {
+    if (input.repairWaveCount >= GLM_NARUTO_LIMITS.max_repair_waves) {
+        return { shardsToRepair: [], canRepair: false, reason: 'max_repair_waves_reached' };
+    }
+    const failedShardIds = new Set(input.failedEnvelopes.map((e) => e.shard_id));
+    const shardsToRepair = input.shards.filter((s) => failedShardIds.has(s.id));
+    if (shardsToRepair.length === 0) {
+        return { shardsToRepair: [], canRepair: false, reason: 'no_failed_shards_to_repair' };
+    }
+    return {
+        shardsToRepair: shardsToRepair.map((s) => ({
+            ...s,
+            strategy: 'defensive_fix',
+            patches_per_shard: 1
+        })),
+        canRepair: true,
+        reason: 'repair_wave_planned'
+    };
+}
+//# sourceMappingURL=glm-naruto-repair-wave.js.map

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

@@ -0,0 +1,32 @@
+import { NARUTO_PATCH_STRATEGIES, GLM_NARUTO_DEFAULTS } from './glm-naruto-types.js';
+export function planShardCandidates(graph) {
+    return graph.shards
+        .filter((shard) => shard.mutable)
+        .map((shard) => {
+        const strategies = assignStrategies(shard);
+        return {
+            shard,
+            strategies,
+            candidate_count: shard.patches_per_shard
+        };
+    });
+}
+function assignStrategies(shard) {
+    const base = Math.max(0, NARUTO_PATCH_STRATEGIES.indexOf(shard.strategy));
+    const result = [shard.strategy];
+    for (let i = 1; i < shard.patches_per_shard && i < NARUTO_PATCH_STRATEGIES.length; i++) {
+        const next = NARUTO_PATCH_STRATEGIES[(base + i) % NARUTO_PATCH_STRATEGIES.length] || 'minimal_patch';
+        if (!result.includes(next))
+            result.push(next);
+    }
+    return result;
+}
+export function computeInitialLaneMix(graph) {
+    const mutable = graph.mutable_shards.length;
+    const total = Math.max(mutable, GLM_NARUTO_DEFAULTS.safe_active_start);
+    const patchWorkers = Math.ceil(total * GLM_NARUTO_DEFAULTS.patch_worker_ratio);
+    const scouts = Math.max(0, Math.floor(total * GLM_NARUTO_DEFAULTS.scout_ratio));
+    const verifiers = Math.max(1, total - patchWorkers - scouts);
+    return { patch_workers: patchWorkers, scouts, verifiers };
+}
+//# sourceMappingURL=glm-naruto-shard-planner.js.map

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

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../../../fsx.js';
+export function createMissionTrace(missionId) {
+    return {
+        missionId,
+        startedMs: Date.now(),
+        workerTraces: []
+    };
+}
+export function recordWorkerTrace(state, trace) {
+    return { ...state, workerTraces: [...state.workerTraces, trace] };
+}
+export async function writeMissionArtifacts(input) {
+    const dir = path.join(input.root, '.sneakoscope', 'glm-naruto', input.missionId);
+    if (input.workGraph)
+        await writeJsonAtomic(path.join(dir, 'work-graph.json'), input.workGraph);
+    if (input.conflictGraph)
+        await writeJsonAtomic(path.join(dir, 'conflict-graph.json'), input.conflictGraph);
+    if (input.mergePlan)
+        await writeJsonAtomic(path.join(dir, 'final-merge-plan.json'), input.mergePlan);
+    if (input.judgeResult)
+        await writeJsonAtomic(path.join(dir, 'judge-result.json'), input.judgeResult);
+    if (input.workerTraces.length > 0)
+        await writeJsonAtomic(path.join(dir, 'worker-traces.json'), input.workerTraces);
+    if (input.providerHealth)
+        await writeJsonAtomic(path.join(dir, 'provider-health.json'), input.providerHealth);
+    if (input.termination)
+        await writeJsonAtomic(path.join(dir, 'termination.json'), input.termination);
+    if (input.applyResult)
+        await writeJsonAtomic(path.join(dir, 'apply-result.json'), input.applyResult);
+    if (input.verificationSummary)
+        await writeJsonAtomic(path.join(dir, 'verification-summary.json'), input.verificationSummary);
+    if (input.missionResult)
+        await writeJsonAtomic(path.join(dir, 'mission-result.json'), input.missionResult);
+    return dir;
+}
+export function buildMissionSummary(input) {
+    return {
+        wall_clock_ms: Date.now() - input.startedMs,
+        workers_started: input.workerTraces.length,
+        workers_completed: input.workerTraces.filter((t) => t.status === 'completed').length,
+        patch_candidates: input.patchCandidates,
+        gate_passed_candidates: input.gatePassed,
+        mergeable_candidates: input.mergeable,
+        applied_patches: input.appliedPatches,
+        failed_shards: input.failedShards,
+        repair_waves: input.repairWaves,
+        budget_used_ms: Date.now() - input.startedMs
+    };
+}
+//# sourceMappingURL=glm-naruto-trace.js.map

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

@@ -0,0 +1,37 @@
+import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
+export const GLM_NARUTO_LIMITS = {
+    max_waves_speed: 3,
+    max_waves_deep: 5,
+    max_wall_clock_ms: 300_000,
+    max_worker_runtime_ms: 90_000,
+    max_total_requests: 128,
+    max_requests_per_shard: 4,
+    max_no_progress_waves: 1,
+    max_repeated_patch_digest: 1,
+    max_repair_waves: 1,
+    max_merge_attempts: 2
+};
+export const GLM_NARUTO_DEFAULTS = {
+    default_clones: 12,
+    safe_active_start: 6,
+    max_clones: 64,
+    patch_worker_ratio: 0.70,
+    scout_ratio: 0.10,
+    verifier_ratio: 0.20,
+    default_patches_per_shard: 2,
+    critical_patches_per_shard: 3,
+    default_max_tokens: 4096,
+    judge_max_tokens: 8192,
+    patch_temperature: 0.25,
+    patch_top_p: 0.85,
+    judge_temperature: 0.1,
+    judge_top_p: 0.8
+};
+export const NARUTO_PATCH_STRATEGIES = [
+    'minimal_patch',
+    'test_first_fix',
+    'type_safe_fix',
+    'refactor_local',
+    'defensive_fix'
+];
+//# sourceMappingURL=glm-naruto-types.js.map

package/dist/core/providers/glm/naruto/glm-naruto-work-graph.js

@@ -0,0 +1,2 @@
+export { decomposeTask, validateWorkGraph } from './glm-naruto-decomposer.js';
+//# sourceMappingURL=glm-naruto-work-graph.js.map