sneakoscope 5.7.0 → 5.9.0

package/dist/core/trust-kernel/trust-report.js

@@ -149,8 +149,8 @@ function sourceIntelligenceTrust(proof = {}) {
     const issues = [...proofBlockers];
     if (evidence.policy?.context7?.required === true && evidence.context7?.ok !== true)
         issues.push('context7_missing');
-    if (evidence.policy?.codex_web_search?.required === true && evidence.ultra_search?.proof?.provider_independent !== true)
-        issues.push('ultra_search_provider_independent_proof_missing');
+    if (evidence.policy?.codex_web_search?.required === true && evidence.super_search?.proof?.provider_independent !== true)
+        issues.push('super_search_provider_independent_proof_missing');
     return {
         issues: [...new Set(issues.map(String))],
         summary: {
@@ -160,7 +160,7 @@ function sourceIntelligenceTrust(proof = {}) {
             mode: evidence.mode || evidence.policy?.mode || 'unknown',
             context7_status: evidence.context7?.status || 'unknown',
             codex_web_status: evidence.codex_web_search?.status || 'not_required',
-            ultra_search_status: evidence.ultra_search?.proof?.ok === true ? 'verified' : evidence.ultra_search ? 'partial' : 'not_required',
+            super_search_status: evidence.super_search?.proof?.ok === true ? 'verified' : evidence.super_search ? 'partial' : 'not_required',
             providers_completed: evidence.parallel?.providers_completed || [],
             blockers: proofBlockers
         }

package/dist/core/verification/real-evidence-policy.js

@@ -0,0 +1,55 @@
+export function evaluateRealEvidencePolicy(input) {
+    const productionMode = input.productionMode !== false;
+    const sources = Array.isArray(input.sources) ? input.sources : [];
+    const claims = Array.isArray(input.claims) ? input.claims : [];
+    const blockers = [];
+    const warnings = [];
+    const verifiedSources = sources.filter((source) => source?.acquisition_verdict === 'verified_content');
+    const sourceIds = new Set(sources.map((source) => String(source?.source_id || '')).filter(Boolean));
+    if (!sources.length)
+        blockers.push('source_acquisition_unavailable');
+    if (productionMode && sources.some((source) => sourceLooksMockOrFixture(source)))
+        blockers.push('production_source_fixture_or_mock');
+    if (productionMode && input.proof?.mock_only === true)
+        blockers.push('production_proof_mock_only');
+    if (Number(input.proof?.verified_source_count || 0) > 0 && verifiedSources.length === 0)
+        blockers.push('verified_source_count_without_verified_sources');
+    if (input.mode === 'url_acquisition' && !sources.some((source) => source?.canonical_url || source?.original_url))
+        blockers.push('missing_url_for_super_search_fetch');
+    if (sources.length && verifiedSources.length === 0)
+        blockers.push('verified_source_evidence_missing');
+    for (const claim of claims) {
+        const status = String(claim?.status || '');
+        if (status !== 'supported' && status !== 'verified')
+            continue;
+        const claimSourceIds = Array.isArray(claim?.source_ids) ? claim.source_ids.map(String).filter(Boolean) : [];
+        if (!claimSourceIds.length) {
+            blockers.push('supported_claim_without_sources');
+            continue;
+        }
+        if (claimSourceIds.some((id) => !sourceIds.has(id)))
+            blockers.push('supported_claim_missing_source_artifact');
+        const verifiedClaimSources = sources.filter((source) => claimSourceIds.includes(String(source?.source_id || '')) && source?.acquisition_verdict === 'verified_content');
+        if (!verifiedClaimSources.length)
+            blockers.push('supported_claim_without_verified_source');
+    }
+    return {
+        schema: 'sks.real-evidence-policy.v1',
+        ok: blockers.length === 0,
+        blockers: [...new Set(blockers)],
+        warnings: [...new Set(warnings)]
+    };
+}
+function sourceLooksMockOrFixture(source) {
+    const text = [
+        source?.provider_id,
+        source?.source_family,
+        source?.source_type,
+        source?.title,
+        source?.content_artifact,
+        ...(Array.isArray(source?.acquisition_path) ? source.acquisition_path : []),
+        ...(Array.isArray(source?.warnings) ? source.warnings : [])
+    ].join(' ');
+    return source?.local_only_raw === true || /\b(mock|fixture|fake|stub|synthetic)\b/i.test(text);
+}
+//# sourceMappingURL=real-evidence-policy.js.map

package/dist/core/version.js

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

package/dist/scripts/agent-fast-mode-default-check.js

@@ -22,7 +22,16 @@ function run(extra = []) {
         '2',
         '--json',
         ...extra
-    ], { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 }));
+    ], {
+        cwd: root,
+        encoding: 'utf8',
+        env: {
+            ...process.env,
+            SKS_TEST_ISOLATION: '1',
+            SKS_RELEASE_FIXTURE_ACTIVE_ROUTE_BYPASS: '1'
+        },
+        maxBuffer: 32 * 1024 * 1024
+    }));
 }
 const defaultRun = run();
 const fastRun = run(['--fast']);

