sneakoscope 3.1.14 → 4.0.1

package/dist/core/commands/task-command.js

@@ -0,0 +1,15 @@
+import { checkCommand } from './check-command.js';
+export async function taskCommand(args = []) {
+    const sub = args[0] && !args[0].startsWith('-') ? args[0] : 'run';
+    const rest = sub === args[0] ? args.slice(1) : args;
+    if (sub === 'run')
+        return checkCommand(['--tier', 'confidence', ...rest]);
+    if (sub === 'affected')
+        return checkCommand(['--tier', 'affected', ...rest]);
+    if (sub === 'instant')
+        return checkCommand(['--tier', 'instant', ...rest]);
+    console.error('Usage: sks task run|affected|instant [--sla 5m] [--json]');
+    process.exitCode = 1;
+    return null;
+}
+//# sourceMappingURL=task-command.js.map

package/dist/core/commands/triwiki-command.js

@@ -0,0 +1,38 @@
+import { flag } from '../../cli/args.js';
+import { printJson } from '../../cli/output.js';
+import { projectRoot } from '../fsx.js';
+import { computeTriWikiAffectedGraph } from '../triwiki/triwiki-affected-graph.js';
+import { buildTriWikiGateImpactMap } from '../triwiki/triwiki-gate-impact-map.js';
+import { DEFAULT_TRIWIKI_MODULE_CARDS } from '../triwiki/triwiki-module-card.js';
+import { summarizeTriWikiProofBank } from '../triwiki/triwiki-proof-bank.js';
+export async function triwikiCommand(args = []) {
+    const root = await projectRoot();
+    const sub = args[0] && !args[0].startsWith('-') ? args[0] : 'index';
+    const json = flag(args, '--json');
+    let result;
+    if (sub === 'index') {
+        result = {
+            schema: 'sks.triwiki-index.v1',
+            ok: true,
+            modules: DEFAULT_TRIWIKI_MODULE_CARDS,
+            impact_map: buildTriWikiGateImpactMap(root),
+            proof_bank: summarizeTriWikiProofBank(root)
+        };
+    }
+    else if (sub === 'affected') {
+        result = computeTriWikiAffectedGraph({ root, tier: 'affected' });
+    }
+    else if (sub === 'proof-bank') {
+        result = summarizeTriWikiProofBank(root);
+    }
+    else {
+        console.error('Usage: sks triwiki index|affected|proof-bank [--json]');
+        process.exitCode = 1;
+        return null;
+    }
+    if (json)
+        return printJson(result);
+    console.log(JSON.stringify(result, null, 2));
+    return result;
+}
+//# sourceMappingURL=triwiki-command.js.map

package/dist/core/daemon/sksd-client.js

@@ -0,0 +1,9 @@
+import { sksdStatus, sksdStop, sksdWarm } from './sksd.js';
+export function runSksdClient(root, action) {
+    if (action === 'warm')
+        return sksdWarm(root);
+    if (action === 'stop')
+        return sksdStop(root);
+    return sksdStatus(root);
+}
+//# sourceMappingURL=sksd-client.js.map

package/dist/core/daemon/sksd-ipc.js

