sneakoscope 7.1.0 → 7.3.0

package/dist/scripts/super-search-offline-contract-check.js

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-import { writeJsonAtomic } from '../core/fsx.js';
-const { runSuperSearch } = await importDist('core/super-search/index.js');
-const missionDir = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-super-search-offline-'));
-const result = await runSuperSearch({
-    missionDir,
-    query: 'offline npm release notes contract',
-    offline: true,
-    env: {}
-});
-const gatePath = path.join(result.artifact_dir, 'super-search-gate.json');
-const gate = JSON.parse(await fs.readFile(gatePath, 'utf8'));
-const supportedClaims = result.claims.filter((claim) => claim.status === 'supported' || claim.status === 'verified');
-const sourceIds = new Set(result.sources.map((source) => source.source_id));
-const sourceLessSupportedClaims = supportedClaims.filter((claim) => !claim.source_ids?.length || claim.source_ids.some((id) => !sourceIds.has(id)));
-assertGate(result.mode === 'offline_cache', 'offline contract must use offline_cache mode', { mode: result.mode });
-assertGate(result.provider_plan.selected_providers.includes('offline_cache'), 'offline contract must select offline cache provider', result.provider_plan);
-assertGate(result.ok === false, 'offline contract without cache must fail closed', { ok: result.ok, blockers: result.blockers });
-assertGate(result.blockers.includes('source_acquisition_unavailable'), 'offline contract must report source acquisition blocker without cache', result.blockers);
-assertGate(sourceLessSupportedClaims.length === 0, 'offline contract must not produce source-less supported claims', { sourceLessSupportedClaims, claims: result.claims });
-assertGate(typeof gate.human_summary === 'string' && gate.human_summary.length > 0, 'blocked gate must include human_summary', gate);
-assertGate(Array.isArray(gate.next_actions) && gate.next_actions.length > 0, 'blocked gate must include next_actions', gate);
-assertGate(Array.isArray(gate.evidence_paths) && gate.evidence_paths.length > 0, 'blocked gate must include evidence_paths', gate);
-await writeJsonAtomic(path.join(root, '.sneakoscope', 'reports', 'super-search-offline-contract.json'), {
-    schema: 'sks.super-search-offline-contract.v1',
-    ok: true,
-    generated_at: new Date().toISOString(),
-    mode: result.mode,
-    blockers: [],
-    expected_blockers: result.blockers,
-    source_less_supported_claims: sourceLessSupportedClaims,
-    evidence_paths: [gatePath]
-});
-emitGate('super-search:offline-contract', {
-    mode: result.mode,
-    runtime_ok: result.ok,
-    blockers: result.blockers,
-    gate: gatePath
-});

package/dist/scripts/update-fastpath-check.js

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const { runSksUpdateCheck, runSksUpdateNow } = await importDist('core/update-check.js');
-const startedCheck = Date.now();
-const check = await runSksUpdateCheck({
-    npmBin: null,
-    env: { SKS_NPM_VIEW_SNEAKOSCOPE_VERSION: '999.0.0' },
-    timeoutMs: 250,
-    maxOutputBytes: 1024
-});
-const checkElapsed = Date.now() - startedCheck;
-assertGate(check.schema === 'sks.update-check.v2', 'update check must return v2 schema', check);
-assertGate(check.latest === '999.0.0', 'update check override must avoid registry dependency', check);
-assertGate(checkElapsed <= 1200, 'update check fast path must stay under 1200ms', { elapsed_ms: checkElapsed });
-const startedDryRun = Date.now();
-const dryRun = await runSksUpdateNow({
-    npmBin: process.execPath,
-    currentVersion: '1.0.0',
-    version: '1.0.1',
-    dryRun: true,
-    env: {},
-    timeoutMs: 250,
-    maxOutputBytes: 1024
-});
-const dryRunElapsed = Date.now() - startedDryRun;
-assertGate(dryRun.status === 'dry_run' && dryRun.install_code === null, 'update dry-run must not install', dryRun);
-assertGate(dryRunElapsed <= 2000, 'update dry-run fast path must stay under 2000ms', { elapsed_ms: dryRunElapsed });
-emitGate('update:fastpath', { check_elapsed_ms: checkElapsed, dry_run_elapsed_ms: dryRunElapsed });