package/dist/scripts/agent-visual-consistency-check.js

@@ -2,7 +2,7 @@
 // @ts-nocheck
 import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
 const cockpit = readText('src/core/agents/agent-codex-cockpit.ts');
-for (const token of ['source_intelligence_status', 'ultra_search_status', 'codex_web_search_status', 'goal_mode_status', 'terminal_session_status', 'zellij_attach_command']) {
+for (const token of ['source_intelligence_status', 'super_search_status', 'codex_web_search_status', 'goal_mode_status', 'terminal_session_status', 'zellij_attach_command']) {
     assertGate(cockpit.includes(token), `Codex App cockpit missing ${token}`);
 }
 emitGate('agent:visual-consistency', { dashboard_fields: 6 });

package/dist/scripts/check-architecture.js

@@ -8,7 +8,6 @@ const waivers = loadWaivers();
 const changedFiles = changedFileSet();
 runGate('pipeline-budget:check');
 runGate('pipeline-runtime:check');
-checkFacade('src/core/pipeline-runtime.ts', 300);
 checkLargeFiles();
 checkTsImports();
 checkDistRuntime();

package/dist/scripts/competitor-scorecard-check.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { generateCompetitorScorecard } from '../core/quality/competitor-scorecard.js';
+import { readJson, writeJsonAtomic } from '../core/fsx.js';
+const root = process.env.SKS_REPO_ROOT
+    ? path.resolve(process.env.SKS_REPO_ROOT)
+    : path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const baselinePath = process.env.SKS_COMPETITOR_SCORECARD_BASELINE
+    ? path.resolve(process.env.SKS_COMPETITOR_SCORECARD_BASELINE)
+    : path.join(root, 'config', 'competitor-scorecard-baseline.json');
+const reportPath = process.env.SKS_COMPETITOR_SCORECARD_REPORT
+    ? path.resolve(process.env.SKS_COMPETITOR_SCORECARD_REPORT)
+    : path.join(root, '.sneakoscope', 'reports', 'competitor-scorecard.json');
+const baseline = await readJson(baselinePath);
+const result = await generateCompetitorScorecard(root, baseline);
+await writeJsonAtomic(reportPath, {
+    ...result.scorecard,
+    evidence: result.evidence,
+    ok: result.ok
+});
+console.log(JSON.stringify(result.scorecard, null, 2));
+if (!result.ok)
+    process.exit(1);
+//# sourceMappingURL=competitor-scorecard-check.js.map

package/dist/scripts/doctor-idempotence-check.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const { runDoctorIdempotence } = await importDist('core/doctor/doctor-idempotence.js');
+const report = await runDoctorIdempotence(root);
+assertGate(report.ok, 'doctor_idempotence_failed', report);
+emitGate('doctor:idempotence', { rollback_manifest_exists: report.rollback_manifest_exists });
+//# sourceMappingURL=doctor-idempotence-check.js.map

package/dist/scripts/gate-timing-check.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const { writeGateTiming } = await importDist('core/release/gate-timing.js');
+const report = await writeGateTiming(root);
+assertGate(report.ok, 'release_gate_timing_failed', report);
+emitGate('release:gate-timing', { total_ms: report.total_ms, slowest_gates: report.slowest_gates.slice(0, 3) });
+//# sourceMappingURL=gate-timing-check.js.map

package/dist/scripts/hook-latency-quantum-check.js

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const { runProcess } = await importDist('core/fsx.js');
+const scenarios = [
+    { name: 'no-state', prompt: 'hello', budget_p95_ms: 230 },
+    { name: 'active-route', prompt: 'continue current route', budget_p95_ms: 230, state: { mission_id: 'M-active', mode: 'TEAM', route: 'Team', route_command: '$Team', phase: 'EXECUTE', implementation_allowed: true } },
+    { name: 'stale-code-pack-note', prompt: 'status?', budget_p95_ms: 230, files: { '.sneakoscope/wiki/code-pack.json': JSON.stringify({ generated_at: '2000-01-01T00:00:00.000Z' }) } },
+    { name: 'no-question-queue', prompt: 'can I interrupt?', budget_p95_ms: 230, state: { mission_id: 'M-noq', mode: 'RESEARCH', phase: 'RESEARCH_RUNNING_NO_QUESTIONS' } },
+    { name: 'clarification-awaiting', prompt: 'here is the answer', budget_p95_ms: 230, state: { mission_id: 'M-clarify', mode: 'TEAM', phase: 'CLARIFICATION_AWAITING_ANSWERS', stop_gate: 'clarification-gate', ambiguity_gate_required: true, clarification_required: true, implementation_allowed: false } },
+    { name: 'super-search-prompt', prompt: '$Super-Search run "npm release notes"', budget_p95_ms: 420 },
+    { name: 'question-shaped-work-request', prompt: 'Can you fix the failing tests?', budget_p95_ms: 420 }
+];
+const warmups = Number(process.env.SKS_HOOK_LATENCY_WARMUPS || 2);
+const runs = Number(process.env.SKS_HOOK_LATENCY_RUNS || 15);
+const report = await runHookScenarios();
+const out = path.join(root, '.sneakoscope', 'reports', 'hook-latency-quantum.json');
+fs.mkdirSync(path.dirname(out), { recursive: true });
+fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+assertGate(report.ok, 'hook_latency_quantum_failed', report);
+emitGate('hook:latency-quantum', { scenarios: report.scenarios.length, report: '.sneakoscope/reports/hook-latency-quantum.json' });
+async function runHookScenarios() {
+    const scenarioResults = [];
+    const blockers = [];
+    for (const scenario of scenarios) {
+        const result = await runOne(scenario);
+        scenarioResults.push(result);
+        if (result.failures.length)
+            blockers.push(`${scenario.name}:process_failed`);
+        if (result.p95_ms > result.budget_p95_ms)
+            blockers.push(`${scenario.name}:p95_budget_exceeded`);
+    }
+    return {
+        schema: 'sks.hook-latency-quantum.v1',
+        ok: blockers.length === 0,
+        generated_at: new Date().toISOString(),
+        warmup_runs: warmups,
+        measure_runs: runs,
+        scenarios: scenarioResults,
+        blockers
+    };
+}
+async function runOne(scenario) {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `sks-hook-${scenario.name}-`));
+    try {
+        seedRoot(tmp, scenario);
+        const durations = [];
+        const failures = [];
+        for (let i = 0; i < warmups + runs; i++) {
+            const phase = i < warmups ? 'warmup' : 'measure';
+            const measured = await timed(tmp, scenario, phase === 'measure' ? i - warmups + 1 : i + 1, phase);
+            if (phase === 'measure')
+                durations.push(measured.duration_ms);
+            if (measured.code !== 0)
+                failures.push(measured);
+        }
+        durations.sort((a, b) => a - b);
+        const p95 = percentile(durations, 0.95);
+        const p50 = percentile(durations, 0.5);
+        return {
+            name: scenario.name,
+            runs,
+            p50_ms: p50,
+            p95_ms: p95,
+            budget_p95_ms: scenario.budget_p95_ms,
+            ok: failures.length === 0 && p95 <= scenario.budget_p95_ms,
+            failures
+        };
+    }
+    finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+}
+async function timed(tmp, scenario, run, phase) {
+    const started = performance.now();
+    const payload = JSON.stringify({ prompt: scenario.prompt, cwd: tmp, conversation_id: `quantum-${scenario.name}` });
+    const res = await runProcess(process.execPath, [path.join(root, 'dist', 'bin', 'sks.js'), 'hook', 'user-prompt-submit'], {
+        cwd: tmp,
+        input: payload,
+        timeoutMs: 10000,
+        maxOutputBytes: 64 * 1024,
+        env: { SKS_DISABLE_NETWORK: '1', SKS_PERF_MEASURE: '1', SKS_DISABLE_UPDATE_CHECK: '1' }
+    });
+    return {
+        run,
+        phase,
+        code: res.code,
+        duration_ms: Math.round(performance.now() - started),
+        stderr_tail: String(res.stderr || '').slice(-4000)
+    };
+}
+function seedRoot(tmp, scenario) {
+    fs.mkdirSync(path.join(tmp, '.sneakoscope', 'state', 'sessions'), { recursive: true });
+    fs.mkdirSync(path.join(tmp, '.sneakoscope', 'missions'), { recursive: true });
+    fs.writeFileSync(path.join(tmp, 'package.json'), '{"name":"hook-latency-fixture","type":"module"}\n');
+    if (scenario.state) {
+        const state = { ...scenario.state, _session_key: 'quantum', updated_at: new Date().toISOString() };
+        fs.writeFileSync(path.join(tmp, '.sneakoscope', 'state', 'current.json'), `${JSON.stringify(state, null, 2)}\n`);
+        const missionId = String(scenario.state.mission_id || '');
+        if (missionId) {
+            const dir = path.join(tmp, '.sneakoscope', 'missions', missionId);
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(path.join(dir, 'mission.json'), `${JSON.stringify({ id: missionId, mode: scenario.state.mode || 'TEAM', created_at: new Date().toISOString() }, null, 2)}\n`);
+        }
+    }
+    for (const [rel, text] of Object.entries(scenario.files || {})) {
+        const file = path.join(tmp, rel);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, `${text}\n`);
+    }
+}
+function percentile(values, pct) {
+    if (!values.length)
+        return 0;
+    const index = Math.min(values.length - 1, Math.max(0, Math.ceil(values.length * pct) - 1));
+    return values[index] || 0;
+}
+//# sourceMappingURL=hook-latency-quantum-check.js.map

