sneakoscope 3.1.13 → 4.0.0

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

@@ -0,0 +1,42 @@
+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: (input.envAllowlist || []).sort().map((name) => ({ name, present: process.env[name] !== undefined }))
+    });
+    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
+    };
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`);
+    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`);
+}
+//# sourceMappingURL=probe-memoization.js.map

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

@@ -0,0 +1,33 @@
+import { buildGatePackManifest } from './gate-pack-manifest.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
+    };
+}
+//# sourceMappingURL=extreme-parallel-scheduler.js.map

package/dist/core/release/gate-pack-manifest.js

@@ -0,0 +1,118 @@
+import { buildTriWikiGateImpactMap } from '../triwiki/triwiki-gate-impact-map.js';
+export const GATE_PACK_MANIFEST_SCHEMA = 'sks.gate-pack-manifest.v1';
+export const REQUIRED_GATE_PACK_IDS = [
+    'release-parity',
+    'codex-0140',
+    'doctor-production',
+    'startup-mcp',
+    'native-capability',
+    'secret',
+    'core-skill',
+    'skill-dedupe',
+    'zellij',
+    'loop-mesh',
+    'qa-research-image',
+    'triwiki'
+];
+export function buildGatePackManifest(root, gates) {
+    const impactMap = buildTriWikiGateImpactMap(root);
+    const byPack = new Map();
+    for (const pack of REQUIRED_GATE_PACK_IDS)
+        byPack.set(pack, []);
+    for (const impact of impactMap.impacts) {
+        const ids = byPack.get(impact.gate_pack) || [];
+        ids.push(impact.gate_id);
+        byPack.set(impact.gate_pack, ids);
+    }
+    for (const gate of gates || []) {
+        const pack = packForGateId(gate.id);
+        const ids = byPack.get(pack) || [];
+        if (!ids.includes(gate.id))
+            ids.push(gate.id);
+        byPack.set(pack, ids);
+    }
+    return {
+        schema: GATE_PACK_MANIFEST_SCHEMA,
+        root,
+        packs: REQUIRED_GATE_PACK_IDS.map((id) => ({
+            id,
+            description: descriptionForPack(id),
+            max_parallel: maxParallelForPack(id),
+            estimated_ms: estimatedMsForPack(id),
+            resource_classes: resourceClassesForPack(id),
+            gate_ids: [...new Set(byPack.get(id) || [])].sort()
+        }))
+    };
+}
+export function packForGateId(id) {
+    if (id.startsWith('triwiki:'))
+        return 'triwiki';
+    if (id.startsWith('codex:') || id.includes('0140'))
+        return 'codex-0140';
+    if (id.startsWith('doctor:'))
+        return 'doctor-production';
+    if (id.startsWith('sksd:') || id.startsWith('probes:') || id.includes('mcp'))
+        return 'startup-mcp';
+    if (id.includes('native') || id.startsWith('agent:'))
+        return 'native-capability';
+    if (id.startsWith('secret:') || id.includes('secret'))
+        return 'secret';
+    if (id.startsWith('core-skill:'))
+        return 'core-skill';
+    if (id.includes('skill-dedupe') || id.startsWith('skill:'))
+        return 'skill-dedupe';
+    if (id.includes('zellij') || id.startsWith('legacy:') || id.startsWith('orphan:'))
+        return 'zellij';
+    if (id.startsWith('loop:'))
+        return 'loop-mesh';
+    if (id.startsWith('qa-') || id.startsWith('research:') || id.startsWith('image:'))
+        return 'qa-research-image';
+    return 'release-parity';
+}
+function descriptionForPack(id) {
+    const descriptions = {
+        'release-parity': 'Version, DAG, parity, and package release gates.',
+        'codex-0140': 'Codex 0.140 capability and integration checks.',
+        'doctor-production': 'Doctor repair and production safety checks.',
+        'startup-mcp': 'Startup, MCP, daemon, and probe readiness checks.',
+        'native-capability': 'Native agent and desktop capability checks.',
+        secret: 'Secret-preservation and redaction checks.',
+        'core-skill': 'Immutable core skill checks.',
+        'skill-dedupe': 'Skill duplication and inventory checks.',
+        zellij: 'Zellij and removed legacy runtime checks.',
+        'loop-mesh': 'Loop mesh runtime checks.',
+        'qa-research-image': 'QA, research, and image route checks.',
+        triwiki: 'TriWiki proof bank and affected graph checks.'
+    };
+    return descriptions[id] || id;
+}
+function maxParallelForPack(id) {
+    if (id === 'secret' || id === 'zellij')
+        return 1;
+    if (id === 'qa-research-image' || id === 'codex-0140')
+        return 2;
+    return 4;
+}
+function estimatedMsForPack(id) {
+    if (id === 'release-parity')
+        return 25_000;
+    if (id === 'triwiki')
+        return 12_000;
+    if (id === 'doctor-production')
+        return 18_000;
+    if (id === 'qa-research-image')
+        return 30_000;
+    return 15_000;
+}
+function resourceClassesForPack(id) {
+    if (id === 'secret')
+        return ['fs-read'];
+    if (id === 'zellij')
+        return ['zellij-real'];
+    if (id === 'qa-research-image')
+        return ['cpu-heavy', 'io-heavy'];
+    if (id === 'codex-0140')
+        return ['remote-model-real'];
+    return ['cpu-light', 'fs-read'];
+}
+//# sourceMappingURL=gate-pack-manifest.js.map