package/dist/scripts/update-preserves-supabase-keys-blackbox.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { assertGate, emitGate, makeTempRoot, writeText } from './sks-3-1-8-check-lib.js';
-import { withSecretPreservationGuard } from '../core/config/config-migration-journal.js';
-const root = await makeTempRoot('sks-update-supabase-');
-const envFile = path.join(root, '.env.local');
-await writeText(envFile, 'NEXT_PUBLIC_SUPABASE_URL=https://example.supabase.co\nNEXT_PUBLIC_SUPABASE_ANON_KEY=update-secret\n');
-await withSecretPreservationGuard(root, 'update-fixture', async () => {
-    await fs.appendFile(envFile, 'SKS_UPDATE_MARKER=1\n', 'utf8');
-});
-const text = await fs.readFile(envFile, 'utf8');
-assertGate(text.includes('update-secret'), 'update fixture must preserve Supabase key value in source file');
-let blocked = false;
-try {
-    await withSecretPreservationGuard(root, 'update-fixture-mutates-secret', async () => {
-        await fs.writeFile(envFile, 'NEXT_PUBLIC_SUPABASE_URL=https://example.supabase.co\nNEXT_PUBLIC_SUPABASE_ANON_KEY=mutated-update-secret\n', 'utf8');
-    });
-}
-catch {
-    blocked = true;
-}
-const restored = await fs.readFile(envFile, 'utf8');
-assertGate(blocked, 'update guard must block Supabase key value mutation');
-assertGate(restored.includes('update-secret') && !restored.includes('mutated-update-secret'), 'update guard must restore Supabase key value after mutation');
-emitGate('update:preserves-supabase-keys');

package/dist/scripts/upgrade-migration-matrix-check.js

