sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/route-proof-artifact-structure-check.js

@@ -1,145 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const issues = [];
-for (const rel of [
-    'src/core/proof/route-proof-gate.ts',
-    'src/core/agents/agent-proof-evidence.ts',
-    'src/core/agents/agent-gate.ts',
-    'src/core/agents/agent-ledger-schemas.ts'
-]) {
-    if (!fs.existsSync(path.join(root, rel)))
-        issues.push(`missing:${rel}`);
-}
-const gateText = read('src/core/proof/route-proof-gate.ts');
-for (const token of [
-    "agents.status !== 'passed' || agents.ok !== true",
-    'agent_no_overlap_not_ok',
-    'agent_ledger_hash_chain_not_ok',
-    'agent_consensus_not_ok',
-    'agent_blockers_present',
-    'agent_proof_evidence_missing',
-    'agent_count_below_5',
-    'agent_count_above_20'
-]) {
-    if (!gateText.includes(token))
-        issues.push(`route_gate_missing:${token}`);
-}
-const agentGateText = read('src/core/agents/agent-gate.ts');
-for (const token of ['agent_proof_not_ok', 'agent_proof_status_not_passed', 'agent_count_below_5', 'agent_janitor_missing_or_not_ok']) {
-    if (!agentGateText.includes(token))
-        issues.push(`agent_gate_missing:${token}`);
-}
-await runNegativeFixture();
-const result = {
-    schema: 'sks.route-proof-artifact-structure-check.v1',
-    ok: issues.length === 0,
-    issues
-};
-console.log(JSON.stringify(result, null, 2));
-if (!result.ok)
-    process.exitCode = 1;
-function read(rel) {
-    try {
-        return fs.readFileSync(path.join(root, rel), 'utf8');
-    }
-    catch {
-        return '';
-    }
-}
-async function runNegativeFixture() {
-    const built = path.join(root, 'dist', 'core', 'proof', 'route-proof-gate.js');
-    if (!fs.existsSync(built)) {
-        issues.push('runtime_gate_import_missing');
-        return;
-    }
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-route-proof-'));
-    const mission = 'M-fixture';
-    const missionDir = path.join(tmp, '.sneakoscope', 'missions', mission);
-    fs.mkdirSync(missionDir, { recursive: true });
-    const proofPath = path.join(missionDir, 'completion-proof.json');
-    const baseProof = {
-        schema: 'sks.completion-proof.v1',
-        version: 'fixture',
-        generated_at: '2026-05-25T00:00:00.000Z',
-        mission_id: mission,
-        status: 'verified',
-        route: '$Team',
-        summary: { files_changed: 0, commands_run: 0, tests_passed: 0, tests_failed: 0, manual_review_required: false },
-        evidence: {
-            agents: {
-                schema: 'sks.agent-proof-evidence.v1',
-                ok: true,
-                status: 'blocked',
-                agent_count: 5,
-                all_sessions_closed: true,
-                no_overlap_ok: true,
-                ledger_hash_chain_ok: true,
-                consensus_ok: true,
-                janitor_ok: true,
-                blockers: []
-            }
-        },
-        claims: [],
-        unverified: [],
-        blockers: [],
-        next_human_actions: []
-    };
-    fs.writeFileSync(proofPath, JSON.stringify(baseProof, null, 2));
-    const { validateRouteCompletionProof } = await import(pathToFileURL(built).href);
-    const result = await validateRouteCompletionProof(tmp, { missionId: mission, route: '$Team', state: { agents_required: true } });
-    if (result.ok || !result.issues.includes('agent_gate_not_passed'))
-        issues.push('negative_fixture_false_passed_agent_status');
-    fs.writeFileSync(proofPath, JSON.stringify({ ...baseProof, evidence: {} }, null, 2));
-    const missingAgents = await validateRouteCompletionProof(tmp, { missionId: mission, route: '$Team' });
-    if (missingAgents.ok || !missingAgents.issues.includes('agent_proof_evidence_missing'))
-        issues.push('negative_fixture_false_passed_missing_agents');
-    fs.writeFileSync(proofPath, JSON.stringify({
-        ...baseProof,
-        evidence: {
-            agents: {
-                schema: 'sks.agent-proof-evidence.v1',
-                ok: true,
-                status: 'passed',
-                agent_count: 8,
-                all_sessions_closed: true,
-                no_overlap_ok: true,
-                ledger_hash_chain_ok: true,
-                consensus_ok: true,
-                janitor_ok: true,
-                blockers: []
-            }
-        }
-    }, null, 2));
-    const scaledAgents = await validateRouteCompletionProof(tmp, { missionId: mission, route: '$Team' });
-    if (!scaledAgents.ok || scaledAgents.issues.includes('agent_count_not_5'))
-        issues.push('positive_fixture_scaled_agents_failed');
-    fs.writeFileSync(proofPath, JSON.stringify({
-        ...baseProof,
-        evidence: {
-            agents: {
-                schema: 'sks.agent-proof-evidence.v1',
-                ok: true,
-                status: 'passed',
-                agent_count: 5,
-                all_sessions_closed: true,
-                no_overlap_ok: true,
-                ledger_hash_chain_ok: true,
-                consensus_ok: true,
-                blockers: []
-            }
-        }
-    }, null, 2));
-    const missingJanitor = await validateRouteCompletionProof(tmp, { missionId: mission, route: '$Team' });
-    if (missingJanitor.ok || !missingJanitor.issues.includes('agent_janitor_missing_or_not_ok'))
-        issues.push('negative_fixture_missing_janitor_false_passed');
-    fs.writeFileSync(proofPath, JSON.stringify({ ...baseProof, route: '$Release-Review', evidence: {} }, null, 2));
-    const releaseReview = await validateRouteCompletionProof(tmp, { missionId: mission, route: '$Release-Review' });
-    if (releaseReview.ok || !releaseReview.issues.includes('agent_proof_evidence_missing'))
-        issues.push('negative_fixture_release_review_missing_agents_false_passed');
-}
-//# sourceMappingURL=route-proof-artifact-structure-check.js.map

