sneakoscope 4.0.13 → 4.0.14

package/dist/scripts/release-gate-existence-audit.js

@@ -1,111 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, packageScripts, root } from './sks-1-18-gate-lib.js';
-const scripts = packageScripts();
-const releaseManifestPath = path.join(root, 'release-gates.v2.json');
-const releaseManifest = JSON.parse(fs.readFileSync(releaseManifestPath, 'utf8'));
-const releaseGates = Array.isArray(releaseManifest.gates)
-    ? releaseManifest.gates.filter((gate) => Array.isArray(gate.preset) && gate.preset.includes('release'))
-    : [];
-const dagTasks = new Set(releaseGates.map((gate) => gate.id));
-const manifestTasks = new Set((Array.isArray(releaseManifest.gates) ? releaseManifest.gates : []).map((gate) => gate.id));
-const removedRuntime = `${'tm'}ux`;
-const removedLane = `${'warp'}-right-${'lane'}`;
-const removedRuntimeGateRe = new RegExp(`^${removedRuntime}:|^agent:${removedRuntime}-|real-${removedRuntime}|${removedLane}`, 'i');
-const required = [
-    'runtime:no-tmux',
-    'terminal:keyboard-enhancement-safety',
-    'terminal:tui-output-stability',
-    'zellij:layout-valid',
-    'zellij:initial-main-only-blackbox',
-    'zellij:right-column-geometry-proof',
-    'zellij:dynamic-pane-lifecycle',
-    'zellij:lane-renderer',
-    'zellij:doctor-readiness',
-    'zellij:spawn-on-demand-layout',
-    'zellij:worker-pane-manager',
-    'zellij:worker-pane-manager-single-owner',
-    'zellij:slot-only-ui',
-    'zellij:compact-slot-renderer',
-    'zellij:right-column-headless-overflow',
-    'safety:mutation-callsite-coverage',
-    'mad-sks:zellij-launch',
-    'mad-sks:zellij-default-pane-worker',
-    'agent:zellij-runtime',
-    'agent:slot-pane-binding-proof',
-    'agent:role-config-repair',
-    'agent:worker-pane-communication-contract',
-    'git:worktree-integration-primary',
-    'git:worktree-integration-primary-runtime',
-    'codex:0.137-compat',
-    'doctor:codex-doctor-parity',
-    'codex:permission-profiles',
-    'codex:legacy-profile-consumers-removed',
-    'codex:resume-cwd-truth',
-    'mcp:tool-naming-parity',
-    'responses:retry-policy-centralized',
-    'codex-app:fast-ui-preservation',
-    'codex-app:ui-clobber-guard',
-    'doctor:fixes-codex-app-fast-ui',
-    'mad-sks:app-ui-no-mutation',
-    'provider:badge-context',
-    'provider:context-config-toml',
-    'codex-app:provider-badge',
-    'runtime:no-mjs-scripts',
-    'runtime:ts-python-boundary',
-    'agent:patch-swarm-runtime-truth',
-    'agent:patch-transaction-journal',
-    'agent:patch-conflict-rebase',
-    'agent:strategy-to-patch-strict',
-    'agent:rollback-command',
-    'agent:native-cli-session-swarm',
-    'agent:native-cli-session-swarm-10',
-    'agent:native-cli-session-swarm-20',
-    'agent:no-subagent-scaling',
-    'agent:official-subagent-helper-policy',
-    'agent:native-cli-session-proof',
-    'agent:fast-mode-default',
-    'agent:fast-mode-worker-propagation',
-    'codex:fast-mode-profile-propagation',
-    'mad-sks:fast-mode-propagation',
-    'naruto:active-pool',
-    'naruto:real-active-pool',
-    'naruto:real-active-pool-runtime',
-    'naruto:extreme-parallelism',
-    'naruto:extreme-parallelism-real',
-    'naruto:zellij-dynamic-right-column',
-    'agent:wiki-context-proof',
-    'shared-memory:check',
-    'wrongness:check',
-    'wrongness:fixtures',
-    'trust:check',
-    'git-collaboration:e2e'
-];
-assertGate(releaseManifest.schema === 'sks.release-gates.v2', 'release gate manifest schema mismatch', { schema: releaseManifest.schema });
-const releaseCheck = String(scripts['release:check'] || '');
-const releaseCheckTarget = releaseCheck.includes('release:check:affected')
-    ? String(scripts['release:check:affected'] || '')
-    : releaseCheck;
-assertGate(releaseCheckTarget.includes('release-gate-dag-runner') && /--preset\s+(?:release|affected)/.test(releaseCheckTarget), 'release:check must use the v2 DAG release/affected preset', { release_check: scripts['release:check'], resolved_release_check: releaseCheckTarget });
-assertGate(releaseGates.length > 0, 'release v2 manifest must include release preset gates', { gate_count: releaseGates.length });
-for (const name of required) {
-    assertGate(Boolean(scripts[name]), `missing release gate script: ${name}`, { required });
-    const inReleaseManifest = manifestTasks.has(name);
-    assertGate(inReleaseManifest, `critical gate missing from release v2 manifest: ${name}`, { name, release_gates: [...dagTasks].sort(), manifest_gates: [...manifestTasks].sort() });
-    const match = String(scripts[name]).match(/node\s+(\.\/dist\/scripts\/[^ ]+\.js)/);
-    if (match)
-        assertGate(fs.existsSync(path.join(root, match[1])), `script target missing for ${name}`, { command: scripts[name] });
-}
-for (const name of dagTasks) {
-    if (name === 'build')
-        continue;
-    assertGate(Boolean(scripts[name]), `release DAG task has no package script: ${name}`, { name });
-    assertGate(!removedRuntimeGateRe.test(name), `tmux gate remains in release DAG: ${name}`, { name });
-}
-for (const name of Object.keys(scripts)) {
-    assertGate(!removedRuntimeGateRe.test(name), `tmux package gate remains: ${name}`, { name });
-}
-emitGate('release:gate-existence-audit', { gates: required.length, dag_tasks: dagTasks.size, manifest: 'release-gates.v2.json' });
-//# sourceMappingURL=release-gate-existence-audit.js.map