package/dist/core/release/gate-pack-runner.js

@@ -0,0 +1,113 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { computeTriWikiCacheKey } from '../triwiki/triwiki-cache-key.js';
+import { createTriWikiProofCard } from '../triwiki/triwiki-proof-card.js';
+import { readReusableTriWikiProofCard, writeTriWikiProofCard } from '../triwiki/triwiki-proof-bank.js';
+import { buildGatePackManifest } from './gate-pack-manifest.js';
+import { loadPackageScripts, loadReleaseGateManifest } from '../triwiki/triwiki-gate-impact-map.js';
+export const GATE_PACK_RUNNER_SCHEMA = 'sks.gate-pack-runner.v1';
+export function runGatePack(input) {
+    const manifest = buildGatePackManifest(input.root);
+    const pack = manifest.packs.find((candidate) => candidate.id === input.packId);
+    if (!pack) {
+        return { schema: GATE_PACK_RUNNER_SCHEMA, ok: false, root: input.root, pack_id: input.packId, mode: input.execute ? 'execute' : 'plan', reused: 0, executed: 0, failed: 0, proof_paths: [], blockers: ['pack_missing'] };
+    }
+    const gates = loadReleaseGateManifest(input.root).gates.filter((gate) => pack.gate_ids.includes(gate.id));
+    const scripts = loadPackageScripts(input.root);
+    const blockers = [];
+    const proofPaths = [];
+    let reused = 0;
+    let executed = 0;
+    let failed = 0;
+    for (const gate of gates) {
+        if (!input.execute)
+            continue;
+        const cacheKey = computeTriWikiCacheKey({
+            root: input.root,
+            id: gate.id,
+            inputs: gate.cache.inputs,
+            implementationFiles: [`src/scripts/${scriptFileForCommand(gate.command) || ''}`].filter(Boolean),
+            envAllowlist: ['CI', 'SKS_FAST_MODE', 'SKS_RELEASE_PRESET'],
+            fixtureVersion: 'sks-4.0.0'
+        });
+        const hit = readReusableTriWikiProofCard({ root: input.root, subjectId: gate.id, cacheKey: cacheKey.key });
+        if (hit.hit) {
+            reused += 1;
+            if (hit.path)
+                proofPaths.push(hit.path);
+            continue;
+        }
+        const scriptName = scriptNameForCommand(gate.command);
+        if (!scriptName || !scripts[scriptName]) {
+            failed += 1;
+            blockers.push(`script_missing:${gate.id}`);
+            continue;
+        }
+        const started = Date.now();
+        const run = spawnSync('npm', ['run', scriptName, '--silent'], {
+            cwd: input.root,
+            encoding: 'utf8',
+            maxBuffer: 1024 * 1024 * 10,
+            env: { ...process.env, ...(input.env || {}), CI: process.env.CI || 'true' }
+        });
+        executed += 1;
+        const passed = run.status === 0;
+        if (!passed) {
+            failed += 1;
+            blockers.push(`gate_failed:${gate.id}`);
+        }
+        const card = createTriWikiProofCard({
+            subject_type: 'gate',
+            subject_id: gate.id,
+            cache_key: cacheKey.key,
+            input_hash: cacheKey.input_hash,
+            implementation_hash: cacheKey.implementation_hash,
+            tool_version: cacheKey.tool_version,
+            fixture_version: cacheKey.fixture_version,
+            result: passed ? 'passed' : 'failed',
+            reusable: passed,
+            duration_ms: Math.max(0, Date.now() - started),
+            evidence: {
+                status: run.status,
+                stdout_tail: tail(String(run.stdout || '')),
+                stderr_tail: tail(String(run.stderr || ''))
+            },
+            invalidation_reasons: passed ? [] : ['gate_failed']
+        });
+        proofPaths.push(writeTriWikiProofCard(input.root, card));
+    }
+    const report = {
+        schema: GATE_PACK_RUNNER_SCHEMA,
+        ok: blockers.length === 0,
+        root: input.root,
+        pack_id: input.packId,
+        mode: input.execute ? 'execute' : 'plan',
+        reused,
+        executed,
+        failed,
+        proof_paths: proofPaths,
+        blockers
+    };
+    writeGatePackReport(input.root, report);
+    return report;
+}
+function writeGatePackReport(root, report) {
+    const file = path.join(root, '.sneakoscope', 'reports', 'gate-pack-runner.json');
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, `${JSON.stringify(report, null, 2)}\n`);
+}
+function scriptNameForCommand(command) {
+    const match = command.match(/^npm run ([^ ]+)/);
+    return match?.[1] || null;
+}
+function scriptFileForCommand(command) {
+    const script = scriptNameForCommand(command);
+    if (!script)
+        return null;
+    return `${script.replace(/[:]/g, '-')}${script.includes('blackbox') ? '' : '-check'}.ts`;
+}
+function tail(value, limit = 2000) {
+    return value.length > limit ? value.slice(-limit) : value;
+}
+//# sourceMappingURL=gate-pack-runner.js.map

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