package/dist/scripts/runtime-dist-parity-check.js

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-import { currentDistFreshness, sourceSnapshot } from './lib/ensure-dist-fresh.js';
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const manifestPath = path.join(root, 'dist', 'build-manifest.json');
-const issues = [];
-const freshness = currentDistFreshness();
-const source = sourceSnapshot();
-const manifest = readJson(manifestPath);
-const pkg = readJson(path.join(root, 'package.json'));
-if (!manifest)
-    issues.push('build_manifest_missing');
-if (!freshness.ok)
-    issues.push(...freshness.issues);
-if (manifest) {
-    if (manifest.package_version !== pkg.version || manifest.version !== pkg.version)
-        issues.push('manifest_version_mismatch');
-    if (manifest.source_digest !== source.digest)
-        issues.push('manifest_source_digest_stale');
-    if (manifest.source_file_count !== source.file_count)
-        issues.push('manifest_source_file_count_stale');
-    if (manifest.source_list_hash !== sha256(source.files.join('\n')))
-        issues.push('manifest_source_list_hash_stale');
-    if (Number(manifest.src_mjs_runtime_files) !== 0)
-        issues.push(`manifest_src_mjs_runtime_files:${manifest.src_mjs_runtime_files}`);
-    if (Number(manifest.compiled_js_count) <= 0)
-        issues.push('manifest_compiled_js_count_missing');
-    if (!Number.isFinite(Number(manifest.compiled_dts_count)))
-        issues.push('manifest_compiled_dts_count_invalid');
-}
-const srcMjs = walk(path.join(root, 'src')).filter((file) => file.endsWith('.mjs'));
-if (srcMjs.length)
-    issues.push(`src_mjs_runtime_files:${srcMjs.length}`);
-const distMjs = walk(path.join(root, 'dist')).filter((file) => file.endsWith('.mjs'));
-if (distMjs.length)
-    issues.push(`dist_mjs_runtime_files:${distMjs.length}`);
-const result = {
-    schema: 'sks.runtime-dist-parity.v1',
-    ok: issues.length === 0,
-    package_version: pkg.version,
-    source_digest: source.digest,
-    source_file_count: source.file_count,
-    src_mjs_runtime_files: srcMjs.length,
-    dist_mjs_runtime_files: distMjs.length,
-    manifest,
-    issues
-};
-console.log(JSON.stringify(result, null, 2));
-if (!result.ok)
-    process.exitCode = 1;
-function readJson(file) {
-    try {
-        return JSON.parse(fs.readFileSync(file, 'utf8'));
-    }
-    catch {
-        return null;
-    }
-}
-function walk(dir, out = []) {
-    if (!fs.existsSync(dir))
-        return out;
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            walk(file, out);
-        else if (entry.isFile())
-            out.push(file);
-    }
-    return out;
-}
-function sha256(text) {
-    return crypto.createHash('sha256').update(text).digest('hex');
-}
-//# sourceMappingURL=runtime-dist-parity-check.js.map

