sneakoscope 2.0.7 → 2.0.9

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

@@ -1,4 +1,96 @@
 import { createNarutoGeneration, completeNarutoGeneration } from './naruto-generation-scheduler.js';
+export async function runNarutoRealActivePool(input) {
+    const safeActiveWorkers = Math.max(1, input.governor.safe_active_workers);
+    const visibleCap = Math.max(0, input.governor.safe_zellij_visible_panes);
+    const pending = [...input.graph.work_items];
+    const active = new Map();
+    const completed = new Map();
+    const byId = new Map(input.graph.work_items.map((item) => [item.id, item]));
+    const timeline = [];
+    const lifecycle = [];
+    const refillLatencies = [];
+    let tick = 0;
+    let refillEvents = 0;
+    let maxObserved = 0;
+    let visibleRunning = 0;
+    while (pending.length || active.size) {
+        const beforeLaunch = Date.now();
+        let launched = 0;
+        for (;;) {
+            if (active.size >= safeActiveWorkers)
+                break;
+            const item = popRunnable(pending, new Set(completed.keys()), activeToGenerationMap(active), byId);
+            if (!item)
+                break;
+            const placement = visibleRunning < visibleCap
+                ? { placement: 'zellij-pane', visible_index: visibleRunning + 1, reason: 'within_visible_cap' }
+                : { placement: 'headless', visible_index: null, reason: `visible_pane_cap:${visibleCap}` };
+            if (placement.placement === 'zellij-pane')
+                visibleRunning += 1;
+            const handle = await input.spawnWorker(item, placement);
+            active.set(handle.id, handle);
+            lifecycle.push({ work_item_id: item.id, placement: placement.placement, started_at: handle.started_at, completed_at: null, ok: null });
+            launched += 1;
+            await input.updateDashboard({ event_type: 'worker_spawned', work_item_id: item.id, active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size, placement });
+        }
+        if (launched) {
+            refillEvents += launched;
+            refillLatencies.push(Date.now() - beforeLaunch);
+            await input.updateDashboard({ event_type: 'refill', active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size });
+        }
+        maxObserved = Math.max(maxObserved, active.size);
+        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)
+            break;
+        for (const handle of done) {
+            active.delete(handle.id);
+            if (handle.placement.placement === 'zellij-pane')
+                visibleRunning = Math.max(0, visibleRunning - 1);
+            const result = await input.collectWorker(handle);
+            completed.set(result.item.id, result);
+            const row = lifecycle.find((entry) => entry.work_item_id === result.item.id && entry.completed_at == null);
+            if (row) {
+                row.completed_at = result.completed_at;
+                row.ok = result.ok;
+            }
+            await input.updateDashboard({ event_type: 'worker_completed', work_item_id: result.item.id, active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size, placement: result.placement });
+            if (result.item.verification_required) {
+                await input.enqueueVerification(result);
+                await input.updateDashboard({ event_type: 'verification_enqueued', work_item_id: result.item.id, active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size, placement: result.placement });
+            }
+        }
+        tick += 1;
+        if (tick > input.graph.work_items.length * 4 + 20)
+            break;
+    }
+    await input.updateDashboard({ event_type: 'pool_drained', active_workers: active.size, pending_workers: pending.length, completed_workers: completed.size });
+    const failedCount = [...completed.values()].filter((result) => !result.ok).length;
+    const blockers = [
+        ...(pending.length ? ['naruto_real_active_pool_pending_not_drained'] : []),
+        ...(active.size ? ['naruto_real_active_pool_active_not_drained'] : []),
+        ...(maxObserved > safeActiveWorkers ? ['naruto_real_active_pool_exceeded_safe_workers'] : []),
+        ...[...completed.values()].flatMap((result) => result.blockers || [])
+    ];
+    return {
+        schema: 'sks.naruto-active-pool.v1',
+        ok: blockers.length === 0,
+        runtime_mode: 'real-worker-lifecycle',
+        safe_active_workers: safeActiveWorkers,
+        total_work_items: input.graph.total_work_items,
+        completed_count: completed.size,
+        failed_count: failedCount,
+        refill_events: refillEvents,
+        max_observed_active_workers: maxObserved,
+        duplicate_execution_count: 0,
+        conflict_items_enqueued: 0,
+        max_observed_write_lease_conflicts: 0,
+        refill_latency_ms_p95: percentile(refillLatencies, 0.95),
+        worker_lifecycle: lifecycle,
+        timeline,
+        blockers
+    };
+}
 export async function runNarutoActivePool(input) {
     const base = simulateNarutoActivePool(input);
     const allocations = [];
@@ -34,6 +126,22 @@ export async function runNarutoActivePool(input) {
         blockers: [...base.blockers, ...allocationBlockers]
     };
 }
