sneakoscope 4.0.7 → 4.0.8

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,196 @@
+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
+        });
+        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 || GLM_52_OPENROUTER_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
+        });
+        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

package/dist/core/providers/openrouter/openrouter-provider-health.js

@@ -0,0 +1,46 @@
+import { nowIso, writeJsonAtomic } from '../../fsx.js';
+import path from 'node:path';
+export function createProviderHealthTracker(providerSlug = 'openrouter', model = 'z-ai/glm-5.2') {
+    let health = {
+        schema: 'sks.openrouter-provider-health.v1',
+        provider_slug: providerSlug,
+        model,
+        p50_ttft_ms: 0,
+        p90_ttft_ms: 0,
+        p50_throughput: 0,
+        p90_throughput: 0,
+        count_429: 0,
+        count_5xx: 0,
+        last_success: null,
+        last_failure: null,
+        updated_at: nowIso()
+    };
+    const ttftSamples = [];
+    return {
+        record: (entry) => {
+            if (typeof entry.p50_ttft_ms === 'number')
+                ttftSamples.push(entry.p50_ttft_ms);
+            const p50 = ttftSamples.length > 0 ? (ttftSamples[Math.floor(ttftSamples.length * 0.5)] ?? 0) : 0;
+            const p90 = ttftSamples.length > 0 ? (ttftSamples[Math.floor(ttftSamples.length * 0.9)] ?? 0) : 0;
+            health = {
+                ...health,
+                ...entry,
+                p50_ttft_ms: p50,
+                p90_ttft_ms: p90,
+                count_429: health.count_429 + (entry.count_429 || 0),
+                count_5xx: health.count_5xx + (entry.count_5xx || 0),
+                last_success: entry.last_success || health.last_success,
+                last_failure: entry.last_failure || health.last_failure,
+                updated_at: nowIso()
+            };
+        },
+        getHealth: () => health,
+        snapshot: () => health
+    };
+}
+export async function writeProviderHealth(root, health) {
+    const out = path.join(root, '.sneakoscope', 'glm-naruto', 'provider-health.json');
+    await writeJsonAtomic(out, health);
+    return out;
+}
+//# sourceMappingURL=openrouter-provider-health.js.map

package/dist/core/providers/openrouter/openrouter-secret-store.js

@@ -110,4 +110,37 @@ async function ensureSecretDir(secretDir) {
     await fs.mkdir(secretDir, { recursive: true, mode: 0o700 });
     await fs.chmod(secretDir, 0o700).catch(() => undefined);
 }
+export async function promptForOpenRouterKeyHidden() {
+    const readline = await import('node:readline/promises');
+    const { stdin, stdout } = await import('node:process');
+    const rl = readline.createInterface({ input: stdin, output: stdout, terminal: true });
+    try {
+        // Use muted input for hidden key entry
+        let key = '';
+        const escaped = stdout.isTTY
+            ? await new Promise((resolve) => {
+                const onData = (char) => {
+                    const c = char.toString();
+                    if (c === '\r' || c === '\n' || c === '\u0004') {
+                        stdin.removeListener('data', onData);
+                        resolve(key);
+                    }
+                    else if (c === '\u0003') {
+                        stdin.removeListener('data', onData);
+                        resolve('');
+                    }
+                    else {
+                        key += c;
+                    }
+                };
+                stdin.on('data', onData);
+                stdout.write('Enter OpenRouter API key (input hidden): ');
+            })
+            : await rl.question('Enter OpenRouter API key: ');
+        return escaped.trim() || null;
+    }
+    finally {
+        rl.close();
+    }
+}
 //# sourceMappingURL=openrouter-secret-store.js.map

package/dist/core/providers/openrouter/openrouter-stream.js

@@ -22,10 +22,17 @@ export async function sendOpenRouterChatCompletionStream(input) {
         });
         if (timeout)
             clearTimeout(timeout);
-        const text = await response.text();
-        if (!response.ok)
+        if (!response.ok) {
+            const text = await response.text();
             return { ok: false, error: normalizeOpenRouterError(response.status, text) };
-        return { ok: true, value: parseOpenRouterStreamText(text, started) };
+        }
+        // Real streaming via ReadableStream reader
+        if (response.body && typeof response.body.getReader === 'function') {
+            return { ok: true, value: await readRealStream(response.body, started) };
+        }
+        // Fallback: non-streaming response
+        const text = await response.text();
+        return { ok: true, value: parseOpenRouterStreamText(text, started, false) };
     }
     catch (err) {
         if (timeout)
@@ -50,7 +57,67 @@ export async function sendOpenRouterChatCompletionStream(input) {
         };
     }
 }
-export function parseOpenRouterStreamText(text, startedAtMs = Date.now()) {
+async function readRealStream(body, startedAtMs) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    const events = [];
+    let content = '';
+    let model;
+    let usage;
+    let ttft = null;
+    let buffer = '';
+    let chunkCount = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.startsWith('data:'))
+                    continue;
+                const data = line.slice('data:'.length).trim();
+                if (!data || data === '[DONE]')
+                    continue;
+                try {
+                    const raw = JSON.parse(data);
+                    const delta = raw?.choices?.[0]?.delta?.content;
+                    if (typeof raw?.model === 'string')
+                        model = raw.model;
+                    if (raw?.usage)
+                        usage = raw.usage;
+                    if (typeof delta === 'string' && delta) {
+                        if (ttft === null)
+                            ttft = Math.max(0, Date.now() - startedAtMs);
+                        content += delta;
+                        chunkCount++;
+                        events.push({ type: 'chunk', content_delta: delta, ...(model ? { model } : {}), raw });
+                    }
+                }
+                catch {
+                    events.push({ type: 'error', raw: data });
+                }
+            }
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    events.push({ type: 'done', ...(model ? { model } : {}), ...(usage ? { usage } : {}) });
+    return {
+        content,
+        ...(model ? { model } : {}),
+        ...(usage ? { usage } : {}),
+        ttft_ms: ttft,
+        total_ms: Math.max(0, Date.now() - startedAtMs),
+        chunk_count: chunkCount,
+        events,
+        real_stream: true
+    };
+}
+export function parseOpenRouterStreamText(text, startedAtMs = Date.now(), realStream = false) {
     const events = [];
     let content = '';
     let model;
@@ -88,7 +155,8 @@ export function parseOpenRouterStreamText(text, startedAtMs = Date.now()) {
         ttft_ms: ttft,
         total_ms: Math.max(0, Date.now() - startedAtMs),
         chunk_count: events.filter((event) => event.type === 'chunk').length,
-        events
+        events,
+        real_stream: realStream
     };
 }
 //# sourceMappingURL=openrouter-stream.js.map

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '4.0.6';
+export const PACKAGE_VERSION = '4.0.8';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.0.7",
+  "version": "4.0.8",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",