package/dist/scripts/runtime-no-mjs-scripts-check.js

@@ -1,45 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { packageRoot } from '../core/fsx.js';
-const root = packageRoot();
-const scriptsDir = path.join(root, 'scripts');
-const binDir = path.join(root, 'bin');
-const mjs = [...await collectMjs(scriptsDir), ...await collectMjs(binDir)].sort();
-const packageJson = JSON.parse(await fs.readFile(path.join(root, 'package.json'), 'utf8'));
-const scriptRefs = Object.entries(packageJson.scripts || {})
-    .filter(([, command]) => typeof command === 'string' && /(^|[\s;&|])\.\/(?:scripts|bin)\/[^ ]+\.mjs\b/.test(command))
-    .map(([name, command]) => ({ name, command }));
-const ok = mjs.length === 0 && scriptRefs.length === 0;
-emit({
-    schema: 'sks.runtime-no-mjs-scripts-check.v1',
-    ok,
-    production_mjs_count: mjs.length,
-    production_mjs_sample: mjs.slice(0, 20).map((file) => path.relative(root, file)),
-    package_script_mjs_refs: scriptRefs.slice(0, 40),
-    blockers: ok ? [] : ['runtime_mjs_scripts_remaining']
-});
-async function collectMjs(dir) {
-    const out = [];
-    let entries;
-    try {
-        entries = await fs.readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return out;
-    }
-    for (const entry of entries) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            out.push(...await collectMjs(full));
-        else if (entry.name.endsWith('.mjs'))
-            out.push(full);
-    }
-    return out.sort();
-}
-function emit(report) {
-    console.log(JSON.stringify(report, null, 2));
-    if (!report.ok)
-        process.exitCode = 1;
-}
-//# sourceMappingURL=runtime-no-mjs-scripts-check.js.map

package/dist/scripts/runtime-no-src-mjs-check.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-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 files = walk(path.join(root, 'src'))
-    .filter((file) => file.endsWith('.mjs'))
-    .map((file) => path.relative(root, file).split(path.sep).join('/'))
-    .sort();
-const result = {
-    schema: 'sks.runtime-no-src-mjs.v1',
-    ok: files.length === 0,
-    src_mjs_runtime_files: files.length,
-    files
-};
-console.log(JSON.stringify(result, null, 2));
-if (!result.ok)
-    process.exitCode = 1;
-function walk(dir, out = []) {
-    if (!fs.existsSync(dir))
-        return out;
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            walk(file, out);
-        else if (entry.isFile())
-            out.push(file);
-    }
-    return out;
-}
-//# sourceMappingURL=runtime-no-src-mjs-check.js.map

package/dist/scripts/runtime-no-tmux-check.js

