sneakoscope 4.0.7 → 4.0.9

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,91 @@
+import path from 'node:path';
+import { ensureDir, 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);
+    await ensureDir(dir);
+    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);
+    // 4.0.9: Write per-worker patch envelope / request-summary / stream-trace / gate-result artifacts.
+    if (input.envelopes && input.envelopes.length > 0) {
+        const workersDir = path.join(dir, 'workers');
+        await ensureDir(workersDir);
+        for (const env of input.envelopes) {
+            const workerId = String(env.worker_id || env.shard_id || 'unknown');
+            const workerDir = path.join(workersDir, workerId);
+            await ensureDir(workerDir);
+            await writeJsonAtomic(path.join(workerDir, 'patch-envelope.json'), env);
+            await writeJsonAtomic(path.join(workerDir, 'request-summary.json'), {
+                schema: 'sks.glm-naruto-worker-request-summary.v1',
+                worker_id: workerId,
+                shard_id: env.shard_id,
+                model: env.model || null,
+                provider: 'openrouter',
+                request_body_size: env.request_body_size ?? null,
+                cached: env.cached ?? false,
+                created_at: nowIso(),
+            });
+            await writeJsonAtomic(path.join(workerDir, 'stream-trace.json'), {
+                schema: 'sks.glm-naruto-worker-stream-trace.v1',
+                worker_id: workerId,
+                ttft_ms: env.ttft_ms ?? null,
+                chunk_count: env.chunk_count ?? null,
+                real_stream: env.real_stream ?? true,
+                idle_timeout_ms: env.idle_timeout_ms ?? null,
+                created_at: nowIso(),
+            });
+            await writeJsonAtomic(path.join(workerDir, 'gate-result.json'), {
+                schema: 'sks.glm-naruto-worker-gate-result.v1',
+                worker_id: workerId,
+                shard_id: env.shard_id,
+                status: env.status,
+                gate_passed: env.status === 'gate_passed',
+                verification_passed: env.verification_passed ?? (env.status === 'gate_passed'),
+                created_at: nowIso(),
+            });
+        }
+    }
+    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

package/dist/core/providers/glm/naruto/glm-naruto-worker-pool.js

@@ -0,0 +1,79 @@
+import { runPatchWorker } from './glm-naruto-worker-runtime.js';
+import { checkAndApplyGlmPatch } from '../glm-patch-apply.js';
+import { evaluateGlmSpeedGate } from '../glm-speed-gate.js';
+import { decideConcurrency } from './glm-naruto-concurrency-governor.js';
+import { planFileLeases } from './glm-naruto-file-lease.js';
+export async function runPatchWorkerPool(input) {
+    const envelopes = [];
+    const traces = [];
+    const failedShardIds = [];
+    const concurrencyDecisions = [];
+    const shardPathMap = new Map();
+    for (const shard of input.shards) {
+        shardPathMap.set(shard.id, shard.target_paths);
+    }
+    const leases = planFileLeases(shardPathMap);
+    const mutableShards = input.shards.filter((s) => s.mutable);
+    const decision = decideConcurrency({
+        requestedClones: input.maxWorkers,
+        activeWorkers: Math.min(input.maxWorkers, mutableShards.length),
+        rateLimited429: 0,
+        ttftP90Ms: 0,
+        failureRate: 0,
+        operatorMax: input.maxWorkers
+    });
+    concurrencyDecisions.push(decision);
+    const workerTasks = [];
+    let workerIdx = 0;
+    for (const shard of mutableShards) {
+        const strategies = input.strategies.get(shard.id) || [shard.strategy];
+        for (const strategy of strategies) {
+            const workerId = `worker-${shard.id}-${strategy}-${workerIdx++}`;
+            const shardWithStrategy = { ...shard, strategy };
+            workerTasks.push(runPatchWorker({
+                apiKey: input.apiKey,
+                missionId: input.missionId,
+                workerId,
+                shard: shardWithStrategy,
+                contextSummary: input.contextSummary,
+                timeoutMs: input.workerTimeoutMs
+            }));
+        }
+    }
+    const results = await Promise.allSettled(workerTasks);
+    for (const result of results) {
+        if (result.status === 'fulfilled' && result.value.ok && result.value.envelope) {
+            const gate = evaluateGlmSpeedGate(result.value.envelope.patch);
+            let envelope = result.value.envelope;
+            if (gate.ok) {
+                const applyCheck = await checkAndApplyGlmPatch({
+                    cwd: input.cwd,
+                    patch: envelope.patch,
+                    apply: false
+                });
+                envelope = applyCheck.ok
+                    ? { ...envelope, status: 'gate_passed' }
+                    : { ...envelope, status: 'gate_failed', blockers: [applyCheck.error.code] };
+            }
+            else {
+                envelope = {
+                    ...envelope,
+                    status: 'gate_failed',
+                    blockers: gate.checks.filter((c) => !c.ok).map((c) => c.reason || c.id)
+                };
+            }
+            envelopes.push(envelope);
+            traces.push(result.value.trace);
+        }
+        else if (result.status === 'fulfilled') {
+            traces.push(result.value.trace);
+            failedShardIds.push(result.value.trace.shard_id);
+        }
+        else {
+            // rejected promise
+            failedShardIds.push('unknown');
+        }
+    }
+    return { envelopes, traces, failedShardIds, concurrencyDecisions };
+}
+//# sourceMappingURL=glm-naruto-worker-pool.js.map