@@ -2,10 +2,16 @@ import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import { normalizeReleaseCacheInputForBehavior } from './release-cache-key.js';
+import { computeTriWikiCacheKey } from '../triwiki/triwiki-cache-key.js';
+import { createTriWikiProofCard } from '../triwiki/triwiki-proof-card.js';
+import { readReusableTriWikiProofCard, writeTriWikiProofCard } from '../triwiki/triwiki-proof-bank.js';
 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 releaseGateProofBankFile(root) {
+    return path.join(root, '.sneakoscope', 'proof-bank', 'gates', 'cache-v2.json');
+}
 // Files whose only release-to-release difference is the version literal.
 // Hashing them version-neutrally keeps a pure `sks versioning bump` from
 // invalidating every behavior gate: bumping the version rewrites
@@ -117,11 +123,23 @@ export function readReleaseGateCacheHit(root, gate) {
     return Boolean(readReleaseGateCacheRecord(root, gate));
 }
 export function readReleaseGateCacheRecord(root, gate) {
-    try {
-        const parsed = JSON.parse(fs.readFileSync(releaseGateCacheFile(root), 'utf8'));
-        const record = parsed.schema === RELEASE_GATE_CACHE_V2_SCHEMA ? parsed.records?.[releaseGateCacheKey(root, gate)] : null;
-        if (record?.ok !== true)
-            return null;
+    const key = releaseGateCacheKey(root, gate);
+    const proof = readReusableTriWikiProofCard({ root, subjectId: gate.id, cacheKey: key });
+    if (proof.hit && proof.card) {
+        return {
+            ok: true,
+            gate_id: gate.id,
+            command: gate.command,
+            resource: gate.resource,
+            preset: gate.preset,
+            duration_ms: Math.max(0, Math.floor(Number(proof.card.duration_ms) || 0)),
+            recorded_at: proof.card.created_at
+        };
+    }
+    for (const file of [releaseGateProofBankFile(root), releaseGateCacheFile(root)]) {
+        const record = readCacheRecord(file, key);
+        if (!record || record.ok !== true)
+            continue;
         return {
             ok: true,
             gate_id: String(record.gate_id || gate.id),
@@ -132,12 +150,59 @@ export function readReleaseGateCacheRecord(root, gate) {
             recorded_at: String(record.recorded_at || '')
         };
     }
+    return null;
+}
+export function writeReleaseGateCacheHit(root, gate, durationMs = 0) {
+    const key = releaseGateCacheKey(root, gate);
+    const record = {
+        ok: true,
+        gate_id: gate.id,
+        command: gate.command,
+        resource: gate.resource,
+        preset: gate.preset,
+        duration_ms: Math.max(0, Math.floor(Number(durationMs) || 0)),
+        recorded_at: new Date().toISOString()
+    };
+    writeCacheRecord(releaseGateCacheFile(root), key, record);
+    writeCacheRecord(releaseGateProofBankFile(root), key, record);
+    const triKey = computeTriWikiCacheKey({
+        root,
+        id: gate.id,
+        inputs: gate.cache.inputs,
+        implementationFiles: ['release-gates.v2.json', `src/scripts/${gate.id.replace(/[:]/g, '-')}-check.ts`],
+        envAllowlist: ['CI', 'SKS_FAST_MODE', 'SKS_RELEASE_PRESET'],
+        fixtureVersion: 'sks-4.0.0',
+        salt: key
+    });
+    writeTriWikiProofCard(root, createTriWikiProofCard({
+        subject_type: 'gate',
+        subject_id: gate.id,
+        cache_key: key,
+        input_hash: triKey.input_hash,
+        implementation_hash: triKey.implementation_hash,
+        tool_version: triKey.tool_version,
+        fixture_version: triKey.fixture_version,
+        result: 'passed',
+        reusable: true,
+        duration_ms: Math.max(0, Math.floor(Number(durationMs) || 0)),
+        evidence: {
+            command: gate.command,
+            cache_key_schema: 'release-cache-v2-compatible',
+            triwiki_key: triKey.key
+        },
+        invalidation_reasons: []
+    }));
+}
+function readCacheRecord(file, key) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return parsed.schema === RELEASE_GATE_CACHE_V2_SCHEMA ? parsed.records?.[key] || null : null;
+    }
     catch {
         return null;
     }
 }
