sneakoscope 4.0.13 → 4.0.15

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

@@ -0,0 +1,78 @@
+#!/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

@@ -0,0 +1,45 @@
+#!/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

@@ -0,0 +1,32 @@
+#!/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

@@ -0,0 +1,114 @@
+#!/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-legacy-observe-command.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-proof-summary-check.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { buildRuntimeProofSummary } from '../core/agents/runtime-proof-summary.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-runtime-summary-'));
+const missionId = 'M-runtime-summary';
+const dir = path.join(root, '.sneakoscope', 'missions', missionId);
+const agents = path.join(dir, 'agents');
+await fs.mkdir(path.join(dir, 'zellij'), { recursive: true });
+await fs.mkdir(agents, { recursive: true });
+await fs.writeFile(path.join(agents, 'parallel-runtime-proof.json'), `${JSON.stringify({
+    schema: 'sks.parallel-runtime-proof.v1',
+    mission_id: missionId,
+    generated_at: new Date().toISOString(),
+    proof_mode: 'production',
+    require_worker_pids: true,
+    allow_missing_pids: false,
+    requested_workers: 32,
+    target_active_slots: 32,
+    max_observed_active_workers: 32,
+    max_observed_worker_processes: 32,
+    unique_worker_pids: 32,
+    unique_model_call_ids: 64,
+    max_observed_model_calls: 12,
+    launch_span_ms: 400,
+    first_batch_launch_span_ms: 400,
+    wall_ms: 12000,
+    sequential_estimate_ms: 82000,
+    speedup_ratio: 6.833,
+    overlap_windows: [],
+    visible_panes: 8,
+    headless_workers: 24,
+    utilization_proof_consistency: { ok: true, scheduler_max_active: 32, proof_max_active: 32, wall_ms_delta: 100 },
+    passed: true,
+    blockers: []
+})}\n`);
+await fs.writeFile(path.join(agents, 'agent-scheduler-state.json'), `${JSON.stringify({ target_active_slots: 32, max_observed_active_slots: 32, largest_batch_size: 32, scheduler_utilization: 0.88, wall_time_ms: 12100 })}\n`);
+await fs.writeFile(path.join(agents, 'agent-native-cli-session-swarm.json'), `${JSON.stringify({ process_ids: Array.from({ length: 32 }, (_, i) => 8000 + i), zellij_pane_worker_sessions: 8, headless_overflow_worker_count: 24 })}\n`);
+await fs.writeFile(path.join(agents, 'naruto-concurrency-governor.json'), `${JSON.stringify({ target_active_slots: 32 })}\n`);
+await fs.writeFile(path.join(dir, 'zellij', 'slot-telemetry.snapshot.json'), `${JSON.stringify({ schema: 'sks.zellij-slot-telemetry-snapshot.v1', mission_id: missionId, updated_at: new Date(Date.now() - 800).toISOString(), slots: {}, counts: {} })}\n`);
+const summary = await buildRuntimeProofSummary(root, missionId);
+assertGate(summary.ok === true, 'runtime proof summary must pass complete fixture', summary);
+assertGate(summary.parallel.max_active_workers === 32 && summary.parallel.unique_worker_pids === 32 && summary.ui.visible_panes === 8 && summary.ui.headless_workers === 24, 'runtime proof summary values mismatch', summary);
+assertGate(await exists(path.join(agents, 'runtime-proof-summary.json')), 'runtime proof summary file missing');
+emitGate('runtime:proof-summary', summary);
+async function exists(file) {
+    try {
+        await fs.stat(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=runtime-proof-summary-check.js.map

package/dist/scripts/runtime-proof-summary-cli-check.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-runtime-summary-cli-'));
+const missionId = 'M-runtime-summary-cli';
+const dir = path.join(tmp, '.sneakoscope', 'missions', missionId);
+const agents = path.join(dir, 'agents');
+await fs.mkdir(path.join(dir, 'zellij'), { recursive: true });
+await fs.mkdir(agents, { recursive: true });
+await fs.writeFile(path.join(agents, 'parallel-runtime-proof.json'), JSON.stringify({
+    schema: 'sks.parallel-runtime-proof.v1',
+    mission_id: missionId,
+    generated_at: new Date().toISOString(),
+    proof_mode: 'production',
+    require_worker_pids: true,
+    allow_missing_pids: false,
+    requested_workers: 32,
+    target_active_slots: 32,
+    max_observed_active_workers: 32,
+    max_observed_worker_processes: 32,
+    unique_worker_pids: 32,
+    unique_model_call_ids: 64,
+    max_observed_model_calls: 12,
+    launch_span_ms: 400,
+    first_batch_launch_span_ms: 400,
+    wall_ms: 12000,
+    sequential_estimate_ms: 82000,
+    speedup_ratio: 6.8,
+    overlap_windows: [],
+    visible_panes: 8,
+    headless_workers: 24,
+    utilization_proof_consistency: { ok: true, scheduler_max_active: 32, proof_max_active: 32, wall_ms_delta: 100 },
+    passed: true,
+    blockers: []
+}, null, 2));
+await fs.writeFile(path.join(agents, 'agent-scheduler-state.json'), JSON.stringify({ target_active_slots: 32, max_observed_active_slots: 32, largest_batch_size: 32, scheduler_utilization: 0.88 }, null, 2));
+await fs.writeFile(path.join(dir, 'zellij', 'slot-telemetry.snapshot.json'), JSON.stringify({ schema: 'sks.zellij-slot-telemetry-snapshot.v1', mission_id: missionId, updated_at: new Date(Date.now() - 800).toISOString(), slots: {}, counts: {} }, null, 2));
+const cli = path.join(root, 'dist', 'bin', 'sks.js');
+for (const args of [['proof', 'latest'], ['naruto', 'proof', 'latest']]) {
+    const res = spawnSync(process.execPath, [cli, ...args], { cwd: tmp, encoding: 'utf8', timeout: 30000 });
+    assertGate(res.status === 0, `${args.join(' ')} failed`, { stdout: res.stdout, stderr: res.stderr });
+    for (const token of ['Parallel proof: passed', 'Active workers: 32', 'Unique PIDs: 32', 'Visible/headless: 8 / 24', 'Model calls max: 12']) {
+        assertGate(res.stdout.includes(token), `${args.join(' ')} missing ${token}`, { stdout: res.stdout });
+    }
+}
+emitGate('runtime:proof-summary-cli', { commands: ['sks proof latest', 'sks naruto proof latest'] });
+//# sourceMappingURL=runtime-proof-summary-cli-check.js.map

package/dist/scripts/runtime-proof-summary-messages-check.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { appendAgentMessage } from '../core/agents/agent-message-bus.js';
+import { buildRuntimeProofSummary, renderRuntimeProofSummary } from '../core/agents/runtime-proof-summary.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-runtime-summary-messages-'));
+const missionId = 'M-runtime-summary-messages';
+const dir = path.join(root, '.sneakoscope', 'missions', missionId);
+const agents = path.join(dir, 'agents');
+await fs.mkdir(path.join(dir, 'zellij'), { recursive: true });
+await fs.mkdir(agents, { recursive: true });
+await fs.writeFile(path.join(agents, 'parallel-runtime-proof.json'), JSON.stringify({
+    schema: 'sks.parallel-runtime-proof.v1',
+    mission_id: missionId,
+    max_observed_active_workers: 32,
+    unique_worker_pids: 32,
+    speedup_ratio: 6,
+    visible_panes: 8,
+    headless_workers: 24,
+    passed: true,
+    blockers: []
+}, null, 2));
+await fs.writeFile(path.join(agents, 'agent-scheduler-state.json'), JSON.stringify({ target_active_slots: 32, max_observed_active_slots: 32, largest_batch_size: 32, scheduler_utilization: 0.9 }, null, 2));
+await fs.writeFile(path.join(agents, 'agent-native-cli-session-swarm.json'), JSON.stringify({ process_ids: Array.from({ length: 32 }, (_, i) => 7000 + i), zellij_pane_worker_sessions: 8, headless_overflow_worker_count: 24 }, null, 2));
+await fs.writeFile(path.join(dir, 'zellij', 'slot-telemetry.snapshot.json'), JSON.stringify({ updated_at: new Date().toISOString(), slots: {} }, null, 2));
+await appendAgentMessage(agents, { from: 'slot-001', session_id: 's1', type: 'worker_completed', body: 'implementer: patch candidate verified' });
+await appendAgentMessage(agents, { from: 'slot-008', session_id: 's8', type: 'worker_failed', body: 'qa: blocker git_worktree_merge_conflict' });
+const summary = await buildRuntimeProofSummary(root, missionId, { maxMessages: 20 });
+const rendered = renderRuntimeProofSummary(summary);
+assertGate(summary.messages.completed_count === 1 && summary.messages.failed_count === 1, 'runtime summary message counts mismatch', summary.messages);
+assertGate(summary.ok === false && summary.blockers.includes('agent_message_bus_error_blockers'), 'runtime summary must fail on error messages', summary);
+assertGate(rendered.includes('Recent worker messages:') && rendered.includes('[done]') && rendered.includes('[fail]'), 'runtime summary render must include recent worker messages', { rendered });
+emitGate('runtime:proof-summary-messages', { messages: summary.messages, blockers: summary.blockers });
+//# sourceMappingURL=runtime-proof-summary-messages-check.js.map

package/dist/scripts/runtime-proof-zellij-stacked-summary-check.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// @ts-nocheck
+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-runtime-zellij-summary-'));
+const missionId = 'M-runtime-zellij-summary';
+const dir = path.join(tmp, '.sneakoscope', 'missions', missionId);
+const agents = path.join(dir, 'agents');
+await fs.mkdir(path.join(dir, 'zellij'), { recursive: true });
+await fs.mkdir(agents, { recursive: true });
+await fs.writeFile(path.join(agents, 'parallel-runtime-proof.json'), JSON.stringify({
+    schema: 'sks.parallel-runtime-proof.v1',
+    mission_id: missionId,
+    max_observed_active_workers: 32,
+    unique_worker_pids: 32,
+    speedup_ratio: 6.8,
+    visible_panes: 8,
+    headless_workers: 24,
+    passed: true,
+    blockers: []
+}, null, 2));
+await fs.writeFile(path.join(agents, 'agent-scheduler-state.json'), JSON.stringify({ target_active_slots: 32, max_observed_active_slots: 32, largest_batch_size: 32, scheduler_utilization: 0.91 }, null, 2));
+await fs.writeFile(path.join(agents, 'agent-native-cli-session-swarm.json'), JSON.stringify({ process_ids: Array.from({ length: 32 }, (_, i) => 9000 + i), zellij_pane_worker_sessions: 8, headless_overflow_worker_count: 24 }, null, 2));
+await fs.writeFile(path.join(agents, 'naruto-concurrency-governor.json'), JSON.stringify({ target_active_slots: 32 }, null, 2));
+await fs.writeFile(path.join(dir, 'zellij', 'slot-telemetry.snapshot.json'), JSON.stringify({ schema: 'sks.zellij-slot-telemetry-snapshot.v1', mission_id: missionId, updated_at: new Date(Date.now() - 500).toISOString(), slots: {}, counts: {} }, null, 2));
+await fs.writeFile(path.join(dir, 'zellij-right-column-state.json'), JSON.stringify({ schema: 'sks.zellij-right-column-state.v1', mission_id: missionId, session_name: 'fixture', status: 'active', slot_column_anchor_pane_id: 'terminal_1', visible_worker_panes: [], headless_workers: [], blockers: [] }, null, 2));
+await fs.writeFile(path.join(tmp, 'agent-zellij-pane-launch-ledger.jsonl'), Array.from({ length: 8 }, (_, i) => JSON.stringify({
+    schema: 'sks.agent-zellij-pane-launch.v1',
+    mission_id: missionId,
+    slot_id: `slot-${String(i + 1).padStart(3, '0')}`,
+    worker_stacked_requested: i > 0,
+    worker_stacked_applied: i > 0,
+    worker_stacked_fallback_mode: i > 0 ? 'native-stacked' : null,
+    worker_stacked_capability: { supports_stacked_panes: true, parsed_version: '0.43.1' },
+    slot_column_anchor_pane_id: 'terminal_1'
+})).join('\n') + '\n');
+await fs.writeFile(path.join(dir, 'zellij', 'pane-creation-lock-events.jsonl'), [40, 70, 120, 180, 220, 260, 310, 350].map((wait, i) => JSON.stringify({
+    schema: 'sks.zellij-pane-creation-lock-metrics.v1',
+    mission_id: missionId,
+    session_name: 'fixture',
+    slot_id: `slot-${String(i + 1).padStart(3, '0')}`,
+    generation_index: 1,
+    wait_ms: wait,
+    held_ms: 300
+})).join('\n') + '\n');
+const runtime = await importDist('core/agents/runtime-proof-summary.js');
+const summary = await runtime.buildRuntimeProofSummary(tmp, missionId);
+const rendered = runtime.renderRuntimeProofSummary(summary);
+assertGate(summary.ok === true, 'runtime summary with zellij fixture must pass', summary);
+assertGate(summary.zellij.stacked_requested_count === 7 && summary.zellij.stacked_applied_count === 7, 'zellij stacked counts mismatch', summary.zellij);
+assertGate(summary.zellij.stacked_fallback_count === 0 && summary.zellij.duplicate_slot_anchor_count === 1, 'zellij fallback/anchor counts mismatch', summary.zellij);
+for (const token of ['Zellij stacked panes: 7/7 applied', 'Stack fallback: 0', 'Pane lock wait p95: 350ms', 'SLOTS anchors: 1']) {
+    assertGate(rendered.includes(token), `runtime summary output missing ${token}`, { rendered });
+}
+emitGate('runtime:proof-zellij-stacked-summary', { stacked: '7/7', pane_lock_wait_p95_ms: summary.zellij.pane_lock_wait_p95_ms });
+//# sourceMappingURL=runtime-proof-zellij-stacked-summary-check.js.map

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

@@ -0,0 +1,59 @@
+#!/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

@@ -0,0 +1,74 @@
+#!/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