package/dist/core/providers/glm/naruto/glm-naruto-worker-runtime.js

@@ -0,0 +1,198 @@
+import crypto from 'node:crypto';
+import { nowIso } from '../../../fsx.js';
+import { GLM_52_OPENROUTER_MODEL } from '../glm-52-settings.js';
+import { buildGlm52Request } from '../glm-52-request.js';
+import { sendOpenRouterChatCompletionStream } from '../../openrouter/openrouter-stream.js';
+import { assertGlm52ActualModel } from '../glm-52-response-guard.js';
+import { encodeGlmRequestWithCache } from '../glm-request-cache.js';
+import { parsePatchCandidateOutput, createPatchEnvelope, digestPatch } from './glm-naruto-patch-envelope.js';
+const STABLE_SYSTEM_PREFIX = `You are a SKS GLM Naruto patch worker. Model lock: ${GLM_52_OPENROUTER_MODEL}. No GPT/OpenAI fallback allowed. Output only <sks_patch_candidate>, <sks_need_context>, or <sks_blocked> envelopes. Use unified diff format for patches. Never write to main workspace directly. Follow proof-first mutation rules.`;
+export async function runPatchWorker(input) {
+    const started = Date.now();
+    const sessionId = `sks-glm-naruto-${input.missionId}-${input.workerId}`;
+    const reasoningEffort = input.shard.reasoning;
+    const shardSuffix = JSON.stringify({
+        shard_id: input.shard.id,
+        task: input.shard.task,
+        target_paths: input.shard.target_paths,
+        forbidden_paths: input.shard.forbidden_paths,
+        base_digest: input.shard.base_digest,
+        strategy: input.shard.strategy,
+        context: input.contextSummary,
+        output_requirement: 'Produce a unified diff patch inside <sks_patch_candidate> tags with summary, target_paths, base_digest, strategy, and patch fields.'
+    });
+    const messages = [
+        { role: 'system', content: STABLE_SYSTEM_PREFIX },
+        { role: 'user', content: shardSuffix }
+    ];
+    const request = buildGlm52Request({
+        profile: 'speed',
+        messages,
+        maxTokens: input.shard.max_tokens,
+        toolChoice: 'none',
+        parallelToolCalls: false,
+        providerSort: 'throughput'
+    });
+    const requestWithSession = { ...request, session_id: sessionId };
+    const encoded = encodeGlmRequestWithCache(requestWithSession);
+    const traceBase = {
+        worker_id: input.workerId,
+        shard_id: input.shard.id,
+        strategy: input.shard.strategy,
+        model: GLM_52_OPENROUTER_MODEL,
+        provider: 'openrouter',
+        session_id: sessionId,
+        ttft_ms: null,
+        total_ms: 0,
+        request_cache_hit: encoded.cacheHit,
+        output_digest: crypto.createHash('sha256').update(shardSuffix).digest('hex'),
+        patch_digest: null,
+        status: 'running'
+    };
+    try {
+        const response = await sendOpenRouterChatCompletionStream({
+            apiKey: input.apiKey,
+            request: requestWithSession,
+            timeoutMs: input.timeoutMs,
+            idleTimeoutMs: 60_000
+        });
+        if (!response.ok) {
+            return {
+                envelope: null,
+                trace: { ...traceBase, total_ms: Date.now() - started, status: 'failed' },
+                ok: false,
+                error: response.error.code
+            };
+        }
+        const modelGuard = assertGlm52ActualModel(response.value.model);
+        if (!modelGuard.ok) {
+            return {
+                envelope: null,
+                trace: { ...traceBase, total_ms: Date.now() - started, status: 'blocked' },
+                ok: false,
+                error: `model_guard:${modelGuard.code}`
+            };
+        }
+        const parsed = parsePatchCandidateOutput(response.value.content);
+        if (parsed.kind !== 'patch') {
+            return {
+                envelope: null,
+                trace: {
+                    ...traceBase,
+                    ttft_ms: response.value.ttft_ms,
+                    total_ms: Date.now() - started,
+                    status: parsed.kind === 'blocked' ? 'blocked' : 'no_patch'
+                },
+                ok: false,
+                error: parsed.kind
+            };
+        }
+        const envelope = createPatchEnvelope({
+            missionId: input.missionId,
+            workerId: input.workerId,
+            shardId: input.shard.id,
+            baseDigest: input.shard.base_digest,
+            patch: parsed.content,
+            strategy: input.shard.strategy,
+            reasoningEffort
+        });
+        const trace = {
+            ...traceBase,
+            ttft_ms: response.value.ttft_ms,
+            total_ms: Date.now() - started,
+            patch_digest: digestPatch(envelope.patch),
+            status: 'completed'
+        };
+        return { envelope, trace, ok: true };
+    }
+    catch (err) {
+        return {
+            envelope: null,
+            trace: { ...traceBase, total_ms: Date.now() - started, status: 'failed' },
+            ok: false,
+            error: err instanceof Error ? err.message : String(err)
+        };
+    }
+}
+export async function runVerifierWorker(input) {
+    const started = Date.now();
+    const sessionId = `sks-glm-naruto-verify-${input.missionId}-${input.workerId}`;
+    const messages = [
+        { role: 'system', content: `You are a SKS GLM Naruto verifier. Model: ${GLM_52_OPENROUTER_MODEL}. No GPT fallback. Check if the patch is correct and safe. Output JSON: {"ok":true/false,"issues":["..."]}` },
+        { role: 'user', content: JSON.stringify({ patch_sha256: input.envelope.patch_sha256, target_paths: input.envelope.target_paths, patch: input.envelope.patch.slice(0, 4000) }) }
+    ];
+    const request = buildGlm52Request({
+        profile: 'speed',
+        messages,
+        maxTokens: 2048,
+        toolChoice: 'none',
+        parallelToolCalls: false
+    });
+    try {
+        const response = await sendOpenRouterChatCompletionStream({
+            apiKey: input.apiKey,
+            request: { ...request, session_id: sessionId },
+            timeoutMs: input.timeoutMs,
+            idleTimeoutMs: 60_000
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                trace: {
+                    worker_id: input.workerId,
+                    shard_id: input.envelope.shard_id,
+                    strategy: 'minimal_patch',
+                    model: GLM_52_OPENROUTER_MODEL,
+                    provider: 'openrouter',
+                    session_id: sessionId,
+                    ttft_ms: null,
+                    total_ms: Date.now() - started,
+                    request_cache_hit: false,
+                    output_digest: '',
+                    patch_digest: input.envelope.patch_sha256,
+                    status: 'failed'
+                },
+                issues: [response.error.code]
+            };
+        }
+        return {
+            ok: true,
+            trace: {
+                worker_id: input.workerId,
+                shard_id: input.envelope.shard_id,
+                strategy: 'minimal_patch',
+                model: GLM_52_OPENROUTER_MODEL,
+                provider: 'openrouter',
+                session_id: sessionId,
+                ttft_ms: response.value.ttft_ms,
+                total_ms: Date.now() - started,
+                request_cache_hit: false,
+                output_digest: crypto.createHash('sha256').update(response.value.content).digest('hex'),
+                patch_digest: input.envelope.patch_sha256,
+                status: 'completed'
+            },
+            issues: []
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            trace: {
+                worker_id: input.workerId,
+                shard_id: input.envelope.shard_id,
+                strategy: 'minimal_patch',
+                model: GLM_52_OPENROUTER_MODEL,
+                provider: 'openrouter',
+                session_id: sessionId,
+                ttft_ms: null,
+                total_ms: Date.now() - started,
+                request_cache_hit: false,
+                output_digest: '',
+                patch_digest: input.envelope.patch_sha256,
+                status: 'failed'
+            },
+            issues: [err instanceof Error ? err.message : String(err)]
+        };
+    }
+}
+//# sourceMappingURL=glm-naruto-worker-runtime.js.map

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