@@ -0,0 +1,9 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function writeSksdIpcMessage(root, action) {
+    const file = path.join(root, '.sneakoscope', 'cache', 'sksd', 'last-message.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify({ schema: 'sks.sksd-ipc-message.v1', action, created_at: new Date().toISOString(), pid: process.pid }, null, 2)}\n`);
+    return file;
+}
+//# sourceMappingURL=sksd-ipc.js.map

package/dist/core/daemon/sksd.js

@@ -0,0 +1,87 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const SKSD_STATE_SCHEMA = 'sks.sksd-state.v1';
+export function sksdStatus(root) {
+    const state = readState(root);
+    if (!state)
+        return emptyState(root);
+    if (state.pid && !pidAlive(state.pid)) {
+        const stopped = { ...emptyState(root), stale_cleaned: true };
+        writeState(root, stopped);
+        return stopped;
+    }
+    return state;
+}
+export function sksdWarm(root) {
+    const state = {
+        schema: SKSD_STATE_SCHEMA,
+        status: 'warm',
+        pid: process.pid,
+        warmed_at: new Date().toISOString(),
+        ipc_path: ipcPath(root),
+        proof_bank_ready: true,
+        build_proof_ready: fs.existsSync(path.join(root, 'dist', '.sks-build-proof.json')),
+        triwiki_index_ready: fs.existsSync(path.join(root, '.sneakoscope', 'wiki', 'context-pack.json')),
+        probe_memoization_ready: fs.existsSync(path.join(root, '.sneakoscope', 'cache', 'probes'))
+    };
+    writeState(root, state);
+    fs.writeFileSync(ipcPath(root), `${JSON.stringify({ schema: 'sks.sksd-ipc.v1', pid: process.pid, command: 'warm', at: new Date().toISOString() }, null, 2)}\n`);
+    return state;
+}
+export function sksdStop(root) {
+    const state = { ...emptyState(root), status: 'stopped' };
+    writeState(root, state);
+    try {
+        fs.rmSync(ipcPath(root), { force: true });
+    }
+    catch { }
+    return state;
+}
+function readState(root) {
+    const file = statePath(root);
+    try {
+        if (!fs.existsSync(file))
+            return null;
+        const json = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return json.schema === SKSD_STATE_SCHEMA ? json : null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeState(root, state) {
+    const file = statePath(root);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`);
+}
+function statePath(root) {
+    return path.join(root, '.sneakoscope', 'cache', 'sksd-state.json');
+}
+function emptyState(root = process.cwd()) {
+    return {
+        schema: SKSD_STATE_SCHEMA,
+        status: 'stopped',
+        pid: null,
+        warmed_at: null,
+        ipc_path: ipcPath(root),
+        proof_bank_ready: false,
+        build_proof_ready: false,
+        triwiki_index_ready: false,
+        probe_memoization_ready: false
+    };
+}
+function ipcPath(root) {
+    const dir = path.join(root, '.sneakoscope', 'cache', 'sksd');
+    fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, 'sksd.ipc.json');
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=sksd.js.map

package/dist/core/doctor/doctor-dirty-planner.js

@@ -0,0 +1,95 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { hashJson } from '../triwiki/triwiki-cache-key.js';
+export const DOCTOR_DIRTY_PLAN_SCHEMA = 'sks.doctor-dirty-plan.v1';
+export function planDoctorDirtyRepair(root, phaseIds) {
+    const phases = phaseIds.map((id) => {
+        const marker = markerPath(root, id);
+        const inputHash = phaseInputHash(root, id);
+        const postcheckRequired = phaseRequiresPostcheck(id);
+        const markerState = readMarker(marker);
+        if (!markerState)
+            return { id, status: 'dirty', reason: 'no_clean_marker', input_hash: inputHash, last_clean_proof_id: null, postcheck_required: postcheckRequired };
+        if (markerState.input_hash !== inputHash) {
+            return { id, status: 'dirty', reason: 'input_hash_changed', input_hash: inputHash, last_clean_proof_id: markerState.proof_id, postcheck_required: postcheckRequired };
+        }
+        if (postcheckRequired && !markerState.postcheck_passed) {
+            return { id, status: 'dirty', reason: 'postcheck_required', input_hash: inputHash, last_clean_proof_id: markerState.proof_id, postcheck_required: true };
+        }
+        return { id, status: 'clean', reason: 'matching_clean_proof', input_hash: inputHash, last_clean_proof_id: markerState.proof_id, postcheck_required: postcheckRequired };
+    });
+    const plan = {
+        schema: DOCTOR_DIRTY_PLAN_SCHEMA,
+        root,
+        phases,
+        dirty_count: phases.filter((phase) => phase.status === 'dirty').length,
+        clean_count: phases.filter((phase) => phase.status === 'clean').length
+    };
+    writeDirtyPlan(root, plan);
+    return plan;
+}
+export function markDoctorPhaseClean(root, id) {
+    const file = markerPath(root, id);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify({ schema: 'sks.doctor-dirty-clean-proof.v1', proof_id: `doctor-${id}-${Date.now()}`, cleaned_at: new Date().toISOString(), input_hash: phaseInputHash(root, id), postcheck_passed: true }, null, 2)}\n`);
+}
+export function isDoctorPhaseClean(plan, id) {
+    return plan?.phases.find((phase) => phase.id === id)?.status === 'clean';
+}
+function markerPath(root, id) {
+    return path.join(root, '.sneakoscope', 'cache', 'doctor-dirty', `${id.replace(/[^a-zA-Z0-9._-]+/g, '_')}.clean`);
+}
+function readMarker(file) {
+    try {
+        if (!fs.existsSync(file))
+            return null;
+        const raw = fs.readFileSync(file, 'utf8');
+        if (!raw.trim().startsWith('{'))
+            return { proof_id: null, input_hash: null, postcheck_passed: false };
+        const json = JSON.parse(raw);
+        return { proof_id: json.proof_id || null, input_hash: json.input_hash || null, postcheck_passed: json.postcheck_passed === true };
+    }
+    catch {
+        return null;
+    }
+}
+function phaseInputHash(root, id) {
+    const files = phaseInputFiles(id).map((rel) => {
+        const file = path.join(root, rel);
+        if (!fs.existsSync(file))
+            return { rel, hash: 'missing' };
+        const stat = fs.statSync(file);
+        return { rel, hash: stat.isDirectory() ? `dir:${stat.mtimeMs}` : hashJson({ size: stat.size, mtimeMs: stat.mtimeMs, text: stat.size < 512_000 ? fs.readFileSync(file, 'utf8') : '' }) };
+    });
+    return hashJson({ id, files, env: phaseEnvPresence(id) });
+}
+function phaseInputFiles(id) {
+    if (id.includes('zellij'))
+        return ['src/core/zellij', 'src/core/doctor/doctor-zellij-repair.ts'];
+    if (id.includes('context7'))
+        return ['src/core/doctor/context7-mcp-repair.ts', '.codex/config.toml'];
+    if (id.includes('startup'))
+        return ['src/core/doctor/codex-startup-config-repair.ts', '.codex/config.toml'];
+    if (id.includes('supabase'))
+        return ['src/core/doctor/supabase-mcp-repair.ts', '.codex/config.toml'];
+    if (id.includes('skill'))
+        return ['.agents/skills', 'src/scripts/skill-registry-ledger-check.ts'];
+    if (id.includes('native'))
+        return ['src/core/codex-native', 'src/scripts/native-capability-postcheck-check.ts'];
+    if (id.includes('secret'))
+        return ['safety-mutation-allowlist.json', 'src/scripts/secret-preservation-check.ts'];
+    return ['package.json', 'src/core/doctor'];
+}
+function phaseEnvPresence(id) {
+    const keys = id.includes('supabase') ? ['SUPABASE_ACCESS_TOKEN'] : id.includes('context7') ? ['CONTEXT7_API_KEY'] : [];
+    return Object.fromEntries(keys.map((key) => [key, process.env[key] !== undefined]));
+}
+function phaseRequiresPostcheck(id) {
+    return /zellij|context7|startup|supabase|native|secret/i.test(id);
+}
+function writeDirtyPlan(root, plan) {
+    const file = path.join(root, '.sneakoscope', 'reports', 'doctor-dirty-plan.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(plan, null, 2)}\n`);
+}
+//# sourceMappingURL=doctor-dirty-planner.js.map

package/dist/core/doctor/doctor-transaction.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { isDoctorPhaseClean, markDoctorPhaseClean } from './doctor-dirty-planner.js';
 export async function runDoctorFixTransaction(input) {
     const startedAt = nowIso();
     const phases = [];
@@ -18,6 +19,16 @@ export async function runDoctorFixTransaction(input) {
             artifact_path: null,
             started_at: phaseStarted
         };
+        if (isDoctorPhaseClean(input.dirtyPlan, definition.id)) {
+            phases.push({
+                ...phase,
+                ok: true,
+                warnings: ['dirty_plan_skipped_clean_phase'],
+                completed_at: nowIso(),
+                duration_ms: Math.max(0, Date.now() - startedMs)
+            });
+            continue;
+        }
         try {
             const result = await definition.run();
             phase = normalizePhase(definition, result, phase, startedMs);
@@ -48,6 +59,8 @@ export async function runDoctorFixTransaction(input) {
         }
         phase.completed_at = phase.completed_at || nowIso();
         phase.duration_ms = phase.duration_ms ?? Math.max(0, Date.now() - startedMs);
+        if (phase.ok)
+            markDoctorPhaseClean(input.root, definition.id);
         phases.push(phase);
     }
     const writeInput = {

package/dist/core/feature-fixtures.js

@@ -21,6 +21,7 @@ const FIXTURES = Object.freeze({
     'cli-hooks': fixture('mock', 'sks hooks trust-report --json', [], 'pass'),
     'cli-features': fixture('execute', 'sks features check --json', [], 'pass'),
     'cli-commands': fixture('execute', 'sks commands --json', [], 'pass'),
+    'cli-check': fixture('execute', 'sks check --tier confidence --sla 5m --plan --json', [], 'pass'),
     'cli-run': fixture('execute_and_validate_artifacts', 'sks run "fixture" --mock --json', ['run-classification.json', 'completion-proof.json', 'evidence-index.json', 'route-completion-contract.json', 'trust-report.json'], 'pass'),
     'cli-status': fixture('execute', 'sks status --json', [], 'pass'),
     'cli-usage': fixture('execute', 'sks usage overview', [], 'pass'),

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '3.1.14';
+export const PACKAGE_VERSION = '4.0.1';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/init.js

@@ -806,7 +806,13 @@ export async function initProject(root, opts = {}) {
             // Context7 credentials may live directly in this table as args/env/headers/url
             // depending on the user's MCP client setup. Seed the default only when absent;
             // never replace an existing Context7 block during setup/update.
-            { table: 'mcp_servers.context7', text: context7ConfigToml().trim(), preserveExisting: true },
+            // Seed the REMOTE (streamable HTTP `url`) transport, not local stdio: Codex
+            // merges the global ~/.codex/config.toml and the project config per-key, so a
+            // local-stdio `command` here merging with a remote `url` in the global config
+            // yields a stdio server that also carries a `url` — which Codex 0.140 rejects
+            // with `url is not supported for stdio`. Remote is also the transport the doctor
+            // migrates everyone to (local stdio can block interactive Codex launch).
+            { table: 'mcp_servers.context7', text: context7ConfigToml('remote').trim(), preserveExisting: true },
             { table: 'agents.native_agent', text: agentConfigBlock('native_agent', 'Read-only SKS analysis agent.', './agents/native-agent-intake.toml', ['Analysis', 'Mapper']) },
             { table: 'agents.team_consensus', text: agentConfigBlock('team_consensus', 'SKS planning/debate agent.', './agents/team-consensus.toml', ['Consensus', 'Atlas']) },
             { table: 'agents.implementation_worker', text: agentConfigBlock('implementation_worker', 'SKS bounded implementation worker.', './agents/implementation-worker.toml', ['Builder', 'Mason']) },

package/dist/core/probes/probe-memoization.js

@@ -0,0 +1,80 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { hashJson } from '../triwiki/triwiki-cache-key.js';
+export const PROBE_MEMOIZATION_SCHEMA = 'sks.probe-memoization.v1';
+export function memoizeProbe(input) {
+    const key = hashJson({
+        probe_id: input.probeId,
+        version: input.version,
+        env: envPresence(input.envAllowlist || []),
+        file_hash: input.fileHash || null
+    });
+    const file = probeCachePath(input.root, key);
+    const existing = readProbeRecord(file);
+    if (existing && new Date(existing.expires_at).getTime() > Date.now())
+        return { value: existing.value, reused: true, key };
+    const value = input.run();
+    const record = {
+        schema: PROBE_MEMOIZATION_SCHEMA,
+        key,
+        probe_id: input.probeId,
+        created_at: new Date().toISOString(),
+        expires_at: new Date(Date.now() + input.ttlMs).toISOString(),
+        value,
+        tool_version: input.version,
+        ...(input.fileHash ? { file_hash: input.fileHash } : {}),
+        env_allowlist_hash: hashJson(envPresence(input.envAllowlist || []))
+    };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
+    return { value, reused: false, key };
+}
+export async function memoizeProbeAsync(input) {
+    const key = hashJson({ probe_id: input.probeId, version: input.version, env: envPresence(input.envAllowlist || []), file_hash: input.fileHash || null });
+    const file = probeCachePath(input.root, key);
+    const existing = readProbeRecord(file);
+    if (existing && new Date(existing.expires_at).getTime() > Date.now()) {
+        writeProbeReport(input.root, { repeated_probe_count: 1, reused_probe_count: 1, saved_ms_estimate: Math.max(1, input.ttlMs / 1000) });
+        return { value: existing.value, reused: true, key };
+    }
+    const started = Date.now();
+    const value = await input.run();
+    const record = {
+        schema: PROBE_MEMOIZATION_SCHEMA,
+        key,
+        probe_id: input.probeId,
+        created_at: new Date().toISOString(),
+        expires_at: new Date(Date.now() + input.ttlMs).toISOString(),
+        value,
+        tool_version: input.version,
+        ...(input.fileHash ? { file_hash: input.fileHash } : {}),
+        env_allowlist_hash: hashJson(envPresence(input.envAllowlist || []))
+    };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
+    writeProbeReport(input.root, { repeated_probe_count: 1, reused_probe_count: 0, saved_ms_estimate: Math.max(0, Date.now() - started) });
+    return { value, reused: false, key };
+}
+function readProbeRecord(file) {
+    try {
+        if (!fs.existsSync(file))
+            return null;
+        const json = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return json.schema === PROBE_MEMOIZATION_SCHEMA ? json : null;
+    }
+    catch {
+        return null;
+    }
+}
+function probeCachePath(root, key) {
+    return path.join(root, '.sneakoscope', 'cache', 'probes', `${key}.json`);
+}
+function envPresence(keys) {
+    return [...new Set(keys)].sort().map((name) => ({ name, present: process.env[name] !== undefined }));
+}
+function writeProbeReport(root, report) {
+    const file = path.join(root, '.sneakoscope', 'reports', 'probe-memoization.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify({ schema: 'sks.probe-memoization-report.v1', ...report }, null, 2)}\n`);
+}
+//# sourceMappingURL=probe-memoization.js.map

package/dist/core/release/critical-path-ledger.js

@@ -0,0 +1,12 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function buildCriticalPathLedger(input) {
+    return { schema: 'sks.critical-path-ledger.v1', ...input };
+}
+export function writeCriticalPathLedger(root, ledger) {
+    const file = path.join(root, '.sneakoscope', 'reports', 'critical-path-ledger.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(ledger, null, 2)}\n`);
+    return file;
+}
+//# sourceMappingURL=critical-path-ledger.js.map

package/dist/core/release/extreme-parallel-scheduler.js

@@ -0,0 +1,86 @@
+import { buildGatePackManifest } from './gate-pack-manifest.js';
+import { executeGatePack } from './gate-pack-runner.js';
+import { buildCriticalPathLedger, writeCriticalPathLedger } from './critical-path-ledger.js';
+import { computeResourceClassBudget } from './resource-class-budget.js';
+export const EXTREME_PARALLEL_SCHEDULER_SCHEMA = 'sks.extreme-parallel-scheduler.v1';
+export function planExtremeParallelSchedule(root, graph, budget = computeResourceClassBudget()) {
+    const manifest = buildGatePackManifest(root);
+    const selectedIds = new Set(graph?.gate_packs && graph.gate_packs.length ? graph.gate_packs : manifest.packs.map((pack) => pack.id));
+    const packs = manifest.packs.filter((pack) => selectedIds.has(pack.id)).sort((a, b) => b.estimated_ms - a.estimated_ms);
+    const laneCount = Math.max(1, Math.min(packs.length || 1, Math.max(4, budget.cpu_light)));
+    const lanes = Array.from({ length: laneCount }, () => ({ packs: [], estimated_ms: 0 }));
+    for (const pack of packs) {
+        const target = lanes.reduce((best, lane) => lane.estimated_ms < best.estimated_ms ? lane : best, lanes[0]);
+        target.packs.push(pack.id);
+        target.estimated_ms += pack.estimated_ms;
+    }
+    const batches = lanes
+        .filter((lane) => lane.packs.length > 0)
+        .map((lane, index) => ({ batch: index + 1, packs: lane.packs, estimated_ms: lane.estimated_ms }));
+    const sequential = packs.reduce((sum, pack) => sum + pack.estimated_ms, 0);
+    const critical = batches.reduce((max, batch) => Math.max(max, batch.estimated_ms), 0);
+    const ratio = sequential <= 0 ? 1 : critical / sequential;
+    const blockers = ratio <= 0.3 || packs.length <= 1 ? [] : ['critical_path_reduction_below_70_percent'];
+    return {
+        schema: EXTREME_PARALLEL_SCHEDULER_SCHEMA,
+        ok: blockers.length === 0,
+        batches,
+        sequential_ms: sequential,
+        critical_path_ms: critical,
+        reduction_ratio: Number(ratio.toFixed(4)),
+        budget,
+        blockers
+    };
+}
+export async function executeExtremeSchedule(input) {
+    const planned = planExtremeParallelSchedule(input.root, input.graph, input.budget);
+    const started = Date.now();
+    const runId = `xs-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
+    const reports = [];
+    let reused = 0;
+    let executedGates = 0;
+    let failedPacks = 0;
+    for (const batch of planned.batches) {
+        const results = await Promise.all(batch.packs.map((packId) => executeGatePack({
+            root: input.root,
+            packId,
+            mode: 'execute',
+            maxParallel: Math.max(1, Math.min(4, input.budget.cpu_light))
+        })));
+        for (const report of results) {
+            reports.push(report);
+            reused += report.reused_proof_count || report.reused || 0;
+            executedGates += report.executed_gate_count || report.executed || 0;
+            if (!report.ok)
+                failedPacks += 1;
+        }
+    }
+    const wallMs = Math.max(0, Date.now() - started);
+    const criticalPathMs = reports.reduce((max, report) => Math.max(max, report.critical_path_ms || 0), planned.critical_path_ms);
+    const sequentialMs = reports.reduce((sum, report) => sum + (report.critical_path_ms || 0), planned.sequential_ms);
+    writeCriticalPathLedger(input.root, buildCriticalPathLedger({
+        run_id: runId,
+        sequential_ms: sequentialMs,
+        critical_path_ms: criticalPathMs,
+        wall_ms: wallMs,
+        parallelism_gain: wallMs > 0 ? Number((sequentialMs / wallMs).toFixed(2)) : 1,
+        resource_wait_ms: {},
+        top_blockers: reports.filter((report) => !report.ok).map((report) => ({ id: report.pack_id, wait_ms: 0, run_ms: report.critical_path_ms || 0 }))
+    }));
+    return {
+        ...planned,
+        ok: planned.ok && failedPacks === 0 && wallMs <= input.slaMs,
+        run_id: runId,
+        mode: 'execute',
+        executed_packs: reports.map((report) => report.pack_id),
+        reused_proof_count: reused,
+        executed_gate_count: executedGates,
+        failed_pack_count: failedPacks,
+        wall_ms: wallMs,
+        critical_path_ms: criticalPathMs,
+        sequential_ms: sequentialMs,
+        pack_reports: reports,
+        blockers: [...planned.blockers, ...(wallMs > input.slaMs ? ['sla_actual_exceeds_budget'] : []), ...(failedPacks ? ['pack_execution_failed'] : [])]
+    };
+}
+//# sourceMappingURL=extreme-parallel-scheduler.js.map

package/dist/core/release/gate-pack-fixture-cache.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const GATE_PACK_FIXTURE_SCHEMA = 'sks.gate-pack-fixture.v1';
+export async function prepareGatePackFixture(input) {
+    const base = path.join(input.root, '.sneakoscope', 'fixture-cache', 'gate-packs', safe(input.packId), safe(input.fixtureVersion));
+    const reusedBase = fs.existsSync(path.join(base, 'fixture.json'));
+    fs.mkdirSync(base, { recursive: true });
+    if (!reusedBase) {
+        fs.writeFileSync(path.join(base, 'fixture.json'), `${JSON.stringify({ schema: GATE_PACK_FIXTURE_SCHEMA, pack_id: input.packId, fixture_version: input.fixtureVersion, created_at: new Date().toISOString() }, null, 2)}\n`);
+    }
+    const runPath = path.join(input.root, '.sneakoscope', 'fixture-cache', 'runs', `${safe(input.packId)}-${process.pid}-${Date.now()}`);
+    fs.mkdirSync(path.dirname(runPath), { recursive: true });
+    copyDir(base, runPath);
+    return {
+        schema: GATE_PACK_FIXTURE_SCHEMA,
+        root: input.root,
+        pack_id: input.packId,
+        fixture_version: input.fixtureVersion,
+        base_path: base,
+        run_path: runPath,
+        reused_base: reusedBase,
+        setup_count: reusedBase ? 0 : 1
+    };
+}
+function copyDir(from, to) {
+    fs.mkdirSync(to, { recursive: true });
+    for (const entry of fs.readdirSync(from, { withFileTypes: true })) {
+        const src = path.join(from, entry.name);
+        const dst = path.join(to, entry.name);
+        if (entry.isDirectory())
+            copyDir(src, dst);
+        else if (entry.isFile())
+            fs.copyFileSync(src, dst);
+    }
+}
+function safe(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '_');
+}
+//# sourceMappingURL=gate-pack-fixture-cache.js.map