sneakoscope 2.0.4 → 2.0.6

package/dist/core/local-llm/local-llm-control-adapter.js

@@ -0,0 +1,101 @@
+import { nowIso, sha256 } from '../fsx.js';
+import { evaluateLocalWorkerEligibility } from './local-worker-eligibility.js';
+import { callLocalLlmGenerate, localLlmTokensPerSecond } from './local-llm-client.js';
+import { enforceLocalLlmJsonSchema } from './local-llm-schema-enforcer.js';
+export async function runLocalLlmTask(input, opts) {
+    const started = Date.now();
+    const requestId = `local-llm:${sha256(`${nowIso()}:${input.missionId}:${input.workItemId || ''}:${input.slotId || ''}`).slice(0, 16)}`;
+    const eligibility = evaluateLocalWorkerEligibility(input, opts.config);
+    if (!eligibility.ok) {
+        return {
+            ok: false,
+            backend: 'local-llm',
+            backendFamily: 'local-llm',
+            requestId,
+            events: [],
+            finalResponse: '',
+            structuredOutput: null,
+            structuredOutputValid: false,
+            proof: buildProof(input, opts.config, requestId, started, eligibility, null, ['local_llm_eligibility_blocked', ...eligibility.blockers]),
+            blockers: ['local_llm_eligibility_blocked', ...eligibility.blockers]
+        };
+    }
+    const prompt = buildLocalLlmTaskPrompt(input, opts.outputSchema);
+    const response = await callLocalLlmGenerate(opts.config, {
+        model: opts.config.model,
+        prompt,
+        stream: false,
+        format: 'json',
+        think: opts.config.think,
+        keep_alive: opts.config.keep_alive,
+        options: { temperature: opts.config.temperature }
+    });
+    const latencyMs = Math.max(0, Date.now() - started);
+    const enforced = response.ok ? enforceLocalLlmJsonSchema(response.text, opts.outputSchema) : { ok: false, value: null, schema_valid: false, issues: [response.error] };
+    const blockers = [
+        ...(response.ok ? [] : ['local_llm_generate_failed', response.error]),
+        ...(enforced.ok ? [] : ['local_llm_structured_output_invalid', ...(enforced.issues || []).map((issue) => `schema:${String(issue)}`)])
+    ];
+    const event = {
+        schema: 'sks.local-llm-event.v1',
+        generated_at: nowIso(),
+        type: response.ok ? 'local_llm_generate_completed' : 'local_llm_generate_failed',
+        request_id: requestId,
+        latency_ms: latencyMs,
+        schema_valid: enforced.schema_valid === true
+    };
+    return {
+        ok: blockers.length === 0,
+        backend: 'local-llm',
+        backendFamily: 'local-llm',
+        requestId,
+        events: [event],
+        finalResponse: JSON.stringify(enforced.value || {}),
+        structuredOutput: enforced.value,
+        structuredOutputValid: enforced.schema_valid === true,
+        proof: buildProof(input, opts.config, requestId, started, eligibility, response.ok ? response.data : null, blockers, latencyMs, response.ok ? localLlmTokensPerSecond(response.data, response.text, latencyMs) : 0),
+        blockers
+    };
+}
+function buildLocalLlmTaskPrompt(input, outputSchema) {
+    return [
+        'You are an SKS local LLM worker backend. You are worker-only.',
+        'You must not make strategy, planning, safety, verification, integration, or final acceptance decisions.',
+        'Return JSON only. Natural language outside JSON is invalid.',
+        'Your output is a draft and requires GPT Final Arbiter before final acceptance or patch application.',
+        JSON.stringify({
+            route: input.route,
+            mission_id: input.missionId,
+            work_item_id: input.workItemId || null,
+            slot_id: input.slotId || null,
+            sandbox_policy: input.sandboxPolicy,
+            prompt: input.prompt,
+            output_schema: outputSchema
+        }, null, 2)
+    ].join('\n');
+}
+function buildProof(input, config, requestId, started, eligibility, rawResponse, blockers, latencyMs = Math.max(0, Date.now() - started), tokensPerSecond = 0) {
+    return {
+        schema: 'sks.local-llm-proof.v1',
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        request_id: requestId,
+        provider: config.provider,
+        model: config.model,
+        endpoint: config.base_url,
+        backend: 'local-llm',
+        backend_family: 'local-llm',
+        route: input.route,
+        mission_id: input.missionId,
+        work_item_id: input.workItemId || null,
+        slot_id: input.slotId || null,
+        safety_scope: 'worker_only_requires_gpt_final',
+        latency_ms: latencyMs,
+        tokens_per_second: tokensPerSecond,
+        schema_valid: blockers.length === 0,
+        eligibility,
+        raw_response: rawResponse,
+        blockers
+    };
+}
+//# sourceMappingURL=local-llm-control-adapter.js.map