@@ -0,0 +1,2 @@
+export { runPatchWorker, runVerifierWorker } from './glm-naruto-worker-runtime.js';
+//# sourceMappingURL=glm-naruto-worker.js.map

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

@@ -0,0 +1,48 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+export async function createWorktree(repoRoot, missionId, workerId, baseCommit) {
+    const branch = `sks-glm-naruto/${missionId}/${workerId}`;
+    const worktreePath = path.join(repoRoot, '.sneakoscope', 'glm-naruto', 'worktrees', missionId, workerId);
+    await runGit(repoRoot, ['worktree', 'add', '-b', branch, worktreePath, baseCommit || 'HEAD']);
+    return { path: worktreePath, workerId, branch };
+}
+export async function removeWorktree(repoRoot, worktree) {
+    try {
+        await runGit(repoRoot, ['worktree', 'remove', '--force', worktree.path]);
+        await runGit(repoRoot, ['branch', '-D', worktree.branch]);
+    }
+    catch {
+        // best-effort cleanup
+    }
+}
+export async function applyPatchToWorktree(worktreePath, patch) {
+    try {
+        const result = await runGit(worktreePath, ['apply', '--whitespace=nowarn', '-'], patch);
+        return { ok: result.code === 0, stderr: result.stderr };
+    }
+    catch (err) {
+        return { ok: false, stderr: String(err) };
+    }
+}
+export async function getWorktreeDiff(worktreePath) {
+    const result = await runGit(worktreePath, ['diff', 'HEAD']);
+    return result.stdout;
+}
+export async function resetWorktree(worktreePath) {
+    await runGit(worktreePath, ['checkout', '--', '.']);
+}
+function runGit(cwd, args, stdin) {
+    return new Promise((resolve) => {
+        const child = spawn('git', [...args], { cwd, stdio: ['pipe', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+        child.stderr.on('data', (chunk) => { stderr += String(chunk); });
+        child.on('close', (code) => resolve({ code, stdout, stderr }));
+        if (stdin !== undefined)
+            child.stdin.end(stdin);
+        else
+            child.stdin.end();
+    });
+}
+//# sourceMappingURL=glm-naruto-worktree.js.map