+function activeToGenerationMap(active) {
+    const out = new Map();
+    let index = 1;
+    for (const handle of active.values()) {
+        out.set(handle.id, createNarutoGeneration(handle.item, index, 0));
+        index += 1;
+    }
+    return out;
+}
+function percentile(values, quantile) {
+    if (!values.length)
+        return 0;
+    const sorted = [...values].sort((a, b) => a - b);
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * quantile) - 1));
+    return sorted[index] || 0;
+}
 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)));

package/dist/core/naruto/naruto-concurrency-governor.js

@@ -17,11 +17,20 @@ export function decideNarutoConcurrency(input = {}) {
     const gbPerWorker = heavy ? Number(process.env.SKS_NARUTO_GB_PER_WORKER || 0.25) : Number(process.env.SKS_NARUTO_LIGHT_GB_PER_WORKER || 0.1);
     const memoryCap = Math.max(1, Math.floor(memoryBudgetGb / Math.max(0.05, gbPerWorker)));
     const fdCap = Math.max(1, Math.floor((hardware.file_descriptor_limit - hardware.process_count) / 6));
+    const cpuCap = Math.max(1, hardware.cpu_core_count * (heavy ? 2 : 4));
+    const ioCap = Math.max(2, Math.floor(hardware.cpu_core_count / 2));
+    const processCap = Math.max(1, Number(process.env.SKS_NARUTO_HEADLESS_PROCESS_CAP || cpuCap + ioCap));
+    const gitWorktreeCap = Math.max(1, Number(process.env.SKS_NARUTO_GIT_WORKTREE_CAP || Math.min(requestedClones, processCap)));
     const localLlmParallel = Math.max(1, Math.min(4, hardware.local_llm_max_parallel_requests));
     const remoteCodexParallel = Math.max(1, Math.min(hardware.remote_api_rate_limit_budget, requestedClones));
+    const backendBudget = backend === 'ollama' || backend === 'local-llm'
+        ? localLlmParallel
+        : backend === 'codex-sdk' || backend === 'zellij'
+            ? Math.max(remoteCodexParallel, Math.min(requestedClones, processCap))
+            : processCap;
     const queueCap = Math.max(1, Math.min(requestedClones, pending || totalWorkItems));
     const leaseCap = Math.max(1, requestedClones - leaseConflicts);
-    const rawSafe = Math.max(1, Math.min(requestedClones, totalWorkItems, memoryCap, fdCap, remoteCodexParallel, queueCap, leaseCap, 100));
+    const rawSafe = Math.max(1, Math.min(requestedClones, totalWorkItems, memoryCap, fdCap, cpuCap + ioCap, gitWorktreeCap + processCap, backendBudget, queueCap, leaseCap, 100));
     const pressure = monitorNarutoResourcePressure(hardware, { activeWorkers: rawSafe, zellijVisiblePaneCap });
     const backpressure = applyNarutoBackpressure(rawSafe, pressure);
     const safeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
@@ -29,6 +38,9 @@ export function decideNarutoConcurrency(input = {}) {
     const reasons = [
         ...(memoryCap < requestedClones ? ['memory_cap'] : []),
         ...(fdCap < requestedClones ? ['file_descriptor_budget'] : []),
+        ...(cpuCap + ioCap < requestedClones ? ['cpu_io_budget'] : []),
+        ...(gitWorktreeCap + processCap < requestedClones ? ['git_worktree_process_budget'] : []),
+        ...(backendBudget < requestedClones ? ['backend_parallel_budget'] : []),
         ...(remoteCodexParallel < requestedClones ? ['remote_api_rate_limit_budget'] : []),
         ...(localLlmParallel <= 4 ? ['local_llm_max_parallel_requests'] : []),
         ...(safeVisible < safeActiveWorkers ? ['zellij_ui_pane_budget'] : []),
@@ -44,6 +56,9 @@ export function decideNarutoConcurrency(input = {}) {
         headless_workers: Math.max(0, safeActiveWorkers - safeVisible),
         local_llm_parallel: localLlmParallel,
         remote_codex_parallel: remoteCodexParallel,
+        process_parallel: processCap,
+        git_worktree_parallel: gitWorktreeCap,
+        cpu_io_parallel: cpuCap + ioCap,
         verification_parallel: Math.max(1, Math.min(hardware.cpu_core_count * 2, safeActiveWorkers, 16)),
         reasons: [...new Set(reasons)],
         backpressure: backpressure.backpressure,

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

@@ -28,7 +28,8 @@ export function buildNarutoWorkGraph(input = {}) {
     const requestedClones = normalizePositiveInt(input.requestedClones, 12);
     const readonly = input.readonly === true;
     const writeCapable = input.writeCapable !== false && !readonly;
-    const totalWorkItems = Math.max(requestedClones, normalizePositiveInt(input.totalWorkItems, requestedClones));
+    const minimumFanout = writeCapable ? requestedClones * 2 : requestedClones;
+    const totalWorkItems = Math.max(minimumFanout, normalizePositiveInt(input.totalWorkItems, minimumFanout));
     const kindCycle = writeCapable ? WRITE_CAPABLE_KIND_CYCLE : READONLY_KIND_CYCLE;
     const basePath = normalizeNarutoPath(input.leaseBasePath || '.sneakoscope/naruto/patch-envelopes');
     const targetPaths = normalizePaths(input.targetPaths || []);

package/dist/core/release/release-gate-cache-v2.js

@@ -0,0 +1,117 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+export const RELEASE_GATE_CACHE_V2_SCHEMA = 'sks.release-gate-cache.v2';
+export function releaseGateCacheFile(root) {
+    return path.join(root, '.sneakoscope', 'reports', 'release-gates', 'cache-v2.json');
+}
+export function releaseGateCacheKey(root, gate) {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    const hash = crypto.createHash('sha256');
+    hash.update(gate.id);
+    hash.update(gate.command);
+    hash.update(String(pkg.version || ''));
+    hash.update(process.version);
+    hash.update(String(process.env.npm_config_user_agent || ''));
+    hash.update(JSON.stringify(gate.resource || []));
+    hash.update(JSON.stringify(gate.preset || []));
+    hashFileIfPresent(hash, path.join(root, 'release-gates.v2.json'));
+    hashFileIfPresent(hash, path.join(root, 'package.json'));
+    hashFileIfPresent(hash, path.join(root, 'dist', 'build-manifest.json'));
+    for (const input of gate.cache.inputs) {
+        const expanded = expandGlob(root, input);
+        hash.update(`input:${input}`);
+        if (!expanded.length) {
+            hash.update(`missing_or_empty:${input}`);
+            continue;
+        }
+        for (const file of expanded) {
+            hash.update(path.relative(root, file));
+            hashFileIfPresent(hash, file);
+        }
+    }
+    return hash.digest('hex');
+}
+export function expandGlob(root, input) {
+    const absolute = path.join(root, input);
+    if (!/[*!?[\]{}]/.test(input)) {
+        if (!fs.existsSync(absolute))
+            return [];
+        const stat = fs.statSync(absolute);
+        if (stat.isDirectory())
+            return hashDirectoryRecursive(absolute);
+        return stat.isFile() ? [absolute] : [];
+    }
+    if (input.endsWith('/**')) {
+        const dir = path.join(root, input.slice(0, -3));
+        return fs.existsSync(dir) && fs.statSync(dir).isDirectory() ? hashDirectoryRecursive(dir) : [];
+    }
+    const firstWildcard = input.search(/[*!?[\]{}]/);
+    const prefix = input.slice(0, firstWildcard);
+    const base = path.join(root, prefix.includes('/') ? prefix.slice(0, prefix.lastIndexOf('/')) : '');
+    if (!fs.existsSync(base))
+        return [];
+    const re = globToRegExp(input);
+    return hashDirectoryRecursive(base).filter((file) => re.test(path.relative(root, file)));
+}
+export function hashDirectoryRecursive(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    const out = [];
+    const stack = [dir];
+    while (stack.length) {
+        const current = stack.pop();
+        for (const name of fs.readdirSync(current).sort()) {
+            const file = path.join(current, name);
+            const stat = fs.statSync(file);
+            if (stat.isDirectory())
+                stack.push(file);
+            else if (stat.isFile())
+                out.push(file);
+        }
+    }
+    return out.sort();
+}
+export function readReleaseGateCacheHit(root, gate) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(releaseGateCacheFile(root), 'utf8'));
+        return parsed.schema === RELEASE_GATE_CACHE_V2_SCHEMA && parsed.records?.[releaseGateCacheKey(root, gate)]?.ok === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function writeReleaseGateCacheHit(root, gate) {
+    const file = releaseGateCacheFile(root);
+    let parsed = { schema: RELEASE_GATE_CACHE_V2_SCHEMA, records: {} };
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch { }
+    parsed.schema = RELEASE_GATE_CACHE_V2_SCHEMA;
+    parsed.records ||= {};
+    parsed.records[releaseGateCacheKey(root, gate)] = {
+        ok: true,
+        gate_id: gate.id,
+        command: gate.command,
+        resource: gate.resource,
+        preset: gate.preset,
+        recorded_at: new Date().toISOString()
+    };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(parsed, null, 2)}\n`);
+}
+function hashFileIfPresent(hash, file) {
+    if (fs.existsSync(file) && fs.statSync(file).isFile())
+        hash.update(fs.readFileSync(file));
+}
+function globToRegExp(input) {
+    const escaped = input
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '\u0000')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '[^/]')
+        .replace(/\u0000/g, '.*');
+    return new RegExp(`^${escaped}$`);
+}
+//# sourceMappingURL=release-gate-cache-v2.js.map

package/dist/core/release/release-gate-dag.js

@@ -0,0 +1,190 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { createReleaseGateHermeticEnv } from './release-gate-hermetic-env.js';
+import { appendReleaseGateJsonl, writeReleaseGateJson } from './release-gate-report.js';
+import { findReadyReleaseGateNodes, findReleaseGatesBlockedByFailedDeps, pickReadyLaunchableReleaseGates } from './release-gate-scheduler.js';
+import { readReleaseGateCacheHit, writeReleaseGateCacheHit } from './release-gate-cache-v2.js';
+import { RELEASE_GATE_NODE_SCHEMA, validateReleaseGateManifest } from './release-gate-node.js';
+import { countReleaseGateResources, defaultReleaseGateBudget, summarizeReleaseGateBudget } from './release-gate-resource-governor.js';
+export function loadReleaseGateManifest(root, file = 'release-gates.v2.json') {
+    const manifestPath = path.join(root, file);
+    const parsed = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const validation = validateReleaseGateManifest(parsed);
+    if (!validation.ok || !validation.manifest) {
+        throw new Error(`invalid ${file}: ${validation.errors.join(', ')}`);
+    }
+    return validation.manifest;
+}
+export async function runReleaseGateDag(input) {
+    const root = path.resolve(input.root);
+    const preset = input.preset || 'release';
+    const manifest = loadReleaseGateManifest(root);
+    const selected = selectPreset(manifest, preset);
+    const runId = `rg-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
+    const reportDir = path.join(root, '.sneakoscope', 'reports', 'release-gates', runId);
+    fs.mkdirSync(reportDir, { recursive: true });
+    const timeline = path.join(reportDir, 'timeline.jsonl');
+    const started = Date.now();
+    const pending = new Map(selected.map((gate) => [gate.id, gate]));
+    const running = new Map();
+    const completed = new Map();
+    const failed = new Map();
+    const budget = defaultReleaseGateBudget();
+    const peakResources = {};
+    let cached = 0;
+    let sumGateMs = 0;
+    let peakRunning = 0;
+    const writeSummarySnapshot = (finished = false) => {
+        const wallMs = Date.now() - started;
+        const failures = [...failed.values()].map((row) => ({ id: row.id, exit_code: row.exit_code, stderr_tail: row.stderr_tail }));
+        const snapshot = {
+            schema: 'sks.release-gate-dag-run.v1',
+            ok: failures.length === 0,
+            run_id: runId,
+            selected_preset: preset,
+            total_gates: manifest.gates.length,
+            selected_gates: selected.length,
+            completed: completed.size,
+            failed: failed.size,
+            cached,
+            wall_ms: wallMs,
+            sum_gate_ms: sumGateMs,
+            cpu_time_saved_ms: Math.max(0, sumGateMs - wallMs),
+            parallelism_gain: wallMs > 0 ? Number((sumGateMs / wallMs).toFixed(2)) : 1,
+            critical_path_ms: estimateCriticalPath(selected, completed),
+            peak_running: peakRunning,
+            peak_resources: peakResources,
+            budget_snapshot: budget,
+            budget_summary: summarizeReleaseGateBudget(budget),
+            report_dir: reportDir,
+            failures
+        };
+        if (!finished) {
+            snapshot.in_progress = true;
+            snapshot.pending = pending.size;
+            snapshot.running = running.size;
+        }
+        writeReleaseGateJson(path.join(reportDir, 'summary.json'), snapshot);
+        return snapshot;
+    };
+    if (input.explain) {
+        writeReleaseGateJson(path.join(reportDir, 'explain.json'), { schema: RELEASE_GATE_NODE_SCHEMA, preset, budget, gates: selected.map((gate) => ({ id: gate.id, deps: gate.deps, resource: gate.resource, command: gate.command })) });
+    }
+    while (pending.size || running.size) {
+        const ready = findReadyReleaseGateNodes({ pending, completed, failed });
+        const launchable = pickReadyLaunchableReleaseGates({ ready, running: [...running.values()].map((row) => row.gate) });
+        let progressed = false;
+        for (const gate of launchable) {
+            pending.delete(gate.id);
+            const cacheHit = !input.noCache && gate.cache.enabled && readReleaseGateCacheHit(root, gate);
+            if (cacheHit) {
+                const result = { id: gate.id, ok: true, exit_code: 0, duration_ms: 0, cached: true, stderr_tail: '' };
+                completed.set(gate.id, result);
+                cached += 1;
+                progressed = true;
+                appendReleaseGateJsonl(timeline, { event: 'cache_hit', gate_id: gate.id, at: new Date().toISOString() });
+                writeSummarySnapshot(false);
+                continue;
+            }
+            appendReleaseGateJsonl(timeline, { event: 'start', gate_id: gate.id, resource: gate.resource, at: new Date().toISOString() });
+            running.set(gate.id, { gate, promise: runGate(root, runId, reportDir, gate) });
+            peakRunning = Math.max(peakRunning, running.size);
+            const used = countReleaseGateResources([...running.values()].map((row) => row.gate));
+            for (const [resource, count] of Object.entries(used)) {
+                peakResources[resource] = Math.max(peakResources[resource] || 0, Number(count) || 0);
+            }
+            progressed = true;
+        }
+        if (!running.size) {
+            const blockedByFailedDeps = findReleaseGatesBlockedByFailedDeps({ pending, failed });
+            if (blockedByFailedDeps.length) {
+                for (const gate of blockedByFailedDeps) {
+                    pending.delete(gate.id);
+                    const result = {
+                        id: gate.id,
+                        ok: false,
+                        exit_code: null,
+                        duration_ms: 0,
+                        cached: false,
+                        stderr_tail: `blocked by failed dependency: ${gate.deps.filter((dep) => failed.has(dep)).join(', ')}`
+                    };
+                    failed.set(gate.id, result);
+                    appendReleaseGateJsonl(timeline, { event: 'blocked_by_failed_dependency', gate_id: gate.id, deps: gate.deps.filter((dep) => failed.has(dep)), at: new Date().toISOString() });
+                }
+                continue;
+            }
+            if (progressed)
+                continue;
+            const blocked = [...pending.keys()];
+            throw new Error(`release gate DAG stalled: ${blocked.join(', ')}`);
+        }
+        const result = await Promise.race([...running.values()].map((row) => row.promise));
+        running.delete(result.id);
+        sumGateMs += result.duration_ms;
+        if (result.ok) {
+            completed.set(result.id, result);
+            const gate = selected.find((row) => row.id === result.id);
+            if (gate?.cache.enabled && !input.noCache)
+                writeReleaseGateCacheHit(root, gate);
+        }
+        else {
+            failed.set(result.id, result);
+            if (input.failFast) {
+                for (const id of [...pending.keys()])
+                    pending.delete(id);
+            }
+        }
+        appendReleaseGateJsonl(timeline, { event: result.ok ? 'pass' : 'fail', gate_id: result.id, duration_ms: result.duration_ms, at: new Date().toISOString() });
+        writeSummarySnapshot(false);
+    }
+    const result = writeSummarySnapshot(true);
+    return result;
+}
+function selectPreset(manifest, preset) {
+    return manifest.gates.filter((gate) => gate.preset.includes(preset));
+}
+function runGate(root, runId, reportRoot, gate) {
+    const started = Date.now();
+    const hermetic = createReleaseGateHermeticEnv({ root, runId, gate, reportRoot });
+    const stdoutFile = path.join(hermetic.report_dir, 'stdout.log');
+    const stderrFile = path.join(hermetic.report_dir, 'stderr.log');
+    const out = fs.createWriteStream(stdoutFile);
+    const err = fs.createWriteStream(stderrFile);
+    return new Promise((resolve) => {
+        const child = spawn(gate.command, { cwd: root, shell: true, env: hermetic.env, stdio: ['ignore', 'pipe', 'pipe'] });
+        const timer = setTimeout(() => child.kill('SIGTERM'), gate.timeout_ms);
+        child.stdout.pipe(out);
+        child.stderr.pipe(err);
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            out.end();
+            err.end();
+            const durationMs = Date.now() - started;
+            const stderrTail = tail(fs.existsSync(stderrFile) ? fs.readFileSync(stderrFile, 'utf8') : '');
+            const result = { id: gate.id, ok: code === 0, exit_code: code, duration_ms: durationMs, cached: false, stderr_tail: stderrTail };
+            writeReleaseGateJson(path.join(hermetic.report_dir, 'result.json'), { schema: 'sks.release-gate-result.v1', ...result, stdout_log: stdoutFile, stderr_log: stderrFile });
+            resolve(result);
+        });
+    });
+}
+function estimateCriticalPath(gates, completed) {
+    const byId = new Map(gates.map((gate) => [gate.id, gate]));
+    const memo = new Map();
+    const visit = (id) => {
+        if (memo.has(id))
+            return memo.get(id);
+        const gate = byId.get(id);
+        if (!gate)
+            return 0;
+        const own = completed.get(id)?.duration_ms || 0;
+        const dep = Math.max(0, ...gate.deps.map(visit));
+        memo.set(id, own + dep);
+        return own + dep;
+    };
+    return Math.max(0, ...gates.map((gate) => visit(gate.id)));
+}
+function tail(value, limit = 1200) {
+    return value.length > limit ? value.slice(-limit) : value;
+}
+//# sourceMappingURL=release-gate-dag.js.map

package/dist/core/release/release-gate-hermetic-env.js

@@ -0,0 +1,32 @@
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+export function createReleaseGateHermeticEnv(input) {
+    const safeId = input.gate.id.replace(/[^a-zA-Z0-9._-]+/g, '-');
+    const tmpRoot = path.join(os.tmpdir(), 'sks-gate', input.runId, safeId);
+    const home = path.join(tmpRoot, 'home');
+    const codexHome = path.join(tmpRoot, 'codex-home');
+    const cacheHome = path.join(tmpRoot, 'xdg-cache');
+    const reportDir = path.join(input.reportRoot, safeId);
+    fs.mkdirSync(home, { recursive: true });
+    fs.mkdirSync(codexHome, { recursive: true });
+    fs.mkdirSync(cacheHome, { recursive: true });
+    fs.mkdirSync(reportDir, { recursive: true });
+    return {
+        tmp_dir: tmpRoot,
+        report_dir: reportDir,
+        env: {
+            ...process.env,
+            SKS_GATE_ID: input.gate.id,
+            SKS_GATE_RUN_ID: input.runId,
+            SKS_REPORT_DIR: reportDir,
+            SKS_TMP_DIR: tmpRoot,
+            HOME: input.gate.isolation.home === 'temp' ? home : process.env.HOME,
+            CODEX_HOME: input.gate.isolation.codex_home === 'temp' ? codexHome : process.env.CODEX_HOME,
+            XDG_CACHE_HOME: cacheHome,
+            SKS_DISABLE_REAL_MODEL_CALLS: input.gate.preset.includes('real-check') ? process.env.SKS_DISABLE_REAL_MODEL_CALLS || '0' : '1',
+            SKS_DISABLE_GLOBAL_CONFIG_MUTATION: '1'
+        }
+    };
+}
+//# sourceMappingURL=release-gate-hermetic-env.js.map

package/dist/core/release/release-gate-node.js

@@ -0,0 +1,62 @@
+export const RELEASE_GATE_NODE_SCHEMA = 'sks.release-gates.v2';
+export const RELEASE_GATE_RESOURCE_CLASSES = [
+    'cpu-light',
+    'cpu-heavy',
+    'io-light',
+    'io-heavy',
+    'git',
+    'git-worktree',
+    'zellij-real',
+    'local-llm-real',
+    'remote-model-real',
+    'python',
+    'network',
+    'global-config',
+    'publish',
+    'fs-read'
+];
+export function validateReleaseGateManifest(input) {
+    const errors = [];
+    if (input?.schema !== RELEASE_GATE_NODE_SCHEMA)
+        errors.push('schema_mismatch');
+    if (!Array.isArray(input?.gates))
+        errors.push('gates_missing');
+    const ids = new Set();
+    const resources = new Set(RELEASE_GATE_RESOURCE_CLASSES);
+    for (const gate of Array.isArray(input?.gates) ? input.gates : []) {
+        if (!gate?.id)
+            errors.push('gate_id_missing');
+        if (gate?.id && ids.has(gate.id))
+            errors.push(`gate_duplicate:${gate.id}`);
+        if (gate?.id)
+            ids.add(gate.id);
+        if (!gate?.command)
+            errors.push(`gate_command_missing:${gate?.id || 'unknown'}`);
+        if (!Array.isArray(gate?.deps))
+            errors.push(`gate_deps_missing:${gate?.id || 'unknown'}`);
+        if (!Array.isArray(gate?.resource) || !gate.resource.length)
+            errors.push(`gate_resource_missing:${gate?.id || 'unknown'}`);
+        for (const resource of Array.isArray(gate?.resource) ? gate.resource : []) {
+            if (!resources.has(resource))
+                errors.push(`gate_unknown_resource:${gate?.id || 'unknown'}:${resource}`);
+        }
+        if (gate?.side_effect !== 'hermetic' && gate?.side_effect !== 'real-env')
+            errors.push(`gate_side_effect_invalid:${gate?.id || 'unknown'}`);
+        if (!Number.isFinite(Number(gate?.timeout_ms)) || Number(gate.timeout_ms) <= 0)
+            errors.push(`gate_timeout_missing:${gate?.id || 'unknown'}`);
+        if (!gate?.cache || typeof gate.cache.enabled !== 'boolean' || !Array.isArray(gate.cache.inputs))
+            errors.push(`gate_cache_missing:${gate?.id || 'unknown'}`);
+        if (!gate?.isolation || gate.isolation.report_dir !== 'per-gate')
+            errors.push(`gate_isolation_missing:${gate?.id || 'unknown'}`);
+        if (!Array.isArray(gate?.preset))
+            errors.push(`gate_preset_missing:${gate?.id || 'unknown'}`);
+    }
+    for (const gate of Array.isArray(input?.gates) ? input.gates : []) {
+        for (const dep of Array.isArray(gate?.deps) ? gate.deps : []) {
+            if (!ids.has(dep))
+                errors.push(`gate_unknown_dep:${gate.id}:${dep}`);
+        }
+    }
+    return errors.length ? { ok: false, errors } : { ok: true, manifest: input, errors };
+}
+//# sourceMappingURL=release-gate-node.js.map

package/dist/core/release/release-gate-report.js

@@ -0,0 +1,11 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function writeReleaseGateJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+export function appendReleaseGateJsonl(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${JSON.stringify(value)}\n`);
+}
+//# sourceMappingURL=release-gate-report.js.map

package/dist/core/release/release-gate-resource-governor.js

@@ -0,0 +1,54 @@
+import os from 'node:os';
+export function defaultReleaseGateBudget() {
+    const cores = Math.max(1, os.cpus().length || 1);
+    return {
+        'cpu-light': Math.min(32, cores * 4),
+        'cpu-heavy': Math.max(1, cores - 1),
+        'io-light': Math.min(64, cores * 8),
+        'io-heavy': Math.min(8, cores),
+        git: Math.min(8, cores),
+        'git-worktree': Math.min(6, cores),
+        python: Math.min(8, cores),
+        network: 8,
+        'zellij-real': 1,
+        'local-llm-real': Math.max(1, Number(process.env.SKS_LOCAL_LLM_MAX_PARALLEL || 1)),
+        'remote-model-real': 4,
+        'global-config': 1,
+        publish: 1,
+        'fs-read': Math.min(64, cores * 8)
+    };
+}
+export function summarizeReleaseGateBudget(budget = defaultReleaseGateBudget()) {
+    return Object.entries(budget)
+        .filter(([, value]) => Number(value) > 0)
+        .map(([resource, value]) => `${resource}=${value}`)
+        .join(' ');
+}
+export function countReleaseGateResources(running) {
+    return usedResources(running);
+}
+export function pickLaunchableReleaseGates(input) {
+    const budget = input.budget || defaultReleaseGateBudget();
+    const used = usedResources(input.running);
+    const launchable = [];
+    for (const gate of input.ready) {
+        if (fits(gate, used, budget)) {
+            launchable.push(gate);
+            for (const resource of gate.resource)
+                used[resource] = (used[resource] || 0) + 1;
+        }
+    }
+    return launchable;
+}
+function usedResources(running) {
+    const used = {};
+    for (const gate of running) {
+        for (const resource of gate.resource)
+            used[resource] = (used[resource] || 0) + 1;
+    }
+    return used;
+}
+function fits(gate, used, budget) {
+    return gate.resource.every((resource) => (used[resource] || 0) < budget[resource]);
+}
+//# sourceMappingURL=release-gate-resource-governor.js.map

package/dist/core/release/release-gate-scheduler.js

@@ -0,0 +1,15 @@
+import { defaultReleaseGateBudget, pickLaunchableReleaseGates } from './release-gate-resource-governor.js';
+export function findReadyReleaseGateNodes(input) {
+    return [...input.pending.values()].filter((gate) => gate.deps.every((dep) => input.completed.has(dep)) && !gate.deps.some((dep) => input.failed.has(dep)));
+}
+export function findReleaseGatesBlockedByFailedDeps(input) {
+    return [...input.pending.values()].filter((gate) => gate.deps.some((dep) => input.failed.has(dep)));
+}
+export function pickReadyLaunchableReleaseGates(input) {
+    return pickLaunchableReleaseGates({
+        ready: input.ready,
+        running: input.running,
+        budget: defaultReleaseGateBudget()
+    });
+}
+//# sourceMappingURL=release-gate-scheduler.js.map

package/dist/core/version.js

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