sneakoscope 7.0.2 → 7.0.5

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

@@ -1,421 +0,0 @@
-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';
-import { parseGlmNarutoVerifierOutput } from './glm-naruto-verifier-output.js';
-import { writeGlmNarutoWorkerArtifacts } from './glm-naruto-worker-artifacts.js';
-import { extractGlmNarutoUsageMetrics } from './glm-naruto-usage-extractor.js';
-import { normalizeGlmNarutoSessionId } from './glm-naruto-session-id.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 artifactRoot = input.root ?? process.cwd();
-    const sessionId = normalizeGlmNarutoSessionId(`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 stablePrefixDigest = crypto.createHash('sha256').update(STABLE_SYSTEM_PREFIX).digest('hex');
-    const shardSuffixDigest = crypto.createHash('sha256').update(shardSuffix).digest('hex');
-    const cacheKeyParts = {
-        model: requestWithSession.model,
-        profile: 'glm-naruto-worker-speed',
-        stable_prefix_digest: stablePrefixDigest,
-        shard_suffix_digest: shardSuffixDigest,
-        tools_digest: requestWithSession.tools ? crypto.createHash('sha256').update(JSON.stringify(requestWithSession.tools)).digest('hex') : null,
-        response_format_digest: requestWithSession.response_format ? crypto.createHash('sha256').update(JSON.stringify(requestWithSession.response_format)).digest('hex') : null,
-        provider_digest: crypto.createHash('sha256').update(JSON.stringify(requestWithSession.provider ?? null)).digest('hex'),
-        session_id: sessionId
-    };
-    const encoded = encodeGlmRequestWithCache({ request: requestWithSession, cacheKeyParts });
-    await writeGlmNarutoWorkerArtifacts({
-        root: artifactRoot,
-        missionId: input.missionId,
-        workerId: input.workerId,
-        shardId: input.shard.id,
-        requestSummary: {
-            model: requestWithSession.model,
-            provider: 'openrouter',
-            session_id: sessionId,
-            request_body_sha256: encoded.entry.bodySha256,
-            request_body_size: encoded.entry.byteLength,
-            request_body_stored: encoded.entry.bodyStored,
-            cache_hit: encoded.cacheHit,
-            gpt_fallback_allowed: false,
-            fallback_models_count: Array.isArray(requestWithSession.models) ? requestWithSession.models?.length ?? 0 : 0,
-            openai_key_used: false,
-            authorization_source: 'openrouter',
-            stable_prefix_digest: stablePrefixDigest,
-            shard_suffix_digest: shardSuffixDigest
-        }
-    }).catch(() => undefined);
-    const traceBase = {
-        worker_id: input.workerId,
-        shard_id: input.shard.id,
-        strategy: input.shard.strategy,
-        model: GLM_52_OPENROUTER_MODEL,
-        provider: 'openrouter',
-        provider_slug: '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,
-            cacheKeyParts,
-            ...(input.fetchImpl ? { fetchImpl: input.fetchImpl } : {})
-        });
-        if (!response.ok) {
-            const issue = classifyWorkerIssue(response.error);
-            const trace = { ...traceBase, total_ms: Date.now() - started, status: 'failed', chunk_count: 0, real_stream: false };
-            await writeGlmNarutoWorkerArtifacts({
-                root: artifactRoot,
-                missionId: input.missionId,
-                workerId: input.workerId,
-                shardId: input.shard.id,
-                streamTrace: trace,
-                termination: { status: 'failed', ok: false, error: response.error.code }
-            }).catch(() => undefined);
-            return {
-                envelope: null,
-                trace,
-                ok: false,
-                error: response.error.code,
-                issue
-            };
-        }
-        const modelGuard = assertGlm52ActualModel(response.value.model);
-        if (!modelGuard.ok) {
-            const usage = extractGlmNarutoUsageMetrics(response.value.usage);
-            const trace = { ...traceBase, ...usage, ttft_ms: response.value.ttft_ms, total_ms: Date.now() - started, status: 'blocked', chunk_count: response.value.chunk_count, real_stream: response.value.real_stream, request_cache_hit: response.value.request_cache_hit ?? traceBase.request_cache_hit };
-            await writeGlmNarutoWorkerArtifacts({
-                root: artifactRoot,
-                missionId: input.missionId,
-                workerId: input.workerId,
-                shardId: input.shard.id,
-                streamTrace: trace,
-                termination: { status: 'blocked', ok: false, error: `model_guard:${modelGuard.code}` }
-            }).catch(() => undefined);
-            return {
-                envelope: null,
-                trace,
-                ok: false,
-                error: `model_guard:${modelGuard.code}`,
-                issue: { code: `model_guard:${modelGuard.code}`, retryable: false }
-            };
-        }
-        const parsed = parsePatchCandidateOutput(response.value.content);
-        if (parsed.kind !== 'patch') {
-            const trace = {
-                ...traceBase,
-                ...extractGlmNarutoUsageMetrics(response.value.usage),
-                ttft_ms: response.value.ttft_ms,
-                total_ms: Date.now() - started,
-                chunk_count: response.value.chunk_count,
-                real_stream: response.value.real_stream,
-                request_cache_hit: response.value.request_cache_hit ?? traceBase.request_cache_hit,
-                status: parsed.kind === 'blocked' ? 'blocked' : 'no_patch'
-            };
-            await writeGlmNarutoWorkerArtifacts({
-                root: artifactRoot,
-                missionId: input.missionId,
-                workerId: input.workerId,
-                shardId: input.shard.id,
-                streamTrace: trace,
-                termination: { status: trace.status, ok: false, error: parsed.kind }
-            }).catch(() => undefined);
-            return {
-                envelope: null,
-                trace,
-                ok: false,
-                error: parsed.kind,
-                issue: { code: parsed.kind, retryable: false }
-            };
-        }
-        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,
-            ...extractGlmNarutoUsageMetrics(response.value.usage),
-            ttft_ms: response.value.ttft_ms,
-            total_ms: Date.now() - started,
-            chunk_count: response.value.chunk_count,
-            real_stream: response.value.real_stream,
-            request_cache_hit: response.value.request_cache_hit ?? traceBase.request_cache_hit,
-            patch_digest: digestPatch(envelope.patch),
-            status: 'completed'
-        };
-        await writeGlmNarutoWorkerArtifacts({
-            root: artifactRoot,
-            missionId: input.missionId,
-            workerId: input.workerId,
-            shardId: input.shard.id,
-            streamTrace: trace,
-            patchEnvelope: envelope,
-            gateResult: {
-                schema: 'sks.glm-naruto-worker-gate-result.v1',
-                worker_id: input.workerId,
-                shard_id: input.shard.id,
-                status: 'pending_orchestrator_gate',
-                ok: false,
-                reason: 'deterministic_gate_runs_in_orchestrator_with_repo_cwd'
-            },
-            termination: { status: 'completed', ok: true }
-        }).catch(() => undefined);
-        return { envelope, trace, ok: true };
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        const trace = { ...traceBase, total_ms: Date.now() - started, status: 'failed', chunk_count: 0, real_stream: false };
-        await writeGlmNarutoWorkerArtifacts({
-            root: artifactRoot,
-            missionId: input.missionId,
-            workerId: input.workerId,
-            shardId: input.shard.id,
-            streamTrace: trace,
-            termination: { status: 'failed', ok: false, error: err instanceof Error ? err.message : String(err) }
-        }).catch(() => undefined);
-        return {
-            envelope: null,
-            trace,
-            ok: false,
-            error: message,
-            issue: classifyWorkerIssue({ code: message, message, severity: 'failed' })
-        };
-    }
-}
-function classifyWorkerIssue(issue) {
-    const code = String(issue.code || 'glm_worker_failed');
-    const status = typeof issue.status === 'number' ? issue.status : undefined;
-    const retryable = code === 'glm_openrouter_rate_limited'
-        || status === 429
-        || (typeof status === 'number' && status >= 500)
-        || code === 'glm_openrouter_provider_unavailable'
-        || code === 'glm_stream_idle_timeout'
-        || code === 'glm_request_timeout';
-    return {
-        code,
-        retryable,
-        ...(status !== undefined ? { provider_status: status } : {}),
-        retry_after_ms: null
-    };
-}
-export async function runVerifierWorker(input) {
-    const started = Date.now();
-    const sessionId = normalizeGlmNarutoSessionId(`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. Return only JSON with schema "sks.glm-naruto-verifier-output.v1", ok boolean, issues string array, risk_score number 0..1, confidence number 0..1, requirements_satisfied string array, requirements_missing string array, and detail_loss_risks string array. Do not include markdown.` },
-        { role: 'user', content: JSON.stringify({ patch_sha256: input.envelope.patch_sha256, target_paths: input.envelope.target_paths, requirements_satisfied: input.envelope.requirements_satisfied ?? [], requirements_risk: input.envelope.requirements_risk ?? [], patch: input.envelope.patch.slice(0, 4000) }) }
-    ];
-    const request = buildGlm52Request({
-        profile: 'speed',
-        messages,
-        maxTokens: 2048,
-        toolChoice: 'none',
-        parallelToolCalls: false,
-        providerSort: 'throughput'
-    });
-    const requestWithSession = { ...request, session_id: sessionId };
-    const cacheKeyParts = {
-        model: requestWithSession.model,
-        profile: 'glm-naruto-verifier-speed',
-        stable_prefix_digest: crypto.createHash('sha256').update(messages[0].content).digest('hex'),
-        shard_suffix_digest: crypto.createHash('sha256').update(messages[1].content).digest('hex'),
-        tools_digest: null,
-        response_format_digest: requestWithSession.response_format ? crypto.createHash('sha256').update(JSON.stringify(requestWithSession.response_format)).digest('hex') : null,
-        provider_digest: crypto.createHash('sha256').update(JSON.stringify(requestWithSession.provider ?? null)).digest('hex'),
-        session_id: sessionId
-    };
-    try {
-        const response = await sendOpenRouterChatCompletionStream({
-            apiKey: input.apiKey,
-            request: requestWithSession,
-            timeoutMs: input.timeoutMs,
-            idleTimeoutMs: 60_000,
-            cacheKeyParts,
-            ...(input.fetchImpl ? { fetchImpl: input.fetchImpl } : {})
-        });
-        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',
-                    provider_slug: '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]
-            };
-        }
-        const modelGuard = assertGlm52ActualModel(response.value.model);
-        const usageMetrics = extractGlmNarutoUsageMetrics(response.value.usage);
-        if (!modelGuard.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',
-                    provider_slug: 'openrouter',
-                    session_id: sessionId,
-                    ...usageMetrics,
-                    ttft_ms: response.value.ttft_ms,
-                    total_ms: Date.now() - started,
-                    chunk_count: response.value.chunk_count,
-                    real_stream: response.value.real_stream,
-                    request_cache_hit: response.value.request_cache_hit ?? false,
-                    output_digest: crypto.createHash('sha256').update(response.value.content).digest('hex'),
-                    patch_digest: input.envelope.patch_sha256,
-                    status: 'verification_failed'
-                },
-                issues: [`model_guard:${modelGuard.code}`]
-            };
-        }
-        const parsed = parseGlmNarutoVerifierOutput(response.value.content);
-        if (!parsed.ok || !parsed.output) {
-            return {
-                ok: false,
-                trace: {
-                    worker_id: input.workerId,
-                    shard_id: input.envelope.shard_id,
-                    strategy: 'minimal_patch',
-                    model: GLM_52_OPENROUTER_MODEL,
-                    provider: 'openrouter',
-                    provider_slug: 'openrouter',
-                    session_id: sessionId,
-                    ...usageMetrics,
-                    ttft_ms: response.value.ttft_ms,
-                    total_ms: Date.now() - started,
-                    chunk_count: response.value.chunk_count,
-                    real_stream: response.value.real_stream,
-                    request_cache_hit: response.value.request_cache_hit ?? false,
-                    output_digest: crypto.createHash('sha256').update(response.value.content).digest('hex'),
-                    patch_digest: input.envelope.patch_sha256,
-                    status: 'verification_failed'
-                },
-                issues: parsed.issues
-            };
-        }
-        if (!parsed.output.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',
-                    provider_slug: 'openrouter',
-                    session_id: sessionId,
-                    ...usageMetrics,
-                    ttft_ms: response.value.ttft_ms,
-                    total_ms: Date.now() - started,
-                    chunk_count: response.value.chunk_count,
-                    real_stream: response.value.real_stream,
-                    request_cache_hit: response.value.request_cache_hit ?? false,
-                    output_digest: crypto.createHash('sha256').update(response.value.content).digest('hex'),
-                    patch_digest: input.envelope.patch_sha256,
-                    status: 'verification_failed',
-                    verifier_risk_score: parsed.output.risk_score,
-                    verifier_confidence: parsed.output.confidence
-                },
-                issues: parsed.output.issues
-            };
-        }
-        return {
-            ok: true,
-            trace: {
-                worker_id: input.workerId,
-                shard_id: input.envelope.shard_id,
-                strategy: 'minimal_patch',
-                model: GLM_52_OPENROUTER_MODEL,
-                provider: 'openrouter',
-                provider_slug: 'openrouter',
-                session_id: sessionId,
-                ...usageMetrics,
-                ttft_ms: response.value.ttft_ms,
-                total_ms: Date.now() - started,
-                chunk_count: response.value.chunk_count,
-                real_stream: response.value.real_stream,
-                request_cache_hit: response.value.request_cache_hit ?? false,
-                output_digest: crypto.createHash('sha256').update(response.value.content).digest('hex'),
-                patch_digest: input.envelope.patch_sha256,
-                status: 'verification_passed',
-                verifier_risk_score: parsed.output.risk_score,
-                verifier_confidence: parsed.output.confidence
-            },
-            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',
-                provider_slug: '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)]
-        };
-    }
-}

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

@@ -1,177 +0,0 @@
-import { nowIso } from '../../../fsx.js';
-import { decideConcurrency } from './glm-naruto-concurrency-governor.js';
-export async function runGlmNarutoWorkerScheduler(input) {
-    const queue = input.jobs.map((job) => ({ job, attempt: 0 }));
-    const running = new Map();
-    const results = [];
-    const decisions = [];
-    const retryEvents = [];
-    const backpressureRecords = [];
-    const maxActive = Math.max(1, input.max_active_workers);
-    let targetActive = Math.max(1, Math.min(maxActive, input.initial_active_workers || 1));
-    let nextRunKey = 0;
-    let maxObservedActive = 0;
-    let backpressureEvents = 0;
-    let failureCount = 0;
-    let finishedCount = 0;
-    let pauseUntilMs = 0;
-    await recordDecision('initial');
-    while (queue.length > 0 || running.size > 0) {
-        const now = Date.now();
-        if (pauseUntilMs > now && running.size === 0) {
-            await sleep(Math.min(1_000, pauseUntilMs - now));
-            continue;
-        }
-        while (queue.length > 0 && running.size < targetActive && Date.now() >= pauseUntilMs) {
-            const entry = queue.shift();
-            const key = nextRunKey++;
-            running.set(key, runTimedJob(key, entry, input));
-            maxObservedActive = Math.max(maxObservedActive, running.size);
-        }
-        if (running.size === 0) {
-            if (queue.length > 0) {
-                targetActive = Math.max(1, targetActive);
-                pauseUntilMs = Math.min(pauseUntilMs || Date.now(), Date.now());
-            }
-            continue;
-        }
-        const completed = await Promise.race([...running.values()]);
-        running.delete(completed.key);
-        finishedCount++;
-        const issue = issueFromSettled(completed.settled);
-        if (completed.settled.status === 'rejected' || (completed.settled.status === 'fulfilled' && !completed.settled.value.ok)) {
-            failureCount++;
-        }
-        updateProviderHealth(input.health, completed.settled);
-        if (issue && shouldBackoff(issue)) {
-            backpressureEvents++;
-            const pauseMs = backoffMs(issue);
-            pauseUntilMs = Math.max(pauseUntilMs, Date.now() + pauseMs);
-            backpressureRecords.push({
-                schema: 'sks.glm-naruto-provider-backpressure.v1',
-                created_at: nowIso(),
-                worker_id: completed.entry.job.worker_id,
-                attempt: completed.entry.attempt,
-                code: issue.code,
-                provider_status: issue.provider_status ?? null,
-                retry_after_ms: issue.retry_after_ms ?? null,
-                pause_ms: pauseMs
-            });
-        }
-        if (shouldRetry(completed.entry, completed.settled, issue)) {
-            const retryEntry = { job: completed.entry.job, attempt: completed.entry.attempt + 1 };
-            retryEvents.push({
-                schema: 'sks.glm-naruto-worker-retry.v1',
-                created_at: nowIso(),
-                worker_id: completed.entry.job.worker_id,
-                shard_id: completed.entry.job.shard.id,
-                next_attempt: retryEntry.attempt,
-                code: issue?.code ?? 'worker_scheduler_rejected'
-            });
-            queue.push(retryEntry);
-        }
-        else {
-            results.push(completed.settled);
-        }
-        await recordDecision(issue?.code ?? 'worker_finished');
-    }
-    return {
-        results,
-        decisions,
-        max_observed_active_workers: maxObservedActive,
-        backpressure_events: backpressureEvents,
-        retry_events: retryEvents,
-        backpressure_records: backpressureRecords
-    };
-    async function recordDecision(reasonSuffix) {
-        const health = input.health.getHealth();
-        const decision = decideConcurrency({
-            requestedWorkers: maxActive,
-            activeWorkers: targetActive,
-            rateLimited429: health?.count_429 ?? 0,
-            ttftP90Ms: health?.p90_ttft_ms ?? 0,
-            failureRate: finishedCount ? failureCount / finishedCount : 0,
-            operatorMax: maxActive
-        });
-        targetActive = Math.max(running.size > 0 ? 1 : 0, Math.min(maxActive, decision.target_active_workers));
-        if (targetActive === 0 && queue.length > 0 && running.size === 0)
-            targetActive = 1;
-        const recorded = { ...decision, reason: `${decision.reason}:${reasonSuffix}` };
-        decisions.push(recorded);
-        if (recorded.backpressure)
-            backpressureEvents++;
-        await input.onDecision(recorded);
-    }
-}
-async function runTimedJob(key, entry, input) {
-    try {
-        const value = await withTimeout(input.runJob(entry.job), input.worker_timeout_ms);
-        return { key, entry, settled: { status: 'fulfilled', value } };
-    }
-    catch (reason) {
-        return { key, entry, settled: { status: 'rejected', reason } };
-    }
-}
-function updateProviderHealth(health, settled) {
-    if (settled.status !== 'fulfilled') {
-        health.record({ provider_slug: 'openrouter', model: 'z-ai/glm-5.2', count_5xx: 1, last_failure: nowIso() });
-        return;
-    }
-    const issue = settled.value.issue;
-    const trace = settled.value.trace;
-    health.record({
-        provider_slug: trace.provider_slug || 'openrouter',
-        model: trace.model,
-        ...(trace.ttft_ms !== null ? { p50_ttft_ms: trace.ttft_ms } : {}),
-        ...(issue?.provider_status === 429 || issue?.code === 'glm_openrouter_rate_limited' ? { count_429: 1 } : {}),
-        ...(typeof issue?.provider_status === 'number' && issue.provider_status >= 500 ? { count_5xx: 1 } : {}),
-        last_success: settled.value.ok ? nowIso() : null,
-        last_failure: settled.value.ok ? null : nowIso()
-    });
-}
-function issueFromSettled(settled) {
-    if (settled.status === 'rejected') {
-        return { code: 'worker_scheduler_rejected', retryable: true, retry_after_ms: null };
-    }
-    return settled.value.issue ?? null;
-}
-function shouldRetry(entry, settled, issue) {
-    if (entry.attempt >= 1)
-        return false;
-    if (settled.status === 'rejected')
-        return true;
-    return settled.value.ok === false && issue?.retryable === true;
-}
-function shouldBackoff(issue) {
-    return issue.provider_status === 429
-        || issue.code === 'glm_openrouter_rate_limited'
-        || (typeof issue.provider_status === 'number' && issue.provider_status >= 500)
-        || issue.code === 'glm_openrouter_provider_unavailable'
-        || issue.code === 'glm_stream_idle_timeout'
-        || issue.code === 'glm_request_timeout';
-}
-function backoffMs(issue) {
-    if (typeof issue.retry_after_ms === 'number' && Number.isFinite(issue.retry_after_ms) && issue.retry_after_ms > 0) {
-        return Math.min(30_000, issue.retry_after_ms);
-    }
-    if (issue.provider_status === 429 || issue.code === 'glm_openrouter_rate_limited')
-        return 1_000;
-    return 250;
-}
-function withTimeout(promise, timeoutMs) {
-    if (!timeoutMs || timeoutMs <= 0)
-        return promise;
-    let timer;
-    return Promise.race([
-        promise,
-        new Promise((_, reject) => {
-            timer = setTimeout(() => reject(new Error('worker_scheduler_timeout')), timeoutMs);
-        })
-    ]).finally(() => {
-        if (timer)
-            clearTimeout(timer);
-    });
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
-}

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

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

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

@@ -1,19 +0,0 @@
-import { nowIso, writeJsonAtomic } from '../../../fsx.js';
-import path from 'node:path';
-import { removeGlmNarutoWorkerWorktree } from './glm-naruto-worktree-manager.js';
-export async function cleanupGlmNarutoWorktree(input) {
-    const result = input.cleanup
-        ? await removeGlmNarutoWorkerWorktree(input.repoRoot, input.lease)
-        : { ok: false, error: null };
-    const record = {
-        schema: 'sks.glm-naruto-worktree-cleanup.v1',
-        worker_id: input.lease.worker_id,
-        worktree_path: input.lease.path,
-        cleanup_requested: input.cleanup,
-        removed: input.cleanup ? result.ok : false,
-        error: input.cleanup ? result.error ?? null : null,
-        created_at: nowIso()
-    };
-    await writeJsonAtomic(path.join(input.repoRoot, '.sneakoscope', 'glm-naruto', input.missionId, 'workers', input.lease.worker_id, 'worktree-cleanup.json'), record).catch(() => undefined);
-    return record;
-}