@@ -1,351 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-import { seedUpgradeMigrationFixture } from '../core/ops/upgrade-migration-fixtures.js';
-const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-upgrade-migration-matrix-'));
-const projectRoot = path.join(tmp, 'project');
-try {
-    const fixtures = await seedUpgradeMigrationFixture(projectRoot);
-    const safetyBaseline = await captureSafetyBaseline(fixtures);
-    const commands = [
-        ['doctor', '--full', '--json'],
-        ['doctor', '--fix', '--yes', '--json'],
-        ['status', '--json'],
-        ['route', 'status', '--json'],
-        ['super-search', 'sources', 'latest', '--json'],
-        ['seo-geo-optimizer', 'status', 'latest', '--json'],
-        ['gc', 'plan', '--json']
-    ];
-    const repairChecks = commands.slice(0, 2).map((argv) => runCommand(argv));
-    const migrationPostcondition = await inspectRetiredOperationalResidue(fixtures);
-    const checks = [
-        ...repairChecks,
-        ...commands.slice(2).map((argv) => runCommand(argv))
-    ];
-    const safetyPostcondition = await inspectSafetyPostcondition(safetyBaseline);
-    const doctorFix = repairChecks.find((check) => check.command === 'sks doctor --fix --yes --json');
-    const blockers = [
-        ...checks.filter((check) => check.panic).map((check) => `${check.command}:panic`),
-        ...checks.filter((check) => check.json?.ok === true && Array.isArray(check.json?.blockers) && check.json.blockers.length).map((check) => `${check.command}:ok_true_with_blockers`),
-        ...(!doctorFix?.ok ? ['doctor_fix_failed'] : []),
-        ...migrationPostcondition.blockers,
-        ...safetyBaseline.blockers,
-        ...safetyPostcondition.blockers
-    ];
-    const explicitBlocked = checks.filter((check) => check.exit_code !== 0 && check.status === 'blocked');
-    const report = {
-        schema: 'sks.upgrade-migration-matrix.v1',
-        ok: blockers.length === 0,
-        generated_at: new Date().toISOString(),
-        fixture_count: fixtures.length,
-        fixture_labels: fixtures.map((fixture) => fixture.label),
-        commands: checks,
-        explicit_blocked_commands: explicitBlocked.map((check) => check.command),
-        migration_postcondition: migrationPostcondition,
-        safety_postcondition: safetyPostcondition,
-        data_loss_detected: safetyPostcondition.data_loss_detected,
-        user_owned_data_touched: safetyPostcondition.user_owned_data_touched,
-        generated_legacy_cleanup_only: migrationPostcondition.ok && safetyPostcondition.ok,
-        blockers
-    };
-    const reportPath = path.join(root, '.sneakoscope', 'reports', 'upgrade-migration-matrix.json');
-    await fs.mkdir(path.dirname(reportPath), { recursive: true });
-    await fs.writeFile(reportPath, `${JSON.stringify(report, null, 2)}\n`);
-    assertGate(report.ok, 'upgrade migration matrix failed', report);
-    emitGate('upgrade:migration-matrix', { fixture_count: fixtures.length, report: reportPath.replace(`${root}/`, '') });
-}
-finally {
-    await fs.rm(tmp, { recursive: true, force: true }).catch(() => undefined);
-}
-function runCommand(argv) {
-    const result = spawnSync(process.execPath, [path.join(root, 'dist', 'bin', 'sks.js'), ...argv], {
-        cwd: projectRoot,
-        encoding: 'utf8',
-        maxBuffer: 16 * 1024 * 1024,
-        env: { ...process.env, SKS_DISABLE_NETWORK: '1', SKS_DISABLE_UPDATE_CHECK: '1', SKS_NO_QUESTION: '1' }
-    });
-    const json = parseJson(result.stdout);
-    const output = `${result.stdout}\n${result.stderr}`;
-    return {
-        command: `sks ${argv.join(' ')}`,
-        exit_code: result.status,
-        json_contract: Boolean(json),
-        ok: result.status === 0,
-        status: json?.status || (result.status === 0 ? 'passed' : output.includes('blocked') ? 'blocked' : 'failed'),
-        schema: json?.schema || null,
-        blockers: Array.isArray(json?.blockers) ? json.blockers : [],
-        panic: /panic|UnhandledPromiseRejection|TypeError|ReferenceError/i.test(output),
-        stdout_tail: result.stdout.slice(-1000),
-        stderr_tail: result.stderr.slice(-1000)
-    };
-}
-function parseJson(value) {
-    try {
-        return JSON.parse(value || '{}');
-    }
-    catch {
-        return null;
-    }
-}
-async function inspectRetiredOperationalResidue(fixtures) {
-    const retiredModes = new Set(['team', 'mad-db']);
-    const retiredMissionIds = fixtures
-        .filter((fixture) => retiredModes.has(String(fixture.mode || '').toLowerCase()))
-        .map((fixture) => fixture.id);
-    const survivingMissionIds = [];
-    for (const missionId of retiredMissionIds) {
-        const missionRoot = path.join(projectRoot, '.sneakoscope', 'missions', missionId);
-        if (await fs.access(missionRoot).then(() => true, () => false))
-            survivingMissionIds.push(missionId);
-    }
-    const listingErrors = [];
-    const indexFile = path.join(projectRoot, '.sneakoscope', 'missions', 'index.json');
-    const operationalFiles = [
-        ...(await listJsonFiles(path.join(projectRoot, '.sneakoscope', 'state'), listingErrors)),
-        indexFile
-    ];
-    const missionRoot = path.join(projectRoot, '.sneakoscope', 'missions');
-    let missionEntries = [];
-    try {
-        missionEntries = await fs.readdir(missionRoot, { withFileTypes: true });
-    }
-    catch (error) {
-        listingErrors.push(`${relative(missionRoot)}:${errorCode(error)}`);
-    }
-    for (const entry of missionEntries) {
-        if (entry.isDirectory())
-            operationalFiles.push(path.join(missionRoot, entry.name, 'mission.json'));
-    }
-    const retiredIdentities = [];
-    const invalidJsonFiles = [];
-    const missingOperationalFiles = [];
-    for (const file of [...new Set(operationalFiles)]) {
-        const result = await readJsonStrict(file);
-        if (!result.ok) {
-            invalidJsonFiles.push({ file: relative(file), error: result.error });
-            continue;
-        }
-        collectRetiredOperationalIdentities(result.value, file, retiredIdentities);
-    }
-    const index = await readJsonStrict(indexFile);
-    if (!index.ok)
-        missingOperationalFiles.push(relative(indexFile));
-    else if (index.value?.schema !== 'sks.mission-index.v1' || !Array.isArray(index.value?.missions)) {
-        invalidJsonFiles.push({ file: relative(indexFile), error: 'mission_index_schema_invalid' });
-    }
-    for (const fixture of fixtures.filter((fixture) => !retiredModes.has(String(fixture.mode || '').toLowerCase()))) {
-        const missionFile = path.join(missionRoot, fixture.id, 'mission.json');
-        const mission = await readJsonStrict(missionFile);
-        if (!mission.ok)
-            missingOperationalFiles.push(relative(missionFile));
-    }
-    const explicitTombstones = [
-        path.join(projectRoot, '.sneakoscope', 'team'),
-        path.join(projectRoot, '.sneakoscope', 'team-dashboard-state.json'),
-        path.join(projectRoot, '.sneakoscope', 'update', 'legacy-team-artifacts.json')
-    ];
-    const survivingTombstones = [];
-    for (const candidate of explicitTombstones) {
-        if (await pathExists(candidate))
-            survivingTombstones.push(relative(candidate));
-    }
-    const retiredMissionArtifactPaths = await findRetiredMissionArtifactPaths(missionRoot);
-    const blockers = [
-        ...survivingMissionIds.map((missionId) => `retired_mission_survived:${missionId}`),
-        ...retiredIdentities.map((finding) => `retired_operational_identity_survived:${finding.file}:${finding.pointer}`),
-        ...listingErrors.map((error) => `operational_json_listing_failed:${error}`),
-        ...invalidJsonFiles.map((finding) => `operational_json_invalid:${finding.file}:${finding.error}`),
-        ...missingOperationalFiles.map((file) => `operational_json_missing:${file}`),
-        ...survivingTombstones.map((file) => `retired_tombstone_survived:${file}`),
-        ...retiredMissionArtifactPaths.map((file) => `retired_mission_artifact_survived:${file}`)
-    ];
-    return {
-        ok: blockers.length === 0,
-        retired_mission_ids: retiredMissionIds,
-        surviving_mission_ids: survivingMissionIds,
-        retired_operational_identities: retiredIdentities,
-        invalid_json_files: invalidJsonFiles,
-        missing_operational_files: missingOperationalFiles,
-        surviving_tombstone_paths: survivingTombstones,
-        retired_mission_artifact_paths: retiredMissionArtifactPaths,
-        blockers
-    };
-}
-async function listJsonFiles(directory, errors = []) {
-    let entries;
-    try {
-        entries = await fs.readdir(directory, { withFileTypes: true });
-    }
-    catch (error) {
-        errors.push(`${relative(directory)}:${errorCode(error)}`);
-        return [];
-    }
-    const files = [];
-    for (const entry of entries) {
-        const file = path.join(directory, entry.name);
-        if (entry.isDirectory())
-            files.push(...await listJsonFiles(file, errors));
-        else if (entry.isFile() && entry.name.endsWith('.json'))
-            files.push(file);
-    }
-    return files;
-}
-async function readJsonStrict(file) {
-    try {
-        return { ok: true, value: JSON.parse(await fs.readFile(file, 'utf8')), error: null };
-    }
-    catch (error) {
-        return { ok: false, value: null, error: errorCode(error) };
-    }
-}
-function collectRetiredOperationalIdentities(value, file, findings) {
-    const records = path.basename(file) === 'index.json' && Array.isArray(value?.missions)
-        ? value.missions.map((entry, index) => ({ entry, pointer: `$.missions[${index}]` }))
-        : [{ entry: value, pointer: '$' }];
-    for (const record of records) {
-        if (!record.entry || typeof record.entry !== 'object' || Array.isArray(record.entry))
-            continue;
-        for (const [key, entry] of Object.entries(record.entry)) {
-            const nextPointer = `${record.pointer}.${key}`;
-            if (['mode', 'route', 'route_command', 'command'].includes(key) && isRetiredOperationalValue(entry)) {
-                findings.push({
-                    file: relative(file),
-                    pointer: nextPointer
-                });
-            }
-        }
-    }
-}
-function isRetiredOperationalValue(value) {
-    const raw = String(value || '').trim();
-    const normalized = raw.replace(/^\$+/, '').replace(/_/g, '-').toLowerCase();
-    if (['team', 'mad-db'].includes(normalized))
-        return true;
-    return /^(?:\$?team|\$?mad-db)(?:\s|$)/i.test(raw)
-        || /^sks\s+(?:team|mad-db)(?:\s|$)/i.test(raw);
-}
-async function captureSafetyBaseline(fixtures) {
-    const currentMissionFiles = [];
-    for (const fixture of fixtures.filter((fixture) => !['team', 'mad-db'].includes(String(fixture.mode || '').toLowerCase()))) {
-        currentMissionFiles.push(...await listAllFiles(path.join(projectRoot, '.sneakoscope', 'missions', fixture.id)));
-    }
-    const userOwnedFiles = [
-        path.join(projectRoot, 'USER-NOTES.md'),
-        path.join(projectRoot, '.sneakoscope', 'state', 'customer-metadata.json')
-    ];
-    const currentManagedFiles = [path.join(projectRoot, 'package.json'), ...currentMissionFiles];
-    const userOwned = await snapshotFiles(userOwnedFiles);
-    const currentManaged = await snapshotFiles(currentManagedFiles);
-    return {
-        user_owned: userOwned.files,
-        current_managed: currentManaged.files,
-        blockers: [...userOwned.blockers, ...currentManaged.blockers]
-    };
-}
-async function inspectSafetyPostcondition(baseline) {
-    const userOwned = await compareSnapshot(baseline.user_owned);
-    const currentManaged = await compareSnapshot(baseline.current_managed);
-    const userOwnedDataTouched = userOwned.missing.length > 0 || userOwned.changed.length > 0;
-    const dataLossDetected = userOwnedDataTouched || currentManaged.missing.length > 0 || currentManaged.changed.length > 0;
-    const blockers = [
-        ...userOwned.missing.map((file) => `user_owned_file_missing:${file}`),
-        ...userOwned.changed.map((file) => `user_owned_file_changed:${file}`),
-        ...currentManaged.missing.map((file) => `current_managed_file_missing:${file}`),
-        ...currentManaged.changed.map((file) => `current_managed_file_changed:${file}`),
-        ...userOwned.blockers,
-        ...currentManaged.blockers
-    ];
-    return {
-        ok: blockers.length === 0,
-        data_loss_detected: dataLossDetected,
-        user_owned_data_touched: userOwnedDataTouched,
-        user_owned: userOwned,
-        current_managed: currentManaged,
-        blockers
-    };
-}
-async function snapshotFiles(files) {
-    const snapshot = {};
-    const blockers = [];
-    for (const file of [...new Set(files)].sort()) {
-        try {
-            snapshot[relative(file)] = await fileSha256(file);
-        }
-        catch (error) {
-            blockers.push(`baseline_file_unreadable:${relative(file)}:${errorCode(error)}`);
-        }
-    }
-    return { files: snapshot, blockers };
-}
-async function compareSnapshot(snapshot) {
-    const missing = [];
-    const changed = [];
-    const blockers = [];
-    for (const [file, expected] of Object.entries(snapshot)) {
-        const absolute = path.join(projectRoot, file);
-        try {
-            const actual = await fileSha256(absolute);
-            if (actual !== expected)
-                changed.push(file);
-        }
-        catch (error) {
-            if (errorCode(error) === 'ENOENT')
-                missing.push(file);
-            else
-                blockers.push(`postcondition_file_unreadable:${file}:${errorCode(error)}`);
-        }
-    }
-    return { ok: missing.length === 0 && changed.length === 0 && blockers.length === 0, checked: Object.keys(snapshot).length, missing, changed, blockers };
-}
-async function listAllFiles(directory) {
-    const entries = await fs.readdir(directory, { withFileTypes: true });
-    const files = [];
-    for (const entry of entries) {
-        const file = path.join(directory, entry.name);
-        if (entry.isDirectory())
-            files.push(...await listAllFiles(file));
-        else if (entry.isFile())
-            files.push(file);
-    }
-    return files;
-}
-async function findRetiredMissionArtifactPaths(missionRoot) {
-    const retiredNames = new Set(['team-gate.json', 'team-session-cleanup.json', 'team-inbox']);
-    const findings = [];
-    async function walk(directory) {
-        let entries;
-        try {
-            entries = await fs.readdir(directory, { withFileTypes: true });
-        }
-        catch (error) {
-            if (errorCode(error) !== 'ENOENT')
-                findings.push(`${relative(directory)}:<unreadable:${errorCode(error)}>`);
-            return;
-        }
-        for (const entry of entries) {
-            const file = path.join(directory, entry.name);
-            if (retiredNames.has(entry.name))
-                findings.push(relative(file));
-            if (entry.isDirectory())
-                await walk(file);
-        }
-    }
-    await walk(missionRoot);
-    return findings.sort();
-}
-async function fileSha256(file) {
-    return crypto.createHash('sha256').update(await fs.readFile(file)).digest('hex');
-}
-async function pathExists(file) {
-    return fs.access(file).then(() => true, () => false);
-}
-function relative(file) {
-    return path.relative(projectRoot, file).split(path.sep).join('/');
-}
-function errorCode(error) {
-    return String(error?.code || error?.name || 'unknown_error');
-}