package/dist/scripts/release-gate-planner.js

@@ -1,34 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-// Gate: release:gate-planner
-// Builds the release gate manifest (release-gates.json) from the live release-gate
-// set (DAG task ids + release:check chain) and validates manifest <-> release parity:
-//  - every release gate is in the manifest,
-//  - every manifest entry maps to a real package.json script.
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const { buildGateManifest, validateManifestParity } = await importDist('core/release/gate-manifest.js');
-const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const scripts = pkg.scripts || {};
-const dagSource = fs.readFileSync(path.join(root, 'src/scripts/release-parallel-check.ts'), 'utf8');
-// Release gate ids = DAG task ids + gates referenced in the release:check chain.
-const dagIds = [...dagSource.matchAll(/task\('([^']+)'/g)].map((m) => m[1]);
-const releaseCheckIds = [...String(scripts['release:check'] || '').matchAll(/npm run ([^\s&]+)/g)].map((m) => m[1]);
-const releaseGateIds = [...new Set([...dagIds, ...releaseCheckIds])]
-    .filter((id) => id && id !== 'build' && id !== 'release:check:parallel');
-const manifest = buildGateManifest(releaseGateIds);
-// Every manifest entry must map to a real package.json script.
-for (const entry of manifest.gates) {
-    assertGate(Boolean(scripts[entry.id]), `gate in manifest without package script: ${entry.id}`, { id: entry.id });
-}
-// Every package script that is a release gate must be in the manifest, and vice versa.
-const parity = validateManifestParity(manifest.gates.map((g) => g.id), releaseGateIds);
-assertGate(parity.ok, 'gate manifest <-> release-gate parity failed', parity);
-const manifestPath = path.join(root, 'release-gates.json');
-fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
-const reportDir = path.join(root, '.sneakoscope', 'reports');
-fs.mkdirSync(reportDir, { recursive: true });
-fs.writeFileSync(path.join(reportDir, 'release-gate-plan.json'), `${JSON.stringify({ schema: 'sks.release-gate-plan.v1', ok: true, gate_count: manifest.gates.length, p0: manifest.gates.filter((g) => g.tier === 'P0').length, required_for_publish: manifest.gates.filter((g) => g.required_for_publish).length }, null, 2)}\n`);
-emitGate('release:gate-planner', { gates: manifest.gates.length, manifest: 'release-gates.json' });
-//# sourceMappingURL=release-gate-planner.js.map

package/dist/scripts/release-gate-worker.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-const command = process.argv.slice(2).join(' ');
-if (!command) {
-    console.error('usage: release-gate-worker <command>');
-    process.exit(2);
-}
-const result = spawnSync(command, { shell: true, stdio: 'inherit', env: process.env });
-process.exit(result.status ?? 1);
-//# sourceMappingURL=release-gate-worker.js.map

package/dist/scripts/release-speed-summary.js

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const reports = path.join(root, '.sneakoscope', 'reports', 'release-gates');
-const runs = fs.existsSync(reports)
-    ? fs.readdirSync(reports).map((name) => path.join(reports, name, 'summary.json')).filter((file) => fs.existsSync(file))
-    : [];
-const latest = runs.sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs)[0];
-const summary = latest ? JSON.parse(fs.readFileSync(latest, 'utf8')) : null;
-const certificatePath = latest ? path.join(path.dirname(latest), 'completion-certificate.json') : null;
-const certificate = certificatePath && fs.existsSync(certificatePath) ? JSON.parse(fs.readFileSync(certificatePath, 'utf8')) : summary?.completion_certificate || null;
-const affectedGraphPath = latest ? path.join(path.dirname(latest), 'affected-gate-graph.json') : null;
-const mode = summary?.affected_selection?.mode || summary?.selected_preset || (summary?.full === true ? 'full' : 'unknown');
-const affectedMode = mode === 'affected';
-const latestRuntimeProof = latestRuntimeProofSummaryPath();
-console.log(JSON.stringify({
-    schema: 'sks.release-speed-summary.v1',
-    ok: true,
-    report: latest || null,
-    mode,
-    affected_mode: affectedMode,
-    affected_mode_warning: affectedMode ? 'Affected mode: true. This is not a full publish gate. Run npm run release:check:full before publishing.' : null,
-    selected_gates: summary?.selected_gates || 0,
-    selected_gate_ids: summary?.selected_gate_ids || [],
-    skipped_by_affected: summary?.skipped_by_affected?.length || 0,
-    skipped_gate_ids: summary?.skipped_by_affected || [],
-    cached: summary?.cached || 0,
-    cached_gates: summary?.cached_gates || [],
-    proof_bank_file: certificate?.proof_bank_file || path.join(root, '.sneakoscope', 'proof-bank', 'gates', 'cache-v2.json'),
-    completion_certificate: certificate,
-    affected_graph_file: affectedGraphPath && fs.existsSync(affectedGraphPath) ? affectedGraphPath : null,
-    reused_proofs: certificate?.reused_proofs || summary?.cached || 0,
-    newly_executed_gates: certificate?.newly_executed_gates || summary?.executed_gates?.length || 0,
-    five_minute_sla_met: certificate?.sla_met ?? null,
-    version_neutralized_inputs: [
-        'package.json:version',
-        'package-lock.json:root.version',
-        'src/core/version.ts:PACKAGE_VERSION',
-        'src/core/fsx.ts:PACKAGE_VERSION',
-        'src/bin/sks.ts:FAST_PACKAGE_VERSION',
-        'dist/build-manifest.json:version'
-    ],
-    behavior_affecting_inputs: [],
-    cache_key_policy: 'version-neutral-safe-v1',
-    cache_message: 'Release cache: version-only changes neutralized for behavior gates. Version correctness gates still ran uncached.',
-    executed: summary?.executed_gates?.length || 0,
-    executed_gates: summary?.executed_gates || [],
-    wall_ms: summary?.wall_ms || 0,
-    cpu_time_saved_ms: summary?.cpu_time_saved_ms || 0,
-    parallelism_gain: summary?.parallelism_gain || 0,
-    max_running: summary?.peak_running || summary?.max_running || 0,
-    slowest_gates: summary?.slowest_gates || [],
-    proof_file_path: latestRuntimeProof
-}, null, 2));
-function latestRuntimeProofSummaryPath() {
-    const missions = path.join(root, '.sneakoscope', 'missions');
-    if (!fs.existsSync(missions))
-        return null;
-    const files = fs.readdirSync(missions)
-        .map((name) => path.join(missions, name, 'agents', 'runtime-proof-summary.json'))
-        .filter((file) => fs.existsSync(file))
-        .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
-    return files[0] || null;
-}
-//# sourceMappingURL=release-speed-summary.js.map