@@ -1,113 +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 scanRoots = ['src', 'scripts', 'package.json', 'README.md', 'docs'];
-const migrationOnlyFiles = new Set([
-    'docs/migration/tmux-to-zellij.md',
-    'dist/scripts/runtime-no-tmux-check.js',
-    'dist/scripts/tmux-removal-inventory.js',
-    'src/scripts/runtime-no-tmux-check.ts',
-    'src/cli/command-registry.ts',
-    'src/commands/tmux.ts',
-    'src/core/commands/basic-cli.ts',
-    'src/core/commands/team-command.ts'
-]);
-const legacyFixtureFileRe = /^(scripts|test)\/.*(?:tmux|real-tmux|warp-right-lane).*$/;
-const runtimePatterns = [
-    ['tmux_binary_spawn', /(?:runProcess|spawnSync|spawn|execFile)\(\s*['"]tmux['"]/],
-    ['tmux_import', /(?:from\s+['"][^'"]*tmux[^'"]*['"]|import\s*\([^)]*['"][^'"]*tmux[^'"]*['"])/],
-    ['launchMadTmuxUi', /\blaunchMadTmuxUi\b/],
-    ['agent-runner-tmux', /\bagent-runner-tmux\b/],
-    ['tmux-physical-proof', /\btmux-physical-proof\b/],
-    ['tmux-lane', /\btmux-lane\b/],
-    ['real-tmux', /\breal-tmux\b/],
-    ['warp-right-lane', /\bwarp-right-lane\b/]
-];
-const docRecommendationRe = /\b(?:sks\s+tmux|sks\s+deps\s+install\s+tmux|brew\s+install\s+tmux|install\s+tmux|requires?\s+tmux|tmux\s+for\s+the\s+CLI|opens?.{0,60}tmux|npm\s+run\s+(?:tmux:|agent:tmux)|cleanup-tmux|open-tmux|attach-tmux)\b/i;
-const issues = [];
-const legacy_fixture_allowlist = [];
-const checked_files = [];
-for (const base of scanRoots) {
-    for (const file of await listFiles(path.join(root, base))) {
-        const rel = path.relative(root, file);
-        checked_files.push(rel);
-        const text = await fs.readFile(file, 'utf8');
-        if (rel === 'package.json') {
-            inspectPackageJson(text);
-            continue;
-        }
-        if (migrationOnlyFiles.has(rel))
-            continue;
-        if (legacyFixtureFileRe.test(rel)) {
-            legacy_fixture_allowlist.push(rel);
-            continue;
-        }
-        if (rel.startsWith('docs/') || rel === 'README.md') {
-            inspectDocs(rel, text);
-            continue;
-        }
-        for (const [name, re] of runtimePatterns) {
-            if (re.test(text))
-                issues.push({ file: rel, pattern: name });
-        }
-        inspectRuntimeRecommendations(rel, text);
-    }
-}
-const ok = issues.length === 0;
-emit({
-    schema: 'sks.runtime-no-tmux-check.v1',
-    ok,
-    scan_roots: scanRoots,
-    issues,
-    checked_file_count: checked_files.length,
-    migration_only_files: [...migrationOnlyFiles],
-    legacy_fixture_allowlist
-});
-async function listFiles(target) {
-    const out = [];
-    const stat = await fs.stat(target).catch(() => null);
-    if (!stat)
-        return out;
-    if (stat.isFile())
-        return [target];
-    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() && /\.(ts|tsx|js|mjs|json|md)$/.test(entry.name))
-            out.push(file);
-    }
-    return out;
-}
-function inspectPackageJson(text) {
-    const pkg = JSON.parse(text);
-    for (const [name, command] of Object.entries(pkg.scripts || {})) {
-        if (name === 'runtime:no-tmux')
-            continue;
-        if (/^(tmux:|agent:tmux-)|warp-right-lane|real-tmux/i.test(name)) {
-            issues.push({ file: 'package.json', script: name, pattern: 'tmux_script_name' });
-        }
-        if (/(?:npm\s+run\s+tmux:|agent-tmux|real-tmux|tmux-physical-proof|tmux-lane|warp-right-lane|mad-sks:warp-right-lane-attach)/i.test(String(command))) {
-            issues.push({ file: 'package.json', script: name, pattern: 'tmux_script_command' });
-        }
-    }
-}
-function inspectDocs(rel, text) {
-    inspectRuntimeRecommendations(rel, text);
-}
-function inspectRuntimeRecommendations(rel, text) {
-    const lines = String(text).split(/\r?\n/);
-    lines.forEach((line, index) => {
-        if (/\bremoved[-_ ]runtime\b|migration notice|Use Zellij instead|replacement:\s*['"]zellij['"]/i.test(line))
-            return;
-        if (docRecommendationRe.test(line))
-            issues.push({ file: rel, line: index + 1, pattern: 'tmux_runtime_recommendation' });
-    });
-}
-function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
-    process.exitCode = 1; }
-//# sourceMappingURL=runtime-no-tmux-check.js.map

package/dist/scripts/runtime-ts-python-boundary-check.js

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { packageRoot } from '../core/fsx.js';
-import { probePythonTools } from '../core/python-tools/python-tool-runner.js';
-const root = packageRoot();
-const probe = await probePythonTools(root);
-const packageJson = JSON.parse(await fs.readFile(path.join(root, 'package.json'), 'utf8'));
-const scriptCommands = Object.values(packageJson.scripts || {}).map(String);
-const pythonRuntimeRefs = scriptCommands.filter((command) => /(^|[\s;&|])python(?:3)?(?:\s|$)/.test(command) && /\b(?:postinstall|publish|prepack|prepublishOnly)\b/.test(command));
-const pytoolsFiles = await collectPython(path.join(root, 'pytools'));
-const forbiddenWrites = await findForbiddenPythonWrites(pytoolsFiles);
-const ok = probe.ok
-    && probe.core_runtime_requires_python === false
-    && pythonRuntimeRefs.length === 0
-    && forbiddenWrites.length === 0;
-emit({
-    schema: 'sks.runtime-ts-python-boundary-check.v1',
-    ok,
-    probe,
-    pytools_files: pytoolsFiles.map((file) => path.relative(root, file)),
-    python_runtime_refs: pythonRuntimeRefs,
-    forbidden_python_writes: forbiddenWrites,
-    blockers: ok ? [] : ['runtime_ts_python_boundary_check_failed']
-});
-async function collectPython(dir) {
-    const out = [];
-    let entries;
-    try {
-        entries = await fs.readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return out;
-    }
-    for (const entry of entries) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            out.push(...await collectPython(full));
-        else if (entry.name.endsWith('.py'))
-            out.push(full);
-    }
-    return out.sort();
-}
-async function findForbiddenPythonWrites(files) {
-    const out = [];
-    for (const file of files) {
-        const text = await fs.readFile(file, 'utf8');
-        if (/(\.codex|config\.toml|auth\.json|os\.environ|subprocess\.(?:run|Popen))/.test(text) && /\b(open|write_text|write_bytes|remove|unlink|rename)\b/.test(text)) {
-            out.push(path.relative(packageRoot(), file));
-        }
-    }
-    return out;
-}
-function emit(report) {
-    console.log(JSON.stringify(report, null, 2));
-    if (!report.ok)
-        process.exitCode = 1;
-}
-//# sourceMappingURL=runtime-ts-python-boundary-check.js.map

package/dist/scripts/runtime-ts-rust-boundary-check.js

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { root, assertGate, emitGate, importDist, readText, readJson } from './sks-1-18-gate-lib.js';
-// Proves TypeScript is the runtime source-of-truth and Rust is an OPTIONAL accelerator:
-//  - publish/build never compiles Rust,
-//  - the JS fallback is always available and produces identical results,
-//  - the native binary is never required to ship or run SKS.
-// 1) No cargo/rustc anywhere in build or publish.
-assertGate(!/cargo|rustc/.test(readText('src/scripts/build-dist.ts')), 'build-dist must not invoke cargo/rustc');
-assertGate(!/cargo|rustc/.test(readText('src/scripts/clean-dist.ts')), 'clean-dist must not invoke cargo/rustc');
-const pkg = readJson('package.json');
-for (const s of ['prepack', 'prepublishOnly', 'publish:dry', 'publish:npm']) {
-    assertGate(!String(pkg.scripts?.[s] || '').includes('cargo'), `publish_script_compiles_rust:${s}`);
-}
-// 2) The published binary is JS; no prebuilt native artifact is shipped or required.
-assertGate(pkg.bin?.sks === 'dist/bin/sks.js', 'package bin.sks must point at the JS entrypoint dist/bin/sks.js');
-assertGate(!(pkg.files || []).some((f) => f === 'native' || f.includes('target') || f.endsWith('.node')), 'package files must not ship a prebuilt native binary (native/target/*.node)');
-// 3) Doctor readiness has no Rust dependency (audit confirmed zero rust references).
-const matrix = readText('src/core/doctor/doctor-readiness-matrix.ts');
-assertGate(!/rust/i.test(matrix), 'doctor readiness matrix must not depend on Rust');
-// 4) Behavioral: JS fallback parity. The normalized result hash must equal the TS sha256.
-const acc = await importDist('core/rust-accelerator.js');
-const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-rust-boundary-'));
-const tempFile = path.join(tmpDir, 'sneakoscope-rust-boundary.bin');
-const fileBytes = Buffer.from('sneakoscope-rust-boundary');
-fs.writeFileSync(tempFile, fileBytes);
-const tsHash = crypto.createHash('sha256').update(fileBytes).digest('hex');
-const r = await acc.rustImageHash(tempFile);
-// The result shape: { command, engine, available, rust_error, stdout, result }.
-// The 64-hex sha256 lives inside `result` (result.sha256 for the JS fallback, or the
-// rust JSON payload's hash field). Extract robustly: prefer known fields, fall back to a
-// regex scan over the whole normalized object.
-const directHash = (r.result && (r.result.sha256 || r.result.hash || r.result.image_hash)) || null;
-const scannedHash = (JSON.stringify(r).match(/\b[0-9a-f]{64}\b/) || [])[0] || null;
-const acceleratorHash = (typeof directHash === 'string' && /^[0-9a-f]{64}$/.test(directHash))
-    ? directHash
-    : scannedHash;
-assertGate(acceleratorHash === tsHash, 'rust_ts_hash_mismatch', {
-    engine: r.engine,
-    accelerator_hash: acceleratorHash,
-    ts_hash: tsHash
-});
-// 5) Accelerator status must report a known mode; JS fallback readiness must be true when present.
-const info = await acc.rustInfo();
-assertGate(['js_fallback', 'rust_accelerated'].includes(info.mode), 'rust accelerator mode must be js_fallback or rust_accelerated', {
-    mode: info.mode
-});
-if (typeof info.js_fallback_ready !== 'undefined') {
-    assertGate(info.js_fallback_ready === true, 'js fallback must be ready when reported');
-}
-try {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-}
-catch {
-    // temp cleanup is best-effort
-}
-const report = {
-    schema: 'sks.runtime-ts-rust-boundary.v1',
-    ok: true,
-    engine: r.engine,
-    mode: info.mode,
-    no_cargo_in_publish: true,
-    native_binary_required: false,
-    js_fallback_parity: true
-};
-const out = path.join(root, '.sneakoscope/reports/runtime-ts-rust-boundary.json');
-fs.mkdirSync(path.dirname(out), { recursive: true });
-fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-emitGate('runtime:ts-rust-boundary', { engine: r.engine, no_cargo_in_publish: true });
-//# sourceMappingURL=runtime-ts-rust-boundary-check.js.map

package/dist/scripts/runtime-ts-source-of-truth-check.js

@@ -1,55 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-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 pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-const issues = [];
-if (pkg.bin?.sks !== 'dist/bin/sks.js')
-    issues.push('package_bin_sks_not_dist');
-if (pkg.bin?.sneakoscope !== 'dist/bin/sks.js')
-    issues.push('package_bin_sneakoscope_not_dist');
-if ((pkg.files || []).includes('src'))
-    issues.push('package_files_include_src');
-if (!pkg.scripts?.['dev:sks'])
-    issues.push('missing_dev_sks');
-for (const file of walk(path.join(root, 'src'))) {
-    const rel = path.relative(root, file).split(path.sep).join('/');
-    if (rel.endsWith('.mjs'))
-        issues.push(`src_mjs_runtime_shadow:${rel}`);
-    if (!rel.endsWith('.ts'))
-        continue;
-    const text = fs.readFileSync(file, 'utf8');
-    if (/from\s+['"][^'"]+\.mjs['"]|import\(\s*['"][^'"]+\.mjs['"]\s*\)/.test(text)) {
-        issues.push(`ts_imports_mjs:${rel}`);
-    }
-}
-const binShim = path.join(root, 'bin', 'sks.mjs');
-if (fs.existsSync(binShim)) {
-    const text = fs.readFileSync(binShim, 'utf8');
-    if (text.includes('/src/') || text.includes('../src/') || text.includes('FAST_PACKAGE_VERSION')) {
-        issues.push('bin_sks_mjs_not_dist_only');
-    }
-}
-const result = {
-    schema: 'sks.runtime-ts-source-of-truth.v1',
-    ok: issues.length === 0,
-    issues
-};
-console.log(JSON.stringify(result, null, 2));
-if (!result.ok)
-    process.exitCode = 1;
-function walk(dir, out = []) {
-    if (!fs.existsSync(dir))
-        return out;
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const file = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            walk(file, out);
-        else if (entry.isFile())
-            out.push(file);
-    }
-    return out;
-}
-//# sourceMappingURL=runtime-ts-source-of-truth-check.js.map

package/dist/scripts/safety-check.js

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { runProcess } from '../core/fsx.js';
-const shards = [
-    ['node', ['--test', 'test/unit/db-safety.test.mjs', 'test/unit/db-safety-golden.test.mjs']],
-    ['node', ['--test', 'test/integration/hooks-replay.test.mjs', 'test/unit/hooks-replay-policy.test.mjs', 'test/unit/hook-command-output.test.mjs']],
-    ['node', ['--test', 'test/unit/proof-redaction.test.mjs', 'test/unit/codex-access-token-redaction.test.mjs']]
-];
-const results = [];
-for (const [cmd, args] of shards) {
-    const result = await runProcess(cmd, args, {
-        cwd: process.cwd(),
-        timeoutMs: 60_000,
-        maxOutputBytes: 512 * 1024,
-        env: { SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' }
-    });
-    results.push({ command: [cmd, ...args].join(' '), ok: result.code === 0, code: result.code, stderr_tail: result.stderr.slice(-1000), stdout_tail: result.stdout.slice(-1000) });
-}
-const ok = results.every((row) => row.ok);
-console.log(JSON.stringify({ schema: 'sks.safety-check.v1', ok, results }, null, 2));
-if (!ok)
-    process.exitCode = 1;
-//# sourceMappingURL=safety-check.js.map

package/dist/scripts/shared-memory-fixture-check.js

@@ -1,27 +0,0 @@
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import assert from 'node:assert/strict';
-import { runProcess } from '../core/fsx.js';
-const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-shared-memory-fixture-'));
-const bin = path.join(process.cwd(), 'dist', 'bin', 'sks.js');
-await fs.writeFile(path.join(root, 'package.json'), '{"name":"fixture","private":true}\n');
-await runProcess('git', ['init'], { cwd: root });
-await runSks(['git', 'install', '--json']);
-await fs.mkdir(path.join(root, '.sneakoscope', 'wiki'), { recursive: true });
-await fs.writeFile(path.join(root, '.sneakoscope', 'wiki', 'context-pack.json'), JSON.stringify({
-    schema: 'fixture',
-    claims: [{ id: 'shared-memory-check-claim', text: 'Shared memory check claim.', status: 'supported', source: 'docs/shared-triwiki.md' }]
-}, null, 2));
-const publish = await runSks(['wiki', 'publish', 'latest', '--shared', '--json']);
-assert.equal(publish.ok, true);
-const validation = await runSks(['wiki', 'validate-shared', '--json']);
-assert.equal(validation.ok, true);
-console.log(JSON.stringify({ ok: true, schema: 'sks.shared-memory-fixture.v1', files: validation.files.length }, null, 2));
-async function runSks(args) {
-    const result = await runProcess(process.execPath, [bin, ...args], { cwd: root, env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' } });
-    assert.equal(result.code, 0, result.stdout || result.stderr);
-    return JSON.parse(result.stdout);
-}
-//# sourceMappingURL=shared-memory-fixture-check.js.map