package/dist/scripts/write-build-manifest.js

@@ -1,70 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-import { writeTextAtomic } from '../core/fsx.js';
-import { writeDistFreshStamp, sourceSnapshot } from './lib/ensure-dist-fresh.js';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const distRoot = path.join(root, 'dist');
-const srcRoot = path.join(root, 'src');
-if (!fs.existsSync(distRoot)) {
-    throw new Error('dist directory does not exist; run npm run build first');
-}
-const files = [];
-await collect(distRoot, files);
-const sorted = files.sort();
-const mjsRuntime = sorted.filter((f) => f.endsWith('.mjs')).length;
-const compiledJsCount = sorted.filter((f) => f.endsWith('.js')).length;
-const compiledDtsCount = sorted.filter((f) => f.endsWith('.d.ts')).length;
-const source = sourceSnapshot();
-const distStamp = writeDistFreshStamp();
-const srcMjsRuntimeFiles = await collectSrcMjsRuntimeFiles();
-await writeTextAtomic(path.join(distRoot, 'build-manifest.json'), `${JSON.stringify({
-    schema: 'sks.dist-build.v2',
-    version: pkg.version,
-    package_version: pkg.version,
-    typescript: true,
-    mjs_runtime_files: mjsRuntime,
-    compiled_file_count: compiledJsCount + compiledDtsCount,
-    compiled_js_count: compiledJsCount,
-    compiled_dts_count: compiledDtsCount,
-    source_digest: source.digest,
-    source_file_count: source.file_count,
-    source_files_hash: sha256(source.files.join('\n')),
-    source_list_hash: sha256(source.files.join('\n')),
-    src_mjs_runtime_files: srcMjsRuntimeFiles.length,
-    dist_stamp_schema: distStamp.schema,
-    files: sorted,
-}, null, 2)}\n`);
-async function collect(dir, out) {
-    for (const entry of await fsp.readdir(dir, { withFileTypes: true })) {
-        const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            await collect(file, out);
-        else if (entry.isFile())
-            out.push(path.relative(distRoot, file).split(path.sep).join('/'));
-    }
-}
-async function collectSrcMjsRuntimeFiles() {
-    const out = [];
-    await collectSrcMjs(srcRoot, out);
-    return out.sort();
-}
-async function collectSrcMjs(dir, out) {
-    if (!fs.existsSync(dir))
-        return;
-    for (const entry of await fsp.readdir(dir, { withFileTypes: true })) {
-        const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            await collectSrcMjs(file, out);
-        else if (entry.isFile() && entry.name.endsWith('.mjs')) {
-            out.push(path.relative(srcRoot, file).split(path.sep).join('/'));
-        }
-    }
-}
-function sha256(value) {
-    return crypto.createHash('sha256').update(value).digest('hex');
-}