package/dist/scripts/installed-package-smoke-check.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const { runInstalledPackageSmoke } = await importDist('core/install/installed-package-smoke.js');
+const report = await runInstalledPackageSmoke(root);
+assertGate(report.ok, 'installed_package_smoke_failed', report);
+emitGate('runtime:installed-smoke', {
+    installed_version: report.installed_version,
+    commands: report.commands.length,
+    tarball: report.tarball
+});
+//# sourceMappingURL=installed-package-smoke-check.js.map

package/dist/scripts/lib/native-cli-session-swarm-check-lib.js

@@ -30,6 +30,8 @@ export function runNativeCliSwarmCheck({ agents, workItems = agents, reportName,
         encoding: 'utf8',
         env: {
             ...process.env,
+            SKS_TEST_ISOLATION: '1',
+            SKS_RELEASE_FIXTURE_ACTIVE_ROUTE_BYPASS: '1',
             ...(backend === 'codex-sdk' ? { SKS_CODEX_SDK_FAKE: '1', NODE_ENV: 'test' } : {})
         },
         maxBuffer: 96 * 1024 * 1024

package/dist/scripts/mutation-callsite-coverage-check.js

@@ -115,6 +115,8 @@ function listScanFiles() {
     const files = [];
     walk(path.join(root, 'src'), (file) => {
         const relative = rel(file);
+        if (isTestSource(relative))
+            return;
         if (relative.startsWith('src/scripts/'))
             return;
         if (file.endsWith('.ts'))
@@ -123,12 +125,17 @@ function listScanFiles() {
     walk(path.join(root, 'src', 'scripts'), (file) => {
         if (!file.endsWith('.ts'))
             return;
+        if (isTestSource(rel(file)))
+            return;
         const base = path.basename(file);
         if (/(install|publish|release|doctor|codex|zellij|migration)/i.test(base))
             files.push(rel(file));
     });
     return files.sort();
 }
+function isTestSource(relative) {
+    return /(^|\/)__tests__\//.test(relative) || /\.test\.ts$/.test(relative);
+}
 function walk(dir, visit) {
     let entries = [];
     try {

package/dist/scripts/package-published-contract-check.js

@@ -1,12 +1,19 @@
 #!/usr/bin/env node
 import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { assertGate, emitGate, readJson, root } from './sks-1-18-gate-lib.js';
 const pkg = readJson('package.json');
 const scripts = pkg.scripts || {};
+const cacheRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-package-published-contract-'));
 const dry = spawnSync('npm', ['pack', '--dry-run', '--json', '--ignore-scripts'], {
     cwd: root,
     encoding: 'utf8',
+    env: {
+        ...process.env,
+        npm_config_cache: path.join(cacheRoot, 'npm-cache')
+    },
     maxBuffer: 16 * 1024 * 1024
 });
 assertGate(dry.status === 0, 'npm pack --dry-run must succeed for package contract check', {

package/dist/scripts/packlist-performance-check.js

@@ -13,9 +13,14 @@ const MAX_UNPACKED = Number(process.env.SKS_MAX_UNPACKED_BYTES || 10 * 1024 * 10
 // research-command.ts, image-ux-review-command.ts, mad-sks-command.ts,
 // sks-menubar.ts) with genuine new production logic, pushing the packed size
 // to ~2306 KiB. 5.7.0 adds doctor/update migration repair coverage and publish
-// contract checks, pushing the packed tarball to ~2345 KiB. Keep a narrow cap
-// rather than giving the package a broad size budget.
-const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || 2350 * 1024);
+// contract checks, pushing the packed tarball to ~2345 KiB. 5.9.0 adds quantum
+// release evidence scripts (installed package smoke, perf budgets, scorecard,
+// Super-Search contracts, and parallel smoke), pushing the packed tarball to
+// ~2354 KiB. Keep a narrow cap rather than giving the package a broad size
+// budget.
+const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || 2365 * 1024);
+const SURFACE_MAX_PACKED = Number(process.env.SKS_PACKAGE_SURFACE_MAX_PACK_BYTES || 25_000_000);
+const SURFACE_MAX_FILES = Number(process.env.SKS_PACKAGE_SURFACE_MAX_FILES || 2500);
 function runNpmPack() {
     const npmCli = process.env.npm_execpath; // set when invoked via `npm run`
     const npmCache = process.env.SKS_RELEASE_NPM_CACHE || path.join(os.tmpdir(), 'sneakoscope-npm-cache');
@@ -62,6 +67,8 @@ assertGate(files.includes('LICENSE'), 'packlist_missing_runtime_entry', { missin
 assertGate(files.some((f) => f.startsWith('schemas/')), 'packlist_missing_runtime_entry', { missing: 'schemas/' });
 const forbidden = files.filter((f) => f.startsWith('test/') ||
     f.startsWith('src/') ||
+    f.includes('/__tests__/') ||
+    f.endsWith('.test.js') ||
     f.startsWith('docs/internal/') ||
     f.endsWith('.map') ||
     f.startsWith('.sneakoscope/') ||
@@ -69,6 +76,8 @@ const forbidden = files.filter((f) => f.startsWith('test/') ||
     f.startsWith('coverage/') ||
     /(^|\/)\.env/.test(f));
 assertGate(forbidden.length === 0, 'packlist_forbidden_files', { forbidden });
+assertGate(info.entryCount <= SURFACE_MAX_FILES, 'package_surface_file_count_over_limit', { entryCount: info.entryCount, max_file_count: SURFACE_MAX_FILES });
+assertGate(info.size <= SURFACE_MAX_PACKED, 'package_surface_tarball_over_limit', { size: info.size, max_tarball_bytes: SURFACE_MAX_PACKED });
 const report = {
     entryCount: info.entryCount,
     size: info.size,
@@ -83,6 +92,25 @@ const report = {
 const out = path.join(root, '.sneakoscope', 'reports', 'packlist-performance.json');
 fs.mkdirSync(path.dirname(out), { recursive: true });
 fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
+const surfaceReport = {
+    schema: 'sks.package-surface-budget.v1',
+    ok: true,
+    generated_at: new Date().toISOString(),
+    max_tarball_bytes: SURFACE_MAX_PACKED,
+    max_file_count: SURFACE_MAX_FILES,
+    actual_tarball_bytes: info.size,
+    actual_file_count: info.entryCount,
+    forbidden_globs: [
+        'dist/**/__tests__/**',
+        'dist/**/*.test.js',
+        '.sneakoscope/**',
+        'src/**',
+        'test/**'
+    ],
+    forbidden_findings: forbidden,
+    blockers: []
+};
+fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'package-surface-budget.json'), `${JSON.stringify(surfaceReport, null, 2)}\n`);
 emitGate('publish:packlist-performance', {
     files: info.entryCount,
     packed_kib: Math.round(info.size / 1024),

package/dist/scripts/parallel-production-smoke-check.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { runParallelProductionSmoke } from '../core/agents/parallel-write-fixture.js';
+const report = await runParallelProductionSmoke({ injectFailure: true });
+const reportPath = path.join(process.cwd(), '.sneakoscope', 'reports', 'parallel-production-smoke.json');
+await fsp.mkdir(path.dirname(reportPath), { recursive: true });
+await fsp.writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`);
+if (!report.ok) {
+    console.error(JSON.stringify({ ok: false, blockers: report.blockers, reportPath }, null, 2));
+    process.exit(1);
+}
+console.log(JSON.stringify({
+    ok: true,
+    reportPath,
+    worker_count: report.worker_count,
+    changed_files: report.changed_files,
+    patch_envelope_count: report.patch_envelope_count,
+    failure_injection: report.failure_injection
+}, null, 2));
+//# sourceMappingURL=parallel-production-smoke-check.js.map

package/dist/scripts/perf-budget-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const config = JSON.parse(fs.readFileSync(path.join(root, 'config/perf-budgets.v1.json'), 'utf8'));
+const { writePerfBudgetReport } = await importDist('core/perf/perf-budget.js');
+const report = await writePerfBudgetReport(root, config.commands || []);
+assertGate(report.ok, 'perf_budget_failed', report);
+emitGate('perf:budgets', {
+    commands: report.commands.length,
+    slowest_p95_ms: Math.max(...report.commands.map((row) => row.p95_ms), 0)
+});
+//# sourceMappingURL=perf-budget-check.js.map

package/dist/scripts/quantum-baseline-report.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { readJson, writeJsonAtomic } from '../core/fsx.js';
+const root = process.env.SKS_REPO_ROOT
+    ? path.resolve(process.env.SKS_REPO_ROOT)
+    : path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const pkg = await readJson(path.join(root, 'package.json'), {});
+const gitHead = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8' });
+const version = pkg.version || 'unknown';
+const reportPath = path.join(root, '.sneakoscope', 'reports', `quantum-baseline-${version}.json`);
+const report = {
+    schema: 'sks.quantum-baseline.v1',
+    package_version: version,
+    git_head: gitHead.status === 0 ? gitHead.stdout.trim() : null,
+    node_version: process.version,
+    platform: `${process.platform}-${process.arch}-${os.release()}`,
+    package_scripts: {
+        test: hasScript('test'),
+        release_check_full: hasScript('release:check:full'),
+        publish_dry: hasScript('publish:dry'),
+        super_search_name_guard: hasScript('super-search:name-guard')
+    },
+    known_competitor_gaps: [
+        'installed_package_smoke_weaker_than_oh_my_codex',
+        'super_search_provider_default_not_guaranteed',
+        'gate_surface_large_without_speed_score',
+        'fresh_parallel_proof_needs_production_smoke'
+    ]
+};
+await writeJsonAtomic(reportPath, report);
+console.log(JSON.stringify(report, null, 2));
+function hasScript(name) {
+    return Boolean(pkg.scripts?.[name]);
+}
+//# sourceMappingURL=quantum-baseline-report.js.map