package/dist/core/local-llm/local-llm-json-repair.js

@@ -0,0 +1,52 @@
+export function parseOrRepairLocalLlmJson(text) {
+    const raw = String(text || '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+    const direct = tryParse(raw);
+    if (direct.ok)
+        return { ok: true, value: direct.value, repaired: false, attempts: 0 };
+    const extracted = extractFirstJsonObject(raw);
+    if (extracted) {
+        const parsed = tryParse(extracted);
+        if (parsed.ok)
+            return { ok: true, value: parsed.value, repaired: true, attempts: 1 };
+    }
+    return { ok: false, value: null, repaired: false, attempts: 1, error: direct.error || 'json_parse_failed' };
+}
+function tryParse(text) {
+    try {
+        return { ok: true, value: JSON.parse(text) };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function extractFirstJsonObject(text) {
+    const start = text.indexOf('{');
+    if (start < 0)
+        return '';
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < text.length; i += 1) {
+        const ch = text[i];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (ch === '\\')
+                escaped = true;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '{')
+            depth += 1;
+        else if (ch === '}') {
+            depth -= 1;
+            if (depth === 0)
+                return text.slice(start, i + 1);
+        }
+    }
+    return '';
+}
+//# sourceMappingURL=local-llm-json-repair.js.map

package/dist/core/local-llm/local-llm-metrics.js

@@ -0,0 +1,42 @@
+import { classifyLocalLlmBackpressure } from './local-llm-backpressure.js';
+export function buildLocalLlmMetrics(input) {
+    const latencies = numeric(input.latencyMsSamples);
+    const metrics = {
+        schema: 'sks.local-llm-metrics.v1',
+        provider: input.provider || 'ollama',
+        model: input.model || 'unknown',
+        active_requests: Math.max(0, Math.floor(Number(input.activeRequests || 0))),
+        max_parallel_requests: Math.max(1, Math.floor(Number(input.maxParallelRequests || 1))),
+        queue_depth: Math.max(0, Math.floor(Number(input.queueDepth || 0))),
+        avg_first_token_ms: average(numeric(input.firstTokenMsSamples)),
+        avg_tokens_per_second: average(numeric(input.tokenPerSecondSamples)),
+        p95_latency_ms: percentile(latencies, 0.95)
+    };
+    const backpressureInput = {
+        activeRequests: metrics.active_requests,
+        maxParallelRequests: metrics.max_parallel_requests,
+        queueDepth: metrics.queue_depth
+    };
+    if (metrics.p95_latency_ms !== undefined)
+        backpressureInput.p95LatencyMs = metrics.p95_latency_ms;
+    return {
+        ...metrics,
+        backpressure: classifyLocalLlmBackpressure(backpressureInput).state
+    };
+}
+function numeric(values = []) {
+    return values.map(Number).filter((value) => Number.isFinite(value) && value >= 0);
+}
+function average(values) {
+    if (!values.length)
+        return 0;
+    return Number((values.reduce((sum, value) => sum + value, 0) / values.length).toFixed(2));
+}
+function percentile(values, p) {
+    if (!values.length)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.min(sorted.length - 1, Math.ceil(sorted.length * p) - 1);
+    return sorted[index];
+}
+//# sourceMappingURL=local-llm-metrics.js.map

package/dist/core/local-llm/local-llm-ollama-client.js

@@ -0,0 +1,67 @@
+export async function probeOllamaVersion(baseUrl, timeoutMs = 3000) {
+    try {
+        const response = await fetch(`${trimTrailingSlash(baseUrl)}/api/version`, { signal: AbortSignal.timeout(timeoutMs) });
+        const text = await response.text();
+        return { ok: response.ok, status: response.status, data: response.ok ? JSON.parse(text) : null, error: response.ok ? null : text.slice(0, 500) };
+    }
+    catch (error) {
+        return { ok: false, status: 0, data: null, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function listOllamaModels(baseUrl, timeoutMs = 5000) {
+    try {
+        const response = await fetch(`${trimTrailingSlash(baseUrl)}/api/tags`, { signal: AbortSignal.timeout(timeoutMs) });
+        const text = await response.text();
+        const data = response.ok ? JSON.parse(text) : null;
+        const models = Array.isArray(data?.models) ? data.models.map((model) => String(model?.name || '')).filter(Boolean) : [];
+        return { ok: response.ok, status: response.status, models, data, error: response.ok ? null : text.slice(0, 500) };
+    }
+    catch (error) {
+        return { ok: false, status: 0, models: [], data: null, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export async function callOllamaGenerate(config, request) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.max(1, Number(config.timeout_ms || 20_000)));
+    try {
+        const response = await fetch(`${trimTrailingSlash(config.base_url)}/api/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+            signal: controller.signal
+        });
+        const text = await response.text();
+        if (!response.ok)
+            return { ok: false, status: response.status, error: `http_${response.status}:${text.slice(0, 500)}` };
+        const data = JSON.parse(text);
+        return { ok: true, data, text: extractOllamaText(data) };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function extractOllamaText(data) {
+    if (typeof data.response === 'string')
+        return data.response;
+    if (typeof data.message?.content === 'string')
+        return data.message.content;
+    if (typeof data.content === 'string')
+        return data.content;
+    return '';
+}
+export function ollamaTokensPerSecond(data, fallbackText = '', latencyMs = 0) {
+    const evalCount = Number(data.eval_count || 0);
+    const evalDurationNs = Number(data.eval_duration || 0);
+    if (evalCount > 0 && evalDurationNs > 0)
+        return Number((evalCount / (evalDurationNs / 1_000_000_000)).toFixed(2));
+    const approximateTokens = Math.max(1, Math.ceil(fallbackText.length / 4));
+    const seconds = Math.max(0.001, latencyMs / 1000);
+    return Number((approximateTokens / seconds).toFixed(2));
+}
+function trimTrailingSlash(value) {
+    return String(value || '').replace(/\/+$/, '');
+}
+//# sourceMappingURL=local-llm-ollama-client.js.map

package/dist/core/local-llm/local-llm-openai-compatible-client.js

@@ -0,0 +1,30 @@
+export async function callOpenAiCompatibleLocalChat(input, timeoutMs = 20_000) {
+    try {
+        const response = await fetch(`${input.endpoint.replace(/\/+$/, '')}/v1/chat/completions`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: input.model,
+                messages: input.messages,
+                temperature: input.temperature ?? 0
+            }),
+            signal: AbortSignal.timeout(timeoutMs)
+        });
+        const text = await response.text();
+        return {
+            ok: response.ok,
+            status: response.status,
+            data: response.ok ? JSON.parse(text) : null,
+            error: response.ok ? null : text.slice(0, 500)
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            status: 0,
+            data: null,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+//# sourceMappingURL=local-llm-openai-compatible-client.js.map

package/dist/core/local-llm/local-llm-prompt-cache.js

@@ -0,0 +1,12 @@
+import { buildLocalLlmContextCacheKey } from './local-llm-context-cache.js';
+export function buildLocalLlmPromptCacheRecord(input) {
+    const key = buildLocalLlmContextCacheKey(input);
+    return {
+        schema: 'sks.local-llm-prompt-cache.v1',
+        cache_key: key.key,
+        source_hashes: input,
+        cacheable: Object.values(input).every(Boolean),
+        forbidden_material: ['secrets', 'auth tokens', 'raw private config']
+    };
+}
+//# sourceMappingURL=local-llm-prompt-cache.js.map

package/dist/core/local-llm/local-llm-scheduler.js

@@ -0,0 +1,29 @@
+import { buildLocalLlmMetrics } from './local-llm-metrics.js';
+export function planLocalLlmSchedule(input) {
+    const max = Math.max(1, Math.floor(Number(input.maxParallelRequests || 1)));
+    const active = Math.max(0, Math.floor(Number(input.activeRequests || 0)));
+    const available = Math.max(0, max - active);
+    const queueDepth = Math.max(0, input.workItems.length - available);
+    const dispatch = input.workItems.slice(0, available);
+    const queued = input.workItems.slice(available);
+    const metrics = buildLocalLlmMetrics({
+        activeRequests: active + dispatch.length,
+        maxParallelRequests: max,
+        queueDepth,
+        latencyMsSamples: input.latencyMsSamples || []
+    });
+    return {
+        schema: 'sks.local-llm-scheduler-plan.v1',
+        ok: metrics.active_requests <= max,
+        max_parallel_requests: max,
+        active_requests: metrics.active_requests,
+        dispatch_count: dispatch.length,
+        queued_count: queued.length,
+        backpressure: metrics.backpressure,
+        dispatch,
+        queued,
+        metrics,
+        blockers: metrics.active_requests <= max ? [] : ['local_llm_active_requests_exceeded']
+    };
+}
+//# sourceMappingURL=local-llm-scheduler.js.map

package/dist/core/local-llm/local-llm-schema-enforcer.js

@@ -0,0 +1,15 @@
+import { validateJsonSchemaRecursive } from '../json-schema-validator.js';
+import { parseOrRepairLocalLlmJson } from './local-llm-json-repair.js';
+export function enforceLocalLlmJsonSchema(text, schema) {
+    const parsed = parseOrRepairLocalLlmJson(text);
+    const validation = parsed.ok ? validateJsonSchemaRecursive(parsed.value, schema) : { ok: false, issues: [parsed.error || 'json_parse_failed'] };
+    return {
+        ok: parsed.ok && validation.ok,
+        value: parsed.ok ? parsed.value : null,
+        repaired: parsed.repaired,
+        repair_attempts: parsed.attempts,
+        schema_valid: validation.ok,
+        issues: validation.issues
+    };
+}
+//# sourceMappingURL=local-llm-schema-enforcer.js.map

package/dist/core/local-llm/local-llm-smoke.js

@@ -0,0 +1,83 @@
+import os from 'node:os';
+import path from 'node:path';
+import { ensureDir, nowIso, sha256, writeJsonAtomic } from '../fsx.js';
+import { detectLocalLlmCapability } from './local-llm-capability.js';
+import { callLocalLlmGenerate, localLlmTokensPerSecond } from './local-llm-client.js';
+import { enforceLocalLlmJsonSchema } from './local-llm-schema-enforcer.js';
+export const LOCAL_LLM_SMOKE_SCHEMA = 'sks.local-llm-smoke.v1';
+export const localLlmSmokeSchema = {
+    type: 'object',
+    required: ['status', 'summary'],
+    properties: {
+        status: { type: 'string' },
+        summary: { type: 'string' }
+    },
+    additionalProperties: false
+};
+export async function runLocalLlmGenerationSmoke(config, opts = {}) {
+    const started = Date.now();
+    const prompt = opts.prompt || 'Return strict JSON: {"status":"ok","summary":"local smoke passed"}';
+    const schema = opts.schema || localLlmSmokeSchema;
+    const capability = await detectLocalLlmCapability(config);
+    const reportPath = expandHome(opts.reportPath || path.join(os.homedir(), '.sneakoscope', 'reports', 'local-llm-smoke.json'));
+    if (!capability.ok) {
+        const smoke = {
+            ok: false,
+            ran_at: nowIso(),
+            prompt_hash: sha256(prompt),
+            latency_ms: Math.max(0, Date.now() - started),
+            tokens_per_second: 0,
+            schema_valid: false,
+            result_path: reportPath,
+            status: 'blocked',
+            blockers: capability.blockers
+        };
+        await writeSmokeReport(reportPath, config, smoke, capability);
+        return smoke;
+    }
+    const request = {
+        model: config.model,
+        prompt,
+        stream: false,
+        format: 'json',
+        think: config.think,
+        keep_alive: config.keep_alive,
+        options: { temperature: 0 }
+    };
+    const response = await callLocalLlmGenerate({ ...config, timeout_ms: opts.timeoutMs || 20_000 }, request);
+    const latencyMs = Math.max(0, Date.now() - started);
+    const enforced = response.ok ? enforceLocalLlmJsonSchema(response.text, schema) : { ok: false, schema_valid: false, issues: [response.error] };
+    const smoke = {
+        ok: response.ok && enforced.ok,
+        ran_at: nowIso(),
+        prompt_hash: sha256(prompt),
+        latency_ms: latencyMs,
+        tokens_per_second: response.ok ? localLlmTokensPerSecond(response.data, response.text, latencyMs) : 0,
+        schema_valid: enforced.schema_valid === true,
+        result_path: reportPath,
+        status: response.ok && enforced.ok ? 'verified' : 'blocked',
+        blockers: [
+            ...(response.ok ? [] : ['local_llm_generate_failed', response.error]),
+            ...(enforced.ok ? [] : ['local_llm_smoke_schema_invalid', ...(enforced.issues || []).map(String)])
+        ]
+    };
+    await writeSmokeReport(reportPath, config, smoke, capability, response.ok ? response.data : null);
+    return smoke;
+}
+async function writeSmokeReport(reportPath, config, smoke, capability, rawResponse = null) {
+    await ensureDir(path.dirname(reportPath));
+    await writeJsonAtomic(reportPath, {
+        schema: LOCAL_LLM_SMOKE_SCHEMA,
+        generated_at: nowIso(),
+        provider: config.provider,
+        model: config.model,
+        endpoint: config.base_url,
+        smoke,
+        capability,
+        raw_response: rawResponse
+    });
+}
+function expandHome(value) {
+    return value.startsWith('~/') ? path.join(os.homedir(), value.slice(2)) : value;
+}
+//# sourceMappingURL=local-llm-smoke.js.map

package/dist/core/local-llm/local-llm-warmup.js

@@ -0,0 +1,20 @@
+import { nowIso } from '../fsx.js';
+export function buildLocalLlmWarmupState(config, input) {
+    const ttlMs = Math.max(1, Number(input.ttlMs || 10 * 60 * 1000));
+    const warmedAt = nowIso();
+    return {
+        schema: 'sks.local-llm-warmup-state.v1',
+        ok: input.ok,
+        provider: config.provider,
+        model: config.model,
+        endpoint: config.base_url,
+        warmed_at: warmedAt,
+        expires_at: new Date(Date.parse(warmedAt) + ttlMs).toISOString(),
+        explicit_only: true,
+        postinstall_allowed: false,
+        release_check_real_warmup_allowed: false,
+        release_real_check_requires_env: 'SKS_REQUIRE_LOCAL_LLM=1',
+        reason: input.reason || null
+    };
+}
+//# sourceMappingURL=local-llm-warmup.js.map

package/dist/core/local-llm/local-worker-eligibility.js

@@ -0,0 +1,27 @@
+export function evaluateLocalWorkerEligibility(input, config) {
+    const prompt = String(input.prompt || '');
+    const writePaths = Array.isArray(input.requestedScopeContract?.write_paths) ? input.requestedScopeContract.write_paths.map(String) : [];
+    const forbidden = /\b(strategy|planning|architecture|design|final review|verification authority|safety authority|integration|database|migration|permission approval)\b/i.test(prompt);
+    const allowed = /\b(worker|patch|read-only|grep|qa|test|docstring|summary|refactor)\b/i.test(`${input.route} ${prompt}`);
+    const blockers = [
+        ...(config.enabled ? [] : ['local_llm_disabled']),
+        ...(config.status === 'verified' ? [] : [`local_llm_${config.status}`]),
+        ...(input.tier === 'worker' ? [] : ['local_llm_worker_tier_only']),
+        ...(input.sandboxPolicy === 'full-access' ? ['local_llm_full_access_blocked'] : []),
+        ...(input.localLlmPolicy?.requiresGptFinal === false ? ['local_llm_requires_gpt_final_policy_missing'] : []),
+        ...(forbidden ? ['local_llm_forbidden_task_class'] : []),
+        ...(!allowed && !writePaths.length ? ['local_llm_task_not_eligible'] : [])
+    ];
+    return {
+        schema: 'sks.local-worker-eligibility.v1',
+        ok: blockers.length === 0,
+        task_classes: {
+            allowed_detected: allowed,
+            forbidden_detected: forbidden,
+            write_path_count: writePaths.length
+        },
+        requires_gpt_final: true,
+        blockers
+    };
+}
+//# sourceMappingURL=local-worker-eligibility.js.map

package/dist/core/naruto/hardware-capacity-probe.js

@@ -0,0 +1,36 @@
+import os from 'node:os';
+export function probeHardwareCapacity(input = {}) {
+    const memory = process.memoryUsage();
+    return {
+        schema: 'sks.naruto-hardware-capacity-probe.v1',
+        cpu_core_count: normalizePositiveInt(input.cores, os.cpus()?.length || 1),
+        current_load_average: input.loadAverage || os.loadavg(),
+        free_memory_bytes: normalizePositiveInt(input.freeMemoryBytes, os.freemem()),
+        total_memory_bytes: normalizePositiveInt(input.totalMemoryBytes, os.totalmem()),
+        node_heap_used_bytes: normalizePositiveInt(input.nodeHeapUsedBytes, memory.heapUsed),
+        node_heap_total_bytes: normalizePositiveInt(input.nodeHeapTotalBytes, memory.heapTotal),
+        process_count: normalizePositiveInt(input.processCount, 1),
+        file_descriptor_limit: normalizePositiveInt(input.fileDescriptorLimit, Number(process.env.SKS_NARUTO_FD_LIMIT) || 256),
+        zellij_pane_count: normalizeNonNegativeInt(input.zellijPaneCount, 0),
+        terminal_columns: normalizePositiveInt(input.terminalColumns, process.stdout.columns || 120),
+        terminal_rows: normalizePositiveInt(input.terminalRows, process.stdout.rows || 40),
+        local_llm_max_parallel_requests: normalizePositiveInt(input.localLlmMaxParallelRequests, Number(process.env.SKS_LOCAL_LLM_MAX_PARALLEL_REQUESTS) || 4),
+        remote_api_rate_limit_budget: normalizePositiveInt(input.remoteApiRateLimitBudget, Number(process.env.SKS_REMOTE_API_PARALLEL_BUDGET) || 12),
+        gpu_available: input.gpuAvailable === true,
+        gpu_vram_mb: normalizeNonNegativeInt(input.gpuVramMb, 0),
+        disk_io_pressure: Math.max(0, Math.min(1, Number(input.diskIoPressure ?? 0)))
+    };
+}
+function normalizePositiveInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return Math.max(1, Math.floor(fallback));
+    return Math.floor(parsed);
+}
+function normalizeNonNegativeInt(value, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return Math.max(0, Math.floor(fallback));
+    return Math.floor(parsed);
+}
+//# sourceMappingURL=hardware-capacity-probe.js.map

package/dist/core/naruto/naruto-active-pool.js

@@ -0,0 +1,134 @@
+import { createNarutoGeneration, completeNarutoGeneration } from './naruto-generation-scheduler.js';
+export function simulateNarutoActivePool(input) {
+    const safeActiveWorkers = Math.max(1, input.governor.safe_active_workers);
+    const retryLimit = Math.max(0, Math.floor(Number(input.retryLimit ?? 1)));
+    const failIds = new Set((input.failWorkItemIds || []).map(String));
+    const pending = [...input.graph.work_items];
+    const active = new Map();
+    const completed = new Set();
+    const failed = new Set();
+    const executed = new Map();
+    const byId = new Map(input.graph.work_items.map((item) => [item.id, item]));
+    const timeline = [];
+    let generationIndex = 1;
+    let tick = 0;
+    let refillEvents = 0;
+    let maxObserved = 0;
+    let maxObservedWriteLeaseConflicts = 0;
+    let conflictItemsEnqueued = 0;
+    while (pending.length || active.size) {
+        let launched = 0;
+        for (;;) {
+            if (active.size >= safeActiveWorkers)
+                break;
+            const next = popRunnable(pending, completed, active, byId);
+            if (!next)
+                break;
+            const generation = createNarutoGeneration(next, generationIndex, tick);
+            generationIndex += 1;
+            active.set(generation.generation_id, generation);
+            executed.set(next.id, (executed.get(next.id) || 0) + 1);
+            launched += 1;
+        }
+        if (launched)
+            refillEvents += launched;
+        maxObserved = Math.max(maxObserved, active.size);
+        maxObservedWriteLeaseConflicts = Math.max(maxObservedWriteLeaseConflicts, countActiveWriteLeaseConflicts(active, byId));
+        timeline.push({ tick, active: active.size, pending: pending.length, completed: completed.size, event: launched ? 'refill' : 'wait' });
+        const done = [...active.values()].slice(0, Math.max(1, Math.ceil(active.size / 2)));
+        if (!done.length && pending.length)
+            break;
+        for (const generation of done) {
+            active.delete(generation.generation_id);
+            const shouldFail = failIds.has(generation.work_item_id) && (executed.get(generation.work_item_id) || 0) <= retryLimit;
+            completeNarutoGeneration(generation, tick + 1, shouldFail);
+            if (shouldFail) {
+                failed.add(generation.work_item_id);
+                conflictItemsEnqueued += 1;
+                const followup = conflictResolutionFollowup(generation.work_item_id, input.graph.work_items.length + conflictItemsEnqueued);
+                pending.push(followup);
+                byId.set(followup.id, followup);
+            }
+            else {
+                completed.add(generation.work_item_id);
+            }
+        }
+        tick += 1;
+        if (tick > input.graph.work_items.length * 4 + 20)
+            break;
+    }
+    const duplicateExecutionCount = [...executed.values()].filter((count) => count > 1).length;
+    const blockers = [
+        ...(pending.length ? ['naruto_active_pool_pending_not_drained'] : []),
+        ...(active.size ? ['naruto_active_pool_active_not_drained'] : []),
+        ...(maxObserved > safeActiveWorkers ? ['naruto_active_pool_exceeded_safe_workers'] : []),
+        ...(maxObservedWriteLeaseConflicts > 0 ? ['naruto_active_pool_overlapping_write_leases'] : []),
+        ...(duplicateExecutionCount > conflictItemsEnqueued ? ['naruto_active_pool_duplicate_execution_without_retry'] : [])
+    ];
+    return {
+        schema: 'sks.naruto-active-pool.v1',
+        ok: blockers.length === 0,
+        safe_active_workers: safeActiveWorkers,
+        total_work_items: input.graph.total_work_items,
+        completed_count: completed.size,
+        failed_count: failed.size,
+        refill_events: refillEvents,
+        max_observed_active_workers: maxObserved,
+        duplicate_execution_count: duplicateExecutionCount,
+        conflict_items_enqueued: conflictItemsEnqueued,
+        max_observed_write_lease_conflicts: maxObservedWriteLeaseConflicts,
+        timeline,
+        blockers
+    };
+}
+function popRunnable(pending, completed, active, byId) {
+    const activeWorkIds = new Set([...active.values()].map((item) => item.work_item_id));
+    for (let index = 0; index < pending.length; index += 1) {
+        const item = pending[index];
+        if (!item)
+            continue;
+        if (activeWorkIds.has(item.id))
+            continue;
+        if (!item.dependencies.every((dep) => completed.has(dep)))
+            continue;
+        const writeConflict = [...active.values()].some((generation) => {
+            const activeItem = byId.get(generation.work_item_id);
+            return activeItem?.write_paths.some((file) => item.write_paths.includes(file));
+        });
+        if (writeConflict)
+            continue;
+        pending.splice(index, 1);
+        return item;
+    }
+    return null;
+}
+function countActiveWriteLeaseConflicts(active, byId) {
+    const counts = new Map();
+    for (const generation of active.values()) {
+        const item = byId.get(generation.work_item_id);
+        for (const file of item?.write_paths || [])
+            counts.set(file, (counts.get(file) || 0) + 1);
+    }
+    return [...counts.values()].filter((count) => count > 1).reduce((sum, count) => sum + count - 1, 0);
+}
+function conflictResolutionFollowup(failedId, index) {
+    const id = `NW-CONFLICT-${String(index).padStart(4, '0')}`;
+    return {
+        id,
+        kind: 'conflict_resolution',
+        title: `Resolve failed work item ${failedId}`,
+        target_paths: [],
+        readonly_paths: [],
+        write_paths: [`.sneakoscope/naruto/conflicts/${id}.json`],
+        required_role: 'conflict_resolver',
+        write_allowed: true,
+        verification_required: true,
+        dependencies: [],
+        can_run_in_parallel_with: [],
+        conflicts_with: [],
+        estimated_cost: { tokens: 4000, latency_ms: 45000, cpu_weight: 1, memory_mb: 256, gpu_weight: 0 },
+        lease_requirements: [{ path: `.sneakoscope/naruto/conflicts/${id}.json`, kind: 'write' }],
+        acceptance: { requires_patch_envelope: true, requires_verification: true, requires_gpt_final: true }
+    };
+}
+//# sourceMappingURL=naruto-active-pool.js.map