package/dist/scripts/zellij-capability-check.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { ensureDistFresh, root } from './lib/ensure-dist-fresh.js';
-const freshness = ensureDistFresh({ rebuild: true });
-if (!freshness.ok)
-    fail('dist_not_fresh', { freshness });
-const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-capability.js')).href);
-const report = await mod.checkZellijCapability({ root, require: process.argv.includes('--require-real') || process.env.SKS_REQUIRE_ZELLIJ === '1' });
-emit(report);
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-function fail(blocker, detail) { emit({ schema: 'sks.zellij-capability-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }

package/dist/scripts/zellij-developer-controls-check.js

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const zellij = fs.readFileSync(path.join(root, 'src/commands/zellij.ts'), 'utf8');
-const report = {
-    schema: 'sks.zellij-developer-controls-check.v1',
-    ok: true,
-    zellij_controls: ['focus-worker', 'worker-logs', 'close-drained', 'pin', 'unpin'].every((token) => zellij.includes(token)),
-    unknown_subcommands_blocked: zellij.includes("status: 'unsupported_subcommand'") && zellij.includes('unsupported_zellij_subcommand'),
-    focus_uses_pane_id: zellij.includes('focus-pane-id'),
-    logs_read_runtime: zellij.includes('native-cli-worker-runtime.json')
-};
-report.ok = report.zellij_controls && report.unknown_subcommands_blocked && report.focus_uses_pane_id && report.logs_read_runtime;
-assertGate(report.ok, 'Zellij/Naruto developer controls missing', report);
-emitGate('zellij:developer-controls', report);

package/dist/scripts/zellij-doctor-readiness-check.js

@@ -1,49 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
-const { buildDoctorReadinessMatrix } = await importDist('core/doctor/doctor-readiness-matrix.js');
-const { ZELLIJ_LANE_SECTIONS, ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS } = await importDist('core/zellij/zellij-lane-renderer.js');
-const baseConfig = { ok: true, checks: [
-        { name: 'node_process_read', ok: true },
-        { name: 'spawned_child_read', ok: true },
-        { name: 'actual_codex_cli_config_load', ok: true, status: 'passed' }
-    ], blockers: [] };
-const missing = buildDoctorReadinessMatrix({
-    codex: { bin: '/usr/bin/codex', available: true },
-    codex_config: baseConfig,
-    zellij: { status: 'missing', ok: false }
-});
-assertGate(missing.mad_ready === false, 'zellij missing must make mad_ready=false', { missing });
-assertGate(missing.cli_ready === true, 'zellij missing must NOT block cli_ready', { missing });
-assertGate(!Object.hasOwn(missing, 'tmux_removed_runtime') && !Object.hasOwn(missing, 'tmux'), 'readiness must expose only the current terminal runtime', { missing });
-assertGate(missing.zellij && Array.isArray(missing.zellij.required_for), 'matrix must carry a zellij block with required_for', { missing });
-const okMatrix = buildDoctorReadinessMatrix({
-    codex: { bin: '/usr/bin/codex', available: true },
-    codex_config: baseConfig,
-    zellij: { status: 'ok', ok: true, version: '0.44.0', bin: 'zellij', min_version: '0.41.0' }
-});
-assertGate(okMatrix.mad_ready === true, 'zellij ok + readable config must make mad_ready=true', { okMatrix });
-const superset = new Set(ZELLIJ_LANE_SECTIONS);
-const missingFromSuperset = ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS.filter((s) => !superset.has(s));
-assertGate(missingFromSuperset.length === 0, 'screen-proof scrapeable sections must be a strict subset of lane sections', { missingFromSuperset });
-assertGate(ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS.length < ZELLIJ_LANE_SECTIONS.length, 'scrapeable subset must be smaller than the composed superset', {
-    scrapeable: ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS.length, lane: ZELLIJ_LANE_SECTIONS.length
-});
-const doctorSource = fs.readFileSync(path.join(root, 'src/commands/doctor.ts'), 'utf8');
-assertGate(/zellij_readiness\s*:/.test(doctorSource), 'doctor result must expose a zellij_readiness block', {});
-const doctorJson = spawnSync(process.execPath, ['dist/bin/sks.js', 'doctor', '--json'], { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
-assertGate(doctorJson.stdout.trim().startsWith('{'), 'built doctor --json must print JSON', { stderr: doctorJson.stderr.slice(-2000), status: doctorJson.status });
-const parsedDoctor = JSON.parse(doctorJson.stdout);
-assertGate(parsedDoctor.zellij_readiness && parsedDoctor.zellij_readiness.schema === 'sks.zellij-readiness.v1', 'built doctor --json must carry zellij_readiness block', { zellij_readiness: parsedDoctor.zellij_readiness || null });
-const doctorHuman = spawnSync(process.execPath, ['dist/bin/sks.js', 'doctor'], { cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 });
-assertGate(/(^|\n)Zellij:\n/.test(doctorHuman.stdout), 'built doctor human output must include Zellij section', { stdout_tail: doctorHuman.stdout.slice(-2000), stderr_tail: doctorHuman.stderr.slice(-2000), status: doctorHuman.status });
-emitGate('zellij:doctor-readiness', {
-    mad_ready_when_missing: false,
-    cli_ready_when_missing: true,
-    built_json_smoke: true,
-    built_human_smoke: true,
-    lane_sections: ZELLIJ_LANE_SECTIONS.length,
-    scrapeable_sections: ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS.length
-});

package/dist/scripts/zellij-dynamic-pane-lifecycle-check.js

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import path from 'node:path';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const worker = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-worker-pane-manager.ts'), 'utf8');
-const manager = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-right-column-manager.ts'), 'utf8');
-const runtime = fs.readFileSync(path.join(root, 'src/core/agents/native-cli-worker-runtime.ts'), 'utf8');
-const report = {
-    schema: 'sks.zellij-dynamic-pane-lifecycle-check.v1',
-    ok: true,
-    close_success_default: worker.includes("SKS_ZELLIJ_CLOSE_WORKER_PANE !== '0'"),
-    keep_failed_default: worker.includes('SKS_ZELLIJ_KEEP_FAILED_PANE'),
-    close_updates_right_column: worker.includes('closeWorkerInRightColumn'),
-    drained_status_recorded: manager.includes('worker_pane_drained'),
-    overflow_headless_recorded: runtime.includes('recordHeadlessWorkerInRightColumn')
-};
-report.ok = report.close_success_default && report.keep_failed_default && report.close_updates_right_column && report.drained_status_recorded && report.overflow_headless_recorded;
-assertGate(report.ok, 'dynamic pane lifecycle must close/drain workers and record headless overflow', report);
-emitGate('zellij:dynamic-pane-lifecycle', report);

package/dist/scripts/zellij-fake-adapter-check.js

@@ -1,31 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-fake-zellij-'));
-process.env.SKS_ZELLIJ_FAKE_ADAPTER = '1';
-process.env.SKS_ZELLIJ_FAKE_ROOT = tmp;
-process.env.SKS_ZELLIJ_FAKE_VERSION = '0.43.1';
-process.env.SKS_ZELLIJ_FAKE_DELAY_MS = '1';
-const { runZellij } = await importDist('core/zellij/zellij-command.js');
-const version = await runZellij(['--version'], { cwd: tmp });
-const attach = await runZellij(['attach', '--create-background', 'fixture'], { cwd: tmp });
-const anchor = await runZellij(['--session', 'fixture', 'action', 'new-pane', '--direction', 'right', '--name', 'SLOTS', '--', 'sh', '-lc', 'echo slots'], { cwd: tmp });
-const worker = await runZellij(['--session', 'fixture', 'action', 'new-pane', '--stacked', '--name', 'slot-001', '--', 'sh', '-lc', 'echo worker'], { cwd: tmp });
-const focus = await runZellij(['--session', 'fixture', 'action', 'focus-pane-id', 'terminal_2'], { cwd: tmp });
-const listed = await runZellij(['--session', 'fixture', 'action', 'list-panes', '--json', '--all'], { cwd: tmp });
-const screen = await runZellij(['--session', 'fixture', 'action', 'dump-screen'], { cwd: tmp });
-process.env.SKS_ZELLIJ_FAKE_VERSION = '0.42.2';
-const rejected = await runZellij(['--session', 'fixture-old', 'action', 'new-pane', '--stacked', '--name', 'old', '--', 'sh', '-lc', 'echo old'], { cwd: tmp, optional: true });
-const calls = await readJsonl(path.join(tmp, '.sneakoscope', 'fake-zellij-calls.jsonl'));
-assertGate(version.ok && version.stdout_tail.includes('0.43.1'), 'fake zellij --version failed', version);
-assertGate(attach.ok && anchor.ok && worker.ok && focus.ok && listed.ok && screen.ok, 'fake zellij core commands must pass', { attach, anchor, worker, focus, listed, screen });
-assertGate(rejected.ok === false, 'fake zellij <0.43 must reject --stacked', rejected);
-assertGate(calls.length >= 8, 'fake zellij calls must be recorded', calls);
-assertGate(JSON.parse(listed.stdout_tail).length >= 2, 'fake zellij list-panes must return fake panes', listed);
-emitGate('zellij:fake-adapter', { calls: calls.length, root: tmp });
-async function readJsonl(file) {
-    const text = await fs.readFile(file, 'utf8');
-    return text.trim().split(/\n+/).filter(Boolean).map((line) => JSON.parse(line));
-}