-export function writeReleaseGateCacheHit(root, gate, durationMs = 0) {
-    const file = releaseGateCacheFile(root);
+function writeCacheRecord(file, key, record) {
     let parsed = { schema: RELEASE_GATE_CACHE_V2_SCHEMA, records: {} };
     try {
         parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
@@ -145,15 +210,7 @@ export function writeReleaseGateCacheHit(root, gate, durationMs = 0) {
     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,
-        duration_ms: Math.max(0, Math.floor(Number(durationMs) || 0)),
-        recorded_at: new Date().toISOString()
-    };
+    parsed.records[key] = record;
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, `${JSON.stringify(parsed, null, 2)}\n`);
 }

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

@@ -4,7 +4,7 @@ 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 { readReleaseGateCacheRecord, writeReleaseGateCacheHit } from './release-gate-cache-v2.js';
+import { readReleaseGateCacheRecord, releaseGateProofBankFile, 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';
 import { selectAffectedReleaseGates } from './release-gate-affected-selector.js';
@@ -38,8 +38,11 @@ export async function runReleaseGateDag(input) {
     const reportDir = path.join(root, '.sneakoscope', 'reports', 'release-gates', runId);
     fs.mkdirSync(reportDir, { recursive: true });
     const timeline = path.join(reportDir, 'timeline.jsonl');
+    const affectedGraphFile = path.join(reportDir, 'affected-gate-graph.json');
+    const completionCertificateFile = path.join(reportDir, 'completion-certificate.json');
     appendReleaseGateJsonl(timeline, { event: 'retention', phase: 'before_run', ...retentionBefore, at: new Date().toISOString() });
     const started = Date.now();
+    const slaMs = Math.max(1, Math.floor(Number(input.slaMs || 300000)));
     const pending = new Map(selected.map((gate) => [gate.id, gate]));
     const running = new Map();
     const completed = new Map();
@@ -54,6 +57,23 @@ export async function runReleaseGateDag(input) {
     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, timed_out: row.timed_out, signal: row.signal }));
+        const affectedGraph = buildAffectedGraph({
+            selection: affected.selection,
+            selected,
+            cachedGates,
+            executedGates,
+            proofBankFile: releaseGateProofBankFile(root)
+        });
+        const completionCertificate = buildCompletionCertificate({
+            ok: failures.length === 0,
+            preset,
+            slaMs,
+            wallMs,
+            criticalPathMs: estimateCriticalPath(selected, completed),
+            affectedGraph,
+            affectedGraphFile,
+            skippedByAffected: affected.selection.mode === 'affected' ? affected.selection.skipped_gate_ids : []
+        });
         const snapshot = {
             schema: 'sks.release-gate-dag-run.v1',
             ok: failures.length === 0,
@@ -83,7 +103,9 @@ export async function runReleaseGateDag(input) {
             budget_snapshot: budget,
             budget_summary: summarizeReleaseGateBudget(budget),
             report_dir: reportDir,
-            failures
+            failures,
+            affected_graph: affectedGraph,
+            completion_certificate: completionCertificate
         };
         if (!finished) {
             snapshot.in_progress = true;
@@ -91,6 +113,12 @@ export async function runReleaseGateDag(input) {
             snapshot.running = running.size;
         }
         writeReleaseGateJson(path.join(reportDir, 'summary.json'), snapshot);
+        writeReleaseGateJson(affectedGraphFile, affectedGraph);
+        writeReleaseGateJson(completionCertificateFile, completionCertificate);
+        if (finished) {
+            writeReleaseGateJson(path.join(root, '.sneakoscope', 'reports', 'affected-gate-graph.json'), affectedGraph);
+            writeReleaseGateJson(path.join(root, '.sneakoscope', 'reports', 'completion-certificate.json'), completionCertificate);
+        }
         return snapshot;
     };
     if (input.explain) {
@@ -179,6 +207,57 @@ export function selectReleaseGatePreset(manifest, preset) {
     const effectivePreset = preset === 'affected' || preset === 'fast' ? 'release' : preset;
     return manifest.gates.filter((gate) => gate.preset.includes(effectivePreset));
 }
+function buildAffectedGraph(input) {
+    return {
+        schema: 'sks.affected-gate-graph.v1',
+        changed_files: input.selection.changed_files,
+        affected_modules: inferAffectedModules(input.selection.changed_files),
+        affected_gates: input.selected.map((gate) => gate.id),
+        reused_proofs: [...input.cachedGates],
+        invalidated_proofs: [...input.executedGates],
+        skipped_gate_ids: input.selection.skipped_gate_ids,
+        proof_bank_file: input.proofBankFile
+    };
+}
+function buildCompletionCertificate(input) {
+    const affectedScope = input.preset === 'affected' || input.preset === 'fast';
+    return {
+        schema: 'sks.five-minute-completion-certificate.v1',
+        ok: input.ok,
+        tier: input.preset === 'affected' ? 'confidence' : input.preset,
+        confidence: affectedScope ? 'release-equivalent-for-affected-scope' : 'full-release-proof',
+        sla_ms: input.slaMs,
+        sla_met: input.wallMs <= input.slaMs,
+        changed_files: input.affectedGraph.changed_files,
+        affected_gates: input.affectedGraph.affected_gates.length,
+        reused_proofs: input.affectedGraph.reused_proofs.length,
+        newly_executed_gates: input.affectedGraph.invalidated_proofs.length,
+        skipped_as_valid_cache: input.affectedGraph.reused_proofs.length,
+        skipped_as_unaffected: input.skippedByAffected.length,
+        critical_path_ms: input.criticalPathMs,
+        wall_ms: input.wallMs,
+        full_release_proof: affectedScope ? 'background_or_release_before_publish_required' : 'current_run',
+        proof_bank_file: input.affectedGraph.proof_bank_file,
+        affected_graph_file: input.affectedGraphFile
+    };
+}
+function inferAffectedModules(files) {
+    const modules = new Set();
+    for (const file of files) {
+        const normalized = file.replace(/\\/g, '/');
+        const parts = normalized.split('/').filter(Boolean);
+        if (!parts.length)
+            continue;
+        const top = parts[0];
+        if (parts[0] === 'src' && parts.length >= 3)
+            modules.add(parts.slice(0, 3).join('/'));
+        else if (parts[0] === 'test' && parts.length >= 2)
+            modules.add(parts.slice(0, 2).join('/'));
+        else
+            modules.add(top);
+    }
+    return [...modules].sort();
+}
 function runGate(root, runId, reportRoot, gate) {
     const started = Date.now();
     const hermetic = createReleaseGateHermeticEnv({ root, runId, gate, reportRoot });

package/dist/core/release/resource-class-budget.js

@@ -0,0 +1,22 @@
+import os from 'node:os';
+export const RESOURCE_CLASS_BUDGET_SCHEMA = 'sks.resource-class-budget.v1';
+export function computeResourceClassBudget(env = process.env) {
+    const cpus = Math.max(2, os.cpus().length || 2);
+    return {
+        schema: RESOURCE_CLASS_BUDGET_SCHEMA,
+        cpu_light: readEnvInt(env, 'SKS_RESOURCE_CPU_LIGHT', Math.max(2, cpus - 1)),
+        cpu_heavy: readEnvInt(env, 'SKS_RESOURCE_CPU_HEAVY', Math.max(1, Math.floor(cpus / 2))),
+        io_light: readEnvInt(env, 'SKS_RESOURCE_IO_LIGHT', 8),
+        io_heavy: readEnvInt(env, 'SKS_RESOURCE_IO_HEAVY', 2),
+        fs_read: readEnvInt(env, 'SKS_RESOURCE_FS_READ', 8),
+        network: readEnvInt(env, 'SKS_RESOURCE_NETWORK', 2),
+        remote_model_real: readEnvInt(env, 'SKS_RESOURCE_REMOTE_MODEL_REAL', 1),
+        zellij_real: readEnvInt(env, 'SKS_RESOURCE_ZELLIJ_REAL', 1),
+        secret_sensitive: readEnvInt(env, 'SKS_RESOURCE_SECRET', 1)
+    };
+}
+function readEnvInt(env, key, fallback) {
+    const value = Number(env[key]);
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+//# sourceMappingURL=resource-class-budget.js.map

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

@@ -0,0 +1,22 @@
+import { computeTriWikiAffectedGraph } from '../triwiki/triwiki-affected-graph.js';
+import { buildTriWikiSlaCertificate } from '../triwiki/triwiki-sla-certificate.js';
+import { planExtremeParallelSchedule } from './extreme-parallel-scheduler.js';
+export const SLA_SCHEDULER_SCHEMA = 'sks.sla-scheduler.v1';
+export function planFiveMinuteSla(root, graph = computeTriWikiAffectedGraph({ root, tier: 'affected' }), slaMs = 300_000) {
+    const schedule = planExtremeParallelSchedule(root, graph);
+    const certificate = buildTriWikiSlaCertificate({
+        graph,
+        slaMs,
+        estimatedCriticalPathMs: schedule.critical_path_ms,
+        estimatedSequentialMs: schedule.sequential_ms,
+        blockers: [...schedule.blockers]
+    });
+    return {
+        schema: SLA_SCHEDULER_SCHEMA,
+        ok: certificate.ok,
+        graph,
+        certificate,
+        highest_confidence_subset: certificate.ok ? graph.gates : graph.gates.slice(0, Math.max(1, Math.floor(graph.gates.length / 2)))
+    };
+}
+//# sourceMappingURL=sla-scheduler.js.map

package/dist/core/routes.js

@@ -623,6 +623,11 @@ export const COMMAND_CATALOG = [
     { name: 'update-check', usage: 'sks update-check [--json]', description: 'Check npm for the latest Sneakoscope Codex version.' },
     { name: 'wizard', usage: 'sks wizard', description: 'Open an interactive setup UI for install scope, setup, doctor, and verification.' },
     { name: 'commands', usage: 'sks commands [--json]', description: 'List every user-facing command with a short description.' },
+    { name: 'check', usage: 'sks check --tier instant|affected|confidence|release|real-check [--sla 5m] [--changed-since auto] [--json]', description: 'Run build-once proof-bank checks: affected/confidence use incremental build and cached proof reuse; release keeps full clean proof for publish readiness.' },
+    { name: 'task', usage: 'sks task run [--sla 5m] [--json]', description: 'Run the normal affected-scope, release-equivalent task verification path.' },
+    { name: 'release', usage: 'sks release affected|full|background [--json]', description: 'Run affected release proof, full release proof, or background release proof explicitly.' },
+    { name: 'triwiki', usage: 'sks triwiki index|affected|proof-bank [--json]', description: 'Inspect TriWiki module cards, gate impact maps, affected graphs, and proof bank status.' },
+    { name: 'daemon', usage: 'sks daemon status|warm|stop [--json]', description: 'Inspect or warm the local SKS daemon cache state for build/proof reuse.' },
     { name: 'run', usage: 'sks run "task" [--visual|--research|--db] [--json]', description: 'Classify a plain-language task, materialize a mission, and route it through the SKS trust kernel.' },
     { name: 'status', usage: 'sks status [--json]', description: 'Show the active mission, route, phase, proof, trust, native agent, image voxel, DB safety, and next action.' },
     { name: 'usage', usage: `sks usage [${USAGE_TOPICS}]`, description: 'Print copy-ready workflows for common tasks.' },