package/dist/scripts/repo-audit.js

@@ -1,83 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-const riskyPathPatterns = [
-    /(^|\/)\.env(\..*)?$/,
-    /(^|\/)\.npmrc$/,
-    /(^|\/)\.pypirc$/,
-    /(^|\/)\.netrc$/,
-    /(^|\/)\.envrc$/,
-    /(^|\/)id_(rsa|dsa|ecdsa|ed25519)$/,
-    /(^|\/)(\.mcp\.json|mcp\.json|claude_desktop_config\.json)$/,
-    /(^|\/)(\.codex|\.agents|\.sneakoscope|\.dcodex|\.omx|\.cursor|\.windsurf)(\/|$)/,
-    /(^|\/)(\.aws|\.azure)(\/|$)/,
-    /\.(pem|key|p12|pfx|crt|cer|asc|kubeconfig|db|sqlite|sqlite3|dump|bak|backup|sql\.gz)$/i
-];
-const allowedSneakoscopeSharedPathPatterns = [
-    /^\.sneakoscope\/git-policy\.json$/,
-    /^\.sneakoscope\/shared-memory-manifest\.json$/,
-    /^\.sneakoscope\/wiki\/project-policy\.json$/,
-    /^\.sneakoscope\/wiki\/records\/claims\/[^/]+\.json$/,
-    /^\.sneakoscope\/wiki\/wrongness\/[^/]+\.json$/,
-    /^\.sneakoscope\/wiki\/image-voxels\/[^/]+\/[^/]+\.json$/,
-    /^\.sneakoscope\/wiki\/avoidance-rules\/[^/]+\.json$/,
-    /^\.sneakoscope\/wiki\/summaries\/[^/]+\.md$/
-];
-const secretContentPatterns = [
-    /-----BEGIN (?:RSA |DSA |EC |OPENSSH |PGP )?PRIVATE KEY-----/,
-    /\bnpm_[A-Za-z0-9]{20,}\b/,
-    /\bgh[pousr]_[A-Za-z0-9_]{30,}\b/,
-    /\bsk-[A-Za-z0-9_-]{32,}\b/,
-    /\bAKIA[0-9A-Z]{16}\b/,
-    /\bservice_role\b.{0,80}\beyJ[A-Za-z0-9_-]{20,}/i,
-    /\b(supabase|firebase|stripe|resend|vercel|github|openai)[A-Za-z0-9_-]{0,30}_(?:secret|token|key)\b\s*[:=]\s*['"]?[A-Za-z0-9._-]{20,}/i
-];
-function gitFiles(args) {
-    const out = execFileSync('git', args, { encoding: 'utf8' });
-    return out.split('\0').filter(Boolean);
-}
-function candidateFiles() {
-    return [
-        ...gitFiles(['ls-files', '-z']),
-        ...gitFiles(['ls-files', '--others', '--exclude-standard', '-z'])
-    ];
-}
-function isProbablyBinary(buf) {
-    return buf.includes(0);
-}
-function isAllowedRiskyPath(file) {
-    return allowedSneakoscopeSharedPathPatterns.some((pattern) => pattern.test(file));
-}
-const files = [...new Set(candidateFiles())];
-const findings = [];
-for (const file of files) {
-    if (/^src\/.*\.mjs$/.test(file))
-        findings.push({ file, reason: 'high severity runtime MJS shadow copy' });
-    for (const pattern of riskyPathPatterns) {
-        if (pattern.test(file) && !isAllowedRiskyPath(file))
-            findings.push({ file, reason: 'risky tracked path' });
-    }
-    let buf;
-    try {
-        buf = fs.readFileSync(file);
-    }
-    catch {
-        continue;
-    }
-    if (isProbablyBinary(buf))
-        continue;
-    const text = buf.toString('utf8');
-    for (const pattern of secretContentPatterns) {
-        if (pattern.test(text))
-            findings.push({ file, reason: 'possible secret material' });
-    }
-}
-if (findings.length) {
-    console.error('Repo audit failed. Remove or untrack these before publishing:');
-    for (const f of findings)
-        console.error(`- ${f.file}: ${f.reason}`);
-    process.exit(1);
-}
-console.log(`Repo audit passed: ${files.length} tracked and unignored files checked.`);
-//# sourceMappingURL=repo-audit.js.map

package/dist/scripts/rust-smoke.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { rustCommand } from '../core/commands/rust-command.js';
-await rustCommand(['smoke', '--json', ...process.argv.slice(2)]);
-//# sourceMappingURL=rust-smoke.js.map

package/dist/scripts/sizecheck.js

@@ -1,146 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const limits = {
-    packedBytes: Number(process.env.SKS_MAX_PACK_BYTES || 1536 * 1024),
-    unpackedBytes: Number(process.env.SKS_MAX_UNPACKED_BYTES || 6400 * 1024),
-    packFiles: Number(process.env.SKS_MAX_PACK_FILES || 1200),
-    trackedFileBytes: Number(process.env.SKS_MAX_TRACKED_FILE_BYTES || 384 * 1024)
-};
-const trackedFileSizeAllowlist = new Set([
-    // Historical source documentation export; not included in the npm package payload.
-    'docs/sks-local-llm-mode/exports/sks-local-llm-mode-deck.pdf',
-    // Central release DAG manifest; package footprint limits still apply below.
-    'release-gates.v2.json'
-]);
-const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-function fail(message, detail = '') {
-    console.error(`Size check failed: ${message}`);
-    if (detail)
-        console.error(detail.trim());
-    process.exit(2);
-}
-function fmt(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KiB`;
-    return `${(bytes / 1024 / 1024).toFixed(2)} MiB`;
-}
-function run(cmd, args, options = {}) {
-    return spawnSync(cmd, args, {
-        cwd: root,
-        encoding: 'utf8',
-        ...options
-    });
-}
-function checkTrackedFiles() {
-    const result = run('git', ['ls-files', '-z'], { encoding: 'buffer' });
-    if (result.status !== 0)
-        fail('unable to list tracked files', result.stderr?.toString('utf8') || '');
-    const files = result.stdout.toString('utf8').split('\0').filter(Boolean);
-    const oversized = [];
-    for (const file of files) {
-        if (trackedFileSizeAllowlist.has(file))
-            continue;
-        let stat;
-        try {
-            stat = fs.statSync(path.join(root, file));
-        }
-        catch (err) {
-            if (err?.code === 'ENOENT')
-                continue;
-            throw err;
-        }
-        if (stat.size > limits.trackedFileBytes)
-            oversized.push(`${file} (${fmt(stat.size)})`);
-    }
-    if (oversized.length) {
-        fail(`tracked file exceeds ${fmt(limits.trackedFileBytes)}`, oversized.join('\n'));
-    }
-}
-function checkVersionSync() {
-    const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-    const lock = JSON.parse(fs.readFileSync(path.join(root, 'package-lock.json'), 'utf8'));
-    const source = fs.readFileSync(path.join(root, 'src', 'core', 'version.ts'), 'utf8');
-    const fsx = fs.readFileSync(path.join(root, 'src', 'core', 'fsx.ts'), 'utf8');
-    const tsBin = fs.readFileSync(path.join(root, 'src', 'bin', 'sks.ts'), 'utf8');
-    const cargoToml = fs.readFileSync(path.join(root, 'crates', 'sks-core', 'Cargo.toml'), 'utf8');
-    const cargoLock = fs.readFileSync(path.join(root, 'crates', 'sks-core', 'Cargo.lock'), 'utf8');
-    const cargoMain = fs.readFileSync(path.join(root, 'crates', 'sks-core', 'src', 'main.rs'), 'utf8');
-    const sourceVersion = source.match(/export const PACKAGE_VERSION = ['"]([^'"]+)['"];/)?.[1];
-    const fsxVersion = fsx.match(/export const PACKAGE_VERSION = ['"]([^'"]+)['"];/)?.[1];
-    const tsBinVersion = tsBin.match(/const FAST_PACKAGE_VERSION = ['"]([^'"]+)['"];/)?.[1];
-    const cargoTomlVersion = cargoToml.match(/^version = "([^"]+)"/m)?.[1];
-    const cargoLockVersion = cargoLock.match(/\[\[package\]\]\nname = "sks-core"\nversion = "([^"]+)"/)?.[1];
-    const cargoMainVersion = cargoMain.match(/println!\("sks-rs ([^"]+)"\)/)?.[1];
-    const lockRootVersion = lock.packages?.['']?.version;
-    const mismatches = [
-        ['package-lock.json version', lock.version],
-        ['package-lock root package version', lockRootVersion],
-        ['src/core/version.ts PACKAGE_VERSION', sourceVersion],
-        ['src/core/fsx.ts PACKAGE_VERSION', fsxVersion],
-        ['src/bin/sks.ts FAST_PACKAGE_VERSION', tsBinVersion],
-        ['crates/sks-core/Cargo.toml version', cargoTomlVersion],
-        ['crates/sks-core/Cargo.lock sks-core version', cargoLockVersion],
-        ['crates/sks-core/src/main.rs sks-rs version', cargoMainVersion]
-    ].filter(([, version]) => version !== pkg.version);
-    if (mismatches.length) {
-        fail('package version metadata is not synchronized', [
-            `package.json version: ${pkg.version}`,
-            ...mismatches.map(([label, version]) => `${label}: ${version || 'missing'}`)
-        ].join('\n'));
-    }
-}
-function checkPackageFootprint() {
-    const env = {
-        ...process.env,
-        npm_config_cache: process.env.SKS_SIZECHECK_NPM_CACHE || path.join(os.tmpdir(), 'sneakoscope-npm-cache')
-    };
-    const result = run(npmBin, ['pack', '--dry-run', '--json', '--ignore-scripts'], { env });
-    if (result.status !== 0)
-        fail('npm pack dry-run failed', `${result.stdout || ''}\n${result.stderr || ''}`);
-    let info;
-    try {
-        info = JSON.parse(result.stdout)[0];
-    }
-    catch {
-        fail('npm pack dry-run returned non-json output', result.stdout || '');
-    }
-    if (!info)
-        fail('npm pack dry-run returned no package metadata');
-    const forbiddenPatterns = [
-        /^\.agents\//,
-        /^\.codex\//,
-        /^\.dcodex\//,
-        /^\.omx\//,
-        /^\.sneakoscope\//,
-        /^native\//,
-        /^node_modules\//,
-        /^scripts\//,
-        /^tmp\//,
-        /^logs\//,
-        /\.(tgz|zip|tar|tar\.gz|log)$/i
-    ];
-    const forbidden = (info.files || [])
-        .map((file) => file.path)
-        .filter((file) => forbiddenPatterns.some((pattern) => pattern.test(file)));
-    if (forbidden.length)
-        fail('npm package includes forbidden files', forbidden.join('\n'));
-    if (info.size > limits.packedBytes)
-        fail(`npm tarball exceeds ${fmt(limits.packedBytes)}`, `${info.filename}: ${fmt(info.size)}`);
-    if (info.unpackedSize > limits.unpackedBytes)
-        fail(`npm unpacked size exceeds ${fmt(limits.unpackedBytes)}`, `${info.filename}: ${fmt(info.unpackedSize)}`);
-    if (info.entryCount > limits.packFiles)
-        fail(`npm package file count exceeds ${limits.packFiles}`, `${info.entryCount} files`);
-    console.log(`Size check passed: ${fmt(info.size)} packed, ${fmt(info.unpackedSize)} unpacked, ${info.entryCount} files.`);
-}
-checkTrackedFiles();
-checkVersionSync();
-checkPackageFootprint();
-//# sourceMappingURL=sizecheck.js.map

package/dist/scripts/sks-1-11-gate-lib.js

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-export const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-export function assertGate(condition, message, detail = {}) {
-    if (condition)
-        return;
-    console.error(JSON.stringify({ ok: false, message, detail }, null, 2));
-    process.exit(1);
-}
-export function emitGate(name, detail = {}) {
-    console.log(JSON.stringify({ schema: 'sks.release-gate.v1', ok: true, gate: name, ...detail }, null, 2));
-}
-export function runSksJson(args) {
-    const entrypoint = path.join(root, 'dist', 'bin', 'sks.js');
-    assertGate(fs.existsSync(entrypoint), 'dist entrypoint missing; run npm run build first', { entrypoint });
-    const result = spawnSync(process.execPath, [entrypoint, ...args], {
-        cwd: root,
-        encoding: 'utf8',
-        timeout: Number(process.env.SKS_GATE_TIMEOUT_MS || 120_000),
-        env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' }
-    });
-    if (result.status !== 0) {
-        assertGate(false, 'sks command failed', { args, status: result.status, stdout: result.stdout, stderr: result.stderr });
-    }
-    try {
-        return JSON.parse(result.stdout);
-    }
-    catch (err) {
-        assertGate(false, 'sks command did not emit parseable JSON', { args, stdout: result.stdout, error: err.message });
-    }
-}
-export function runPptReview(action = 'review') {
-    const json = runSksJson(['ppt', 'fixture', '--mock', '--json']);
-    const proof = readMissionJson(json.mission_id, 'completion-proof.json');
-    const review = json.artifacts || json.imagegen_review || {};
-    json.proof_evidence = proof.evidence?.ppt_review || json.artifacts?.proof_evidence || {};
-    json.artifacts = {
-        ...review,
-        callouts: {
-            ...(review.slide_callout_ledger || {}),
-            no_text_fallback: review.slide_callout_ledger?.text_only_fallback_allowed === false || review.slide_callout_ledger?.generated_slide_callout_images_count > 0
-        },
-        slideIssues: review.slide_issue_ledger || {}
-    };
-    assertGate(json.ok === true, 'ppt imagegen review fixture blocked', json);
-    assertGate(json.proof_evidence?.generated_slide_callout_images_count > 0, 'ppt callout image evidence missing', json.proof_evidence);
-    assertGate(json.proof_evidence?.slide_issue_extraction_status === 'valid', 'ppt issue extraction missing', json.proof_evidence);
-    return json;
-}
-export function runDfixFixture() {
-    const json = runSksJson(['dfix', 'fixture', '--json']);
-    json.gate = json.gate || json.artifacts?.gate;
-    assertGate(json.ok === true, 'dfix fixture blocked', json);
-    assertGate(json.gate?.passed === true, 'dfix gate did not pass', json.gate);
-    return json;
-}
-export function runUxFixture() {
-    const json = runSksJson(['image-ux-review', 'fixture', '--mock', '--json']);
-    assertGate(json.ok === true, 'image UX review fixture blocked', json);
-    return json;
-}
-export function missionFile(missionId, file) {
-    return path.join(root, '.sneakoscope', 'missions', missionId, file);
-}
-export function readMissionJson(missionId, file) {
-    const absolute = missionFile(missionId, file);
-    assertGate(fs.existsSync(absolute), `mission artifact missing: ${file}`, { mission_id: missionId, absolute });
-    return JSON.parse(fs.readFileSync(absolute, 'utf8'));
-}
-export function hasRelationType(missionId, type) {
-    const ledger = readMissionJson(missionId, 'image-voxel-ledger.json');
-    return (ledger.relations || []).some((relation) => relation.type === type);
-}
-//# sourceMappingURL=sks-1-11-gate-lib.js.map

package/dist/scripts/sks-1-18-gate-lib.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-export const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-export function assertGate(condition, message, detail = {}) {
-    if (condition)
-        return;
-    console.error(JSON.stringify({ ok: false, message, detail }, null, 2));
-    process.exit(1);
-}
-export function emitGate(name, detail = {}) {
-    console.log(JSON.stringify({ schema: 'sks.release-gate.v1', ok: true, gate: name, ...detail }, null, 2));
-}
-export function readText(rel) {
-    return fs.readFileSync(path.join(root, rel), 'utf8');
-}
-export function readJson(rel) {
-    return JSON.parse(readText(rel));
-}
-export function exists(rel) {
-    return fs.existsSync(path.join(root, rel));
-}
-export async function importDist(rel) {
-    const absolute = path.join(root, 'dist', rel);
-    assertGate(fs.existsSync(absolute), `dist module missing: ${rel}`, { hint: 'run npm run build first' });
-    return import(pathToFileURL(absolute).href);
-}
-export function packageScripts() {
-    return readJson('package.json').scripts || {};
-}
-export function scriptContains(name, token) {
-    return String(packageScripts()[name] || '').includes(token);
-}
-export function assertFiles(files) {
-    for (const file of files)
-        assertGate(exists(file), `missing required file: ${file}`);
-}
-export const SOURCE_INTELLIGENCE_FILES = [
-    'src/core/source-intelligence/source-intelligence-policy.ts',
-    'src/core/source-intelligence/source-intelligence-runner.ts',
-    'src/core/source-intelligence/source-intelligence-proof.ts',
-    'src/core/mcp/xai-mcp-detector.ts',
-    'src/core/mcp/xai-search-adapter.ts',
-    'src/core/codex/codex-web-search-adapter.ts'
-];
-export const AGENT_118_FILES = [
-    'src/core/agents/scout-policy.ts',
-    'src/core/agents/agent-terminal-session.ts',
-    'src/core/agents/zellij-right-lane-cockpit.ts',
-    'src/core/agents/agent-runner-zellij.ts',
-    'src/core/codex/official-goal-mode.ts'
-];
-//# sourceMappingURL=sks-1-18-gate-lib.js.map

package/dist/scripts/tmux-removal-inventory.js

@@ -1,36 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { root } from './lib/ensure-dist-fresh.js';
-const matches = [];
-for (const dir of ['src', 'scripts', 'docs', 'README.md', 'CHANGELOG.md', 'package.json']) {
-    for (const file of await listFiles(path.join(root, dir))) {
-        const text = await fs.readFile(file, 'utf8').catch(() => '');
-        if (/tmux/i.test(text))
-            matches.push(path.relative(root, file));
-    }
-}
-const report = { schema: 'sks.tmux-removal-inventory.v1', ok: true, generated_at: new Date().toISOString(), match_files: [...new Set(matches)].sort(), migration_note: 'Runtime paths moved to Zellij; remaining tmux mentions are historical docs, migration notices, or removal gates.' };
-await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-await fs.writeFile(path.join(root, '.sneakoscope', 'reports', 'tmux-removal-inventory.json'), `${JSON.stringify(report, null, 2)}\n`);
-console.log(JSON.stringify(report, null, 2));
-async function listFiles(target) {
-    const stat = await fs.stat(target).catch(() => null);
-    if (!stat)
-        return [];
-    if (stat.isFile())
-        return [target];
-    const out = [];
-    for (const entry of await fs.readdir(target, { withFileTypes: true })) {
-        if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name === '.git')
-            continue;
-        const file = path.join(target, entry.name);
-        if (entry.isDirectory())
-            out.push(...await listFiles(file));
-        else if (entry.isFile())
-            out.push(file);
-    }
-    return out;
-}
-//# sourceMappingURL=tmux-removal-inventory.js.map