sneakoscope 6.2.0 → 6.4.0

package/dist/scripts/release-pack-receipt.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import crypto from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { compareReleasePacks, inspectReleaseTarball, releaseProofDir, validateLocalReleasePackBinding, writeReleaseJson } from '../core/release/release-pack-receipt.js';
+import { normalizeNpmPackInfo, readCurrentNpmPackGateArtifacts } from '../core/release/npm-pack-proof.js';
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const action = process.argv[2] || 'create';
+const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+const proofDir = releaseProofDir(root, String(pkg.version || 'unknown'));
+if (action === 'create')
+    createLocalReceipt();
+else if (action === 'inspect')
+    inspectDownloadedReceipt();
+else if (action === 'compare')
+    compareReceipts();
+else
+    fail(`unknown action: ${action}`);
+function createLocalReceipt() {
+    const outputDir = path.resolve(root, option('--output-dir') || path.join(proofDir, 'artifacts'));
+    fs.mkdirSync(outputDir, { recursive: true });
+    const result = spawnSync('npm', ['pack', '--ignore-scripts', '--json', '--pack-destination', outputDir], {
+        cwd: root,
+        encoding: 'utf8',
+        maxBuffer: 32 * 1024 * 1024,
+        env: { ...process.env, npm_config_cache: process.env.SKS_RELEASE_NPM_CACHE || path.join(os.tmpdir(), 'sneakoscope-npm-cache') }
+    });
+    if (result.status !== 0)
+        fail('npm pack failed', result.stderr || result.stdout);
+    let info;
+    try {
+        const parsed = JSON.parse(String(result.stdout || '[]'));
+        info = Array.isArray(parsed) ? parsed[0] : parsed;
+    }
+    catch {
+        fail('npm pack output was not JSON');
+    }
+    const tarball = path.join(outputDir, String(info?.filename || ''));
+    const gate = readCurrentNpmPackGateArtifacts(root);
+    const receipt = inspectReleaseTarball({
+        tarball,
+        kind: 'local',
+        sourceCommit: gitHead(),
+        root,
+        ...(gate.ok && gate.proof ? {
+            npmPackProof: {
+                proof_id: gate.proof.proof_id,
+                info_sha256: gate.proof.info_digest,
+                file_list_sha256: gate.proof.file_list_digest
+            }
+        } : {})
+    });
+    if (!gate.ok)
+        receipt.blockers.push(...gate.blockers.map((blocker) => `npm_pack_gate:${blocker}`));
+    const normalizedInfo = normalizeNpmPackInfo(info || {});
+    const actualInfoSha256 = sha256Json(normalizedInfo);
+    const actualFileListSha256 = sha256Json(normalizedInfo.files);
+    if (gate.proof && gate.proof.info_digest !== actualInfoSha256)
+        receipt.blockers.push('npm_pack_proof_info_digest_mismatch');
+    if (gate.proof && gate.proof.file_list_digest !== actualFileListSha256)
+        receipt.blockers.push('npm_pack_proof_file_list_digest_mismatch');
+    if (receipt.package_name !== pkg.name)
+        receipt.blockers.push('pack_metadata_name_mismatch');
+    if (receipt.package_version !== pkg.version)
+        receipt.blockers.push('pack_metadata_version_mismatch');
+    if (Number(info?.size || 0) !== receipt.bytes)
+        receipt.blockers.push('pack_metadata_size_mismatch');
+    if (Number(info?.unpackedSize || 0) !== receipt.unpacked_bytes)
+        receipt.blockers.push('pack_metadata_unpacked_size_mismatch');
+    if (Number(info?.entryCount || 0) !== receipt.file_count)
+        receipt.blockers.push('pack_metadata_file_count_mismatch');
+    if (String(info?.integrity || '') !== receipt.sha512_integrity)
+        receipt.blockers.push('pack_metadata_integrity_mismatch');
+    receipt.ok = receipt.blockers.length === 0;
+    const binding = validateLocalReleasePackBinding(root, receipt);
+    if (!binding.ok)
+        receipt.blockers.push(...binding.blockers.map((blocker) => `local_binding:${blocker}`));
+    receipt.blockers = [...new Set(receipt.blockers)];
+    receipt.ok = receipt.blockers.length === 0;
+    const file = path.join(proofDir, 'pack-receipt.json');
+    writeReleaseJson(file, receipt);
+    emit(receipt, file);
+}
+function inspectDownloadedReceipt() {
+    const tarball = required('--tarball');
+    const kind = String(option('--kind') || 'staged');
+    if (kind !== 'local' && kind !== 'staged')
+        fail('--kind must be local or staged');
+    const receipt = inspectReleaseTarball({ tarball, kind, sourceCommit: option('--source-commit') || null, root });
+    const file = path.resolve(root, option('--output') || path.join(proofDir, `${kind}-pack-receipt.json`));
+    writeReleaseJson(file, receipt);
+    emit(receipt, file);
+}
+function compareReceipts() {
+    const local = readReceipt(required('--local'));
+    const staged = readReceipt(required('--staged'));
+    const comparison = compareReleasePacks(local, staged);
+    const binding = validateLocalReleasePackBinding(root, local);
+    if (!binding.ok)
+        comparison.blockers.push(...binding.blockers.map((blocker) => `local_binding:${blocker}`));
+    comparison.blockers = [...new Set(comparison.blockers)];
+    comparison.ok = comparison.blockers.length === 0;
+    const file = path.resolve(root, option('--output') || path.join(proofDir, 'pack-compare.json'));
+    writeReleaseJson(file, comparison);
+    emit(comparison, file);
+}
+function readReceipt(file) {
+    try {
+        return JSON.parse(fs.readFileSync(path.resolve(root, file), 'utf8'));
+    }
+    catch (error) {
+        fail(`unable to read receipt ${file}`, error?.message || String(error));
+    }
+}
+function gitHead() {
+    const result = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: root, encoding: 'utf8' });
+    return result.status === 0 ? String(result.stdout || '').trim() || null : null;
+}
+function sha256Json(value) {
+    return crypto.createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function required(name) {
+    const value = option(name);
+    if (!value)
+        fail(`${name} is required`);
+    return value;
+}
+function option(name) {
+    const index = process.argv.indexOf(name);
+    return index >= 0 ? String(process.argv[index + 1] || '').trim() : '';
+}
+function emit(value, file) {
+    console.log(JSON.stringify({ ...value, receipt_path: path.relative(root, file).split(path.sep).join('/') }, null, 2));
+    process.exit(value.ok === true ? 0 : 1);
+}
+function fail(message, detail = '') {
+    console.error(`Release pack receipt failed: ${message}`);
+    if (detail)
+        console.error(String(detail).trim());
+    process.exit(2);
+}

package/dist/scripts/release-parallel-speed-budget-check.js

@@ -104,4 +104,3 @@ function slowestGateResults(reportDir) {
     }
     return out.sort((a, b) => b.duration_ms - a.duration_ms).slice(0, 10);
 }
-//# sourceMappingURL=release-parallel-speed-budget-check.js.map

package/dist/scripts/release-proof-truth-check.js

@@ -11,4 +11,3 @@ assertGate(Boolean(truth.package_json_sha256 && truth.package_lock_sha256 && tru
 assertGate(fs.existsSync(path.join(root, '.sneakoscope', 'release-proof-truth.json')), 'root release proof truth artifact missing');
 assertGate(fs.existsSync(path.join(root, 'dist', 'release-proof-truth.json')), 'dist release proof truth artifact missing');
 emitGate('release:proof-truth', truth);
-//# sourceMappingURL=release-proof-truth-check.js.map

package/dist/scripts/release-provenance-check.js

@@ -143,4 +143,3 @@ function tail(value, limit = 1000) {
     const text = String(value || '');
     return text.length > limit ? text.slice(-limit) : text;
 }
-//# sourceMappingURL=release-provenance-check.js.map

package/dist/scripts/release-real-check.js

@@ -93,7 +93,7 @@ const tasks = [
     task('codex:0144:app-server-v2:real', 'direct', { command: nodeScript('codex-0144-app-server-v2-check.js'), group: 'environment_required', phase: 'parallel_processing', args: ['--require-real'], policy: requiredPolicy(['sks.release-gate.v1']) }),
     task('codex:0144:capability:real', 'direct', { command: nodeScript('codex-0144-capability-check.js'), group: 'environment_required', phase: 'parallel_verification', args: ['--require-real'], deps: ['codex:0144:app-server-v2:real'], policy: requiredPolicy(['sks.release-gate.v1']) }),
     task('doctor:actual', 'direct', { command: [process.execPath, './dist/bin/sks.js', 'doctor', '--json'], group: 'environment_required', phase: 'parallel_processing', policy: requiredPolicy(['sks.doctor-status.v3'], { statusRequired: true, passStatuses: ['fast_readonly_ok', 'ok'] }) }),
-    task('publish:dry-run-performance', 'publish:dry-run-performance', { group: 'environment_required', phase: 'parallel_processing', policy: requiredPolicy(['sks.npm-publish-performance.v1', 'sks.release-gate.v1']) }),
+    task('release:pack-receipt', 'release:pack-receipt', { group: 'environment_required', phase: 'parallel_processing', policy: requiredPolicy(['sks.release-pack-receipt.v1']) }),
     task('zellij:capability', 'zellij:capability', { group: 'environment_required', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, policy: requiredPolicy(['sks.zellij-capability.v1', 'sks.zellij-capability-check.v1'], { statusRequired: true, passStatuses: ['ok'] }) }),
     task('zellij:layout-valid', 'zellij:layout-valid', { group: 'environment_required', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_ZELLIJ: '1' }, deps: ['zellij:capability'], policy: requiredPolicy(['sks.zellij-layout-valid-check.v1']) }),
     task('zellij:real-session-launch', 'direct', { command: nodeScript('zellij-real-session-launch-check.js'), group: 'real_ui', phase: 'parallel_verification', args: ['--require-real', '--main-only', '--owned-session', '--mission', zellijMissionId, '--session', zellijSessionName], env: zellijOwnedEnv, deps: ['zellij:layout-valid'], policy: requiredPolicy(['sks.zellij-real-session-launch-check.v1']) }),
@@ -102,7 +102,6 @@ const tasks = [
     task('zellij:real-session-cleanup', 'direct', { command: nodeScript('zellij-real-session-cleanup-check.js'), group: 'real_ui', phase: 'aggregation', args: ['--mission', zellijMissionId, '--session', zellijSessionName, '--owned-socket-dir', zellijSocketDir], env: zellijOwnedEnv, deps: ['zellij:pane-proof', 'zellij:screen-proof'], alwaysRun: true, policy: requiredPolicy(['sks.zellij-real-session-cleanup-check.v1']) }),
     task('naruto:worktree-coding:blackbox', 'direct', { command: nodeScript('naruto-worktree-coding-blackbox.js'), group: 'real_smoke', phase: 'parallel_processing', args: ['--require-real'], env: { SKS_REQUIRE_GIT_WORKTREE: '1' }, policy: requiredPolicy(['sks.release-gate.v1']) }),
     task('codex-sdk:real-smoke', 'direct', { command: nodeScript('codex-sdk-real-smoke-check.js'), group: 'real_smoke', phase: 'parallel_processing', args: ['--require-real'], policy: requiredPolicy(['sks.release-gate.v1'], { statusRequired: true, passStatuses: ['proven'] }) }),
-    task('agent:real-codex-parallel-workers-5', 'direct', { command: nodeScript('agent-real-codex-parallel-workers-5-check.js'), group: 'real_smoke', phase: 'parallel_processing', policy: liveOptionalPolicy(['sks.release-gate.v1', 'sks.real-codex-parallel-gate.v1']) }),
     task('imagegen:real-smoke', 'direct', { command: nodeScript('imagegen-real-smoke-check.js'), group: 'real_smoke', phase: 'parallel_processing', policy: liveOptionalPolicy(['sks.imagegen-real-smoke.v1'], ['passed']) }),
     task('ux-review:real-imagegen-smoke', 'direct', { command: nodeScript('ux-review-real-imagegen-smoke-check.js'), group: 'real_smoke', phase: 'parallel_processing', deps: ['imagegen:real-smoke'], policy: liveOptionalPolicy(['sks.ux-real-imagegen-smoke.v1'], ['passed']) }),
     task('ppt:real-imagegen-smoke', 'direct', { command: nodeScript('ppt-real-imagegen-smoke-check.js'), group: 'real_smoke', phase: 'parallel_processing', deps: ['imagegen:real-smoke'], policy: liveOptionalPolicy(['sks.ppt-real-imagegen-smoke.v1'], ['passed']) })
@@ -568,4 +567,3 @@ function sha256File(file) {
         return null;
     }
 }
-//# sourceMappingURL=release-real-check.js.map

package/dist/scripts/release-runtime-truth-matrix-check.js

@@ -19,4 +19,3 @@ emitGate('release:runtime-truth-matrix', {
     rows: matrix.rows.length,
     priorities: matrix.priorities
 });
-//# sourceMappingURL=release-runtime-truth-matrix-check.js.map

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

@@ -64,4 +64,3 @@ function latestRuntimeProofSummaryPath() {
         .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
     return files[0] || null;
 }
-//# sourceMappingURL=release-speed-summary.js.map

package/dist/scripts/release-version-truth-check.js

@@ -137,4 +137,3 @@ function tail(value, limit = 1000) {
     const text = String(value || '');
     return text.length > limit ? text.slice(-limit) : text;
 }
-//# sourceMappingURL=release-version-truth-check.js.map

package/dist/scripts/research-blueprint-densifier-check.js

@@ -16,6 +16,5 @@ assertGate(blueprint.repository_aware === true || (blueprint.domain_research ===
 assertGate((blueprint.existing_files || []).length > 0, 'blueprint must list concrete existing files', blueprint);
 assertGate((blueprint.sections || []).length >= 8, 'blueprint must keep required sections', blueprint);
 assertGate((blueprint.test_commands || []).some((cmd) => /^(?:procedure:|npm |node |cargo )/.test(String(cmd))), 'blueprint must include concrete verification commands or procedures', blueprint);
-assertGate(fs.existsSync(path.join(dir, 'team-handoff-goal.md')), 'team handoff goal must exist');
+assertGate(fs.existsSync(path.join(dir, 'naruto-handoff-goal.md')), 'Naruto handoff goal must exist');
 emitGate('research:blueprint-densifier', { dir, sections: blueprint.sections.length, files: blueprint.existing_files.length });
-//# sourceMappingURL=research-blueprint-densifier-check.js.map

package/dist/scripts/research-claim-builder-check.js

@@ -16,4 +16,3 @@ assertGate(matrix.key_claim_ids.length >= 8, 'claim builder must produce key cla
 assertGate(matrix.triangulated_claim_count >= 6, 'claim builder must triangulate claims', matrix);
 assertGate((matrix.unsupported_claims || []).length === 0, 'claim builder must not leave important claims unsupported in complete fixture', matrix);
 emitGate('research:claim-builder', { dir, key_claims: matrix.key_claim_ids.length, triangulated: matrix.triangulated_claim_count });
-//# sourceMappingURL=research-claim-builder-check.js.map

package/dist/scripts/research-complete-package-fixture-check.js

@@ -26,4 +26,3 @@ assertGate(reportQuality.ok === true, 'complete package report must pass anti-te
 assertGate(reportQuality.repetition.repeated_paragraph_ratio <= 0.18, 'complete package must not rely on repeated paragraphs', reportQuality.repetition);
 assertGate(reportQuality.repetition.template_phrase_hits.length === 0, 'complete package must not contain template phrases', reportQuality.repetition);
 emitGate('research:complete-package-fixture', { dir, metrics, report_quality: reportQuality });
-//# sourceMappingURL=research-complete-package-fixture-check.js.map

package/dist/scripts/research-execution-profile-routing-check.js

@@ -1,4 +1,3 @@
 #!/usr/bin/env node
 import { runDirective315Gate } from './sks-3-1-5-directive-check-lib.js';
 await runDirective315Gate('research:execution-profile-routing');
-//# sourceMappingURL=research-execution-profile-routing-check.js.map

package/dist/scripts/research-final-reviewer-blackbox.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const research = await importDist('core/research.js');
+const reviewer = await importDist('core/research/research-final-reviewer.js');
+const fsx = await importDist('core/fsx.js');
+const badDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-final-review-bad-'));
+await research.writeResearchPlan(badDir, 'bad final reviewer fixture', { missionId: 'M-FINAL-BAD' });
+await fsx.writeTextAtomic(path.join(badDir, 'research-report.md'), '# Bad\n\nToo short.\n');
+const bad = await reviewer.runResearchFinalReviewer(badDir, { codexRequired: true });
+assertGate(bad.approved === false, 'static failure must not approve final review', bad);
+const templateDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-final-review-template-'));
+const templatePlan = await research.writeResearchPlan(templateDir, 'template final reviewer fixture', { missionId: 'M-FINAL-TEMPLATE' });
+await research.writeMockResearchResult(templateDir, templatePlan);
+await fsx.writeTextAtomic(path.join(templateDir, 'research-report.md'), [
+    '# SKS Research Report',
+    '',
+    '## Question',
+    'Runtime evidence note: This paragraph exists to make report quality measurable.',
+    '',
+    '## Methodology',
+    'Runtime evidence note: This paragraph exists to make report quality measurable.',
+    '',
+    '## Source Map',
+    'mock-source-1 mock-source-2 mock-source-3 mock-source-4 mock-source-5 mock-source-6 mock-source-7 mock-source-8.',
+    '',
+    '## Key Claims',
+    '- mock-claim-1 cites mock-source-1 and mock-counter-1.',
+    '',
+    '## Evidence Matrix Summary',
+    Array.from({ length: 36 }, () => 'Runtime evidence note: This paragraph exists to make report quality measurable while deterministic fixture text repeats the same sentence for mock-claim-1 using mock-source-1 and mock-counter-1.').join('\n\n'),
+    '',
+    '## Counterevidence',
+    'mock-counter-1 and mock-counter-2 challenge the report.',
+    '',
+    '## Falsification',
+    'Runtime evidence note: This paragraph exists to make report quality measurable.',
+    '',
+    '## Implementation Blueprint',
+    'Runtime evidence note: This paragraph exists to make report quality measurable.',
+    '',
+    '## Experiment / Validation Plan',
+    'Runtime evidence note: This paragraph exists to make report quality measurable.',
+    '',
+    '## Limitations',
+    'Runtime evidence note: This paragraph exists to make report quality measurable.',
+    '',
+    '## References',
+    '- mock-source-1',
+    '- mock-counter-1'
+].join('\n\n'));
+await fsx.rmrf(path.join(templateDir, 'research-final-review.codex.json'));
+const template = await reviewer.runResearchFinalReviewer(templateDir, { codexRequired: true });
+assertGate(template.approved === false, 'template/repeated report must not approve final review', template);
+assertGate((template.blockers || []).some((reason) => String(reason).includes('research_report_repeated_paragraphs') || String(reason).includes('research_report_template_phrase_hit')), 'template blockers must include repetition/template reasons', template);
+const goodDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-research-final-review-good-'));
+const plan = await research.writeResearchPlan(goodDir, 'good final reviewer fixture', { missionId: 'M-FINAL-GOOD' });
+await research.writeMockResearchResult(goodDir, plan);
+const good = JSON.parse(fs.readFileSync(path.join(goodDir, 'research-final-review.json'), 'utf8'));
+assertGate(good.approved === true, 'complete package must approve final review with mock Codex reviewer', good);
+assertGate(good.codex_review?.verdict === 'approve', 'merged final review must include Codex/mock approval', good);
+assertGate(good.codex_review?.template_like_prose === false, 'mock Codex review must preserve template_like_prose=false', good);
+assertGate(good.codex_review?.source_density_ok === true, 'mock Codex review must preserve source_density_ok=true', good);
+assertGate(good.codex_review?.implementation_concreteness_ok === true, 'mock Codex review must preserve implementation_concreteness_ok=true', good);
+assertGate(good.codex_review?.evidence_bound_synthesis_ok === true, 'mock Codex review must preserve evidence_bound_synthesis_ok=true', good);
+emitGate('research:final-reviewer-blackbox', { bad_dir: badDir, template_dir: templateDir, good_dir: goodDir });

package/dist/scripts/responses-retry-policy-centralized-check.js

@@ -16,4 +16,3 @@ emit({ schema: 'sks.responses-retry-policy-centralized-check.v1', ok, policy });
 function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
     process.exitCode = 1; }
 function fail(blocker, detail) { emit({ schema: 'sks.responses-retry-policy-centralized-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-//# sourceMappingURL=responses-retry-policy-centralized-check.js.map

package/dist/scripts/retention-apply-smoke-check.js

@@ -18,4 +18,3 @@ const status = await retentionStatus(root);
 assertGate(applied.ok === true, 'retention apply smoke must accept matching dry-run plan hash', applied);
 assertGate(status.mission_index?.ok !== false, 'retention apply smoke must keep status readable', status);
 emitGate('retention:apply-smoke', { action_count: applied.action_count || 0, plan_hash: planned.plan.plan_hash });
-//# sourceMappingURL=retention-apply-smoke-check.js.map

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

@@ -5,4 +5,3 @@ const { runRetentionBudget } = await importDist('core/retention/retention-budget
 const report = await runRetentionBudget(root);
 assertGate(report.ok, 'retention_budget_failed', report);
 emitGate('retention:budget', { budgets: report.budgets.length, oversized_jsonl: report.oversized_jsonl.length });
-//# sourceMappingURL=retention-budget-check.js.map

package/dist/scripts/retention-dry-run-check.js

@@ -7,4 +7,3 @@ const status = await retentionStatus(root);
 assertGate(Boolean(result.plan?.plan_hash), 'retention dry run must write a plan hash', result);
 assertGate(status.mission_index?.ok !== false, 'retention dry run must keep mission index readable', status);
 emitGate('retention:dry-run', { action_count: result.actions.length, plan_hash: result.plan.plan_hash });
-//# sourceMappingURL=retention-dry-run-check.js.map

package/dist/scripts/rollback-recovery-smoke-check.js

@@ -69,4 +69,3 @@ async function runScenario(scenario) {
         blocked_reasons: blockers.filter((blocker) => blocker === 'rollback_manifest_missing_blocks_rollback')
     };
 }
-//# sourceMappingURL=rollback-recovery-smoke-check.js.map

package/dist/scripts/route-intent-regression-check.js

@@ -41,4 +41,3 @@ emitGate('route:intent-regression', {
     checked: results.length,
     results
 });
-//# sourceMappingURL=route-intent-regression-check.js.map

package/dist/scripts/{runtime-no-tmux-check.js → runtime-current-terminal-check.js}

@@ -5,15 +5,11 @@ 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',
+    'docs/zellij-ui.md',
+    'dist/scripts/runtime-current-terminal-check.js',
+    'src/scripts/runtime-current-terminal-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'
+    'src/core/commands/basic-cli.ts'
 ]);
 const legacyFixtureFileRe = /^(scripts|test)\/.*(?:tmux|real-tmux|warp-right-lane).*$/;
 const runtimePatterns = [
@@ -58,7 +54,7 @@ for (const base of scanRoots) {
 }
 const ok = issues.length === 0;
 emit({
-    schema: 'sks.runtime-no-tmux-check.v1',
+    schema: 'sks.runtime-current-terminal-check.v1',
     ok,
     scan_roots: scanRoots,
     issues,
@@ -87,7 +83,7 @@ async function listFiles(target) {
 function inspectPackageJson(text) {
     const pkg = JSON.parse(text);
     for (const [name, command] of Object.entries(pkg.scripts || {})) {
-        if (name === 'runtime:no-tmux')
+        if (name === 'runtime:terminal-current')
             continue;
         if (/^(tmux:|agent:tmux-)|warp-right-lane|real-tmux/i.test(name)) {
             issues.push({ file: 'package.json', script: name, pattern: 'tmux_script_name' });
@@ -111,4 +107,3 @@ function inspectRuntimeRecommendations(rel, text) {
 }
 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-dist-parity-check.js

@@ -75,4 +75,3 @@ function walk(dir, out = []) {
 function sha256(text) {
     return crypto.createHash('sha256').update(text).digest('hex');
 }
-//# sourceMappingURL=runtime-dist-parity-check.js.map

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

@@ -29,4 +29,3 @@ function walk(dir, out = []) {
     }
     return out;
 }
-//# sourceMappingURL=runtime-no-src-mjs-check.js.map

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

@@ -38,7 +38,7 @@ await fs.writeFile(path.join(agents, 'parallel-runtime-proof.json'), `${JSON.str
     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, 'native-cli-worker-runtime.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);
@@ -55,4 +55,3 @@ async function exists(file) {
         return false;
     }
 }
-//# sourceMappingURL=runtime-proof-summary-check.js.map

package/dist/scripts/runtime-script-pack-closure-check.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { DEFAULT_MAX_PACK_BYTES, DEFAULT_MAX_UNPACKED_BYTES } from '../core/release/package-size-budget.js';
+import { analyzeRuntimeScriptPackClosure } from '../core/release/runtime-script-pack-closure.js';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const MAX_FILES = Number(process.env.SKS_MAX_PACK_FILES || 2100);
+const MAX_PACKED = Number(process.env.SKS_MAX_PACK_BYTES || DEFAULT_MAX_PACK_BYTES);
+const MAX_UNPACKED = Number(process.env.SKS_MAX_UNPACKED_BYTES || DEFAULT_MAX_UNPACKED_BYTES);
+const analysis = analyzeRuntimeScriptPackClosure(root);
+assertGate(analysis.declaration_issues.length === 0, 'runtime_script_allowlist_declaration_invalid', {
+    issues: analysis.declaration_issues
+});
+assertGate(analysis.missing_references.length === 0, 'runtime_script_reference_missing', {
+    missing_references: analysis.missing_references
+});
+assertGate(analysis.uncovered_dynamic_references.length === 0, 'runtime_script_dynamic_reference_uncovered', {
+    uncovered: analysis.uncovered_dynamic_references
+});
+assertGate(analysis.stale_dynamic_reference_policies.length === 0, 'runtime_script_dynamic_reference_policy_stale', {
+    stale: analysis.stale_dynamic_reference_policies
+});
+assertGate(analysis.missing_from_allowlist.length === 0, 'runtime_script_allowlist_missing_closure', {
+    missing: analysis.missing_from_allowlist
+});
+assertGate(analysis.stale_allowlist_entries.length === 0, 'runtime_script_allowlist_stale_entries', {
+    stale: analysis.stale_allowlist_entries
+});
+const npmCache = process.env.SKS_RELEASE_NPM_CACHE || path.join(os.tmpdir(), 'sneakoscope-npm-cache');
+fs.mkdirSync(npmCache, { recursive: true });
+const npmCli = process.env.npm_execpath;
+const args = ['pack', '--dry-run', '--ignore-scripts', '--json'];
+const options = {
+    cwd: root,
+    encoding: 'utf8',
+    maxBuffer: 32 * 1024 * 1024,
+    env: { ...process.env, npm_config_cache: npmCache, NPM_CONFIG_CACHE: npmCache }
+};
+const packed = npmCli
+    ? spawnSync(process.execPath, [npmCli, ...args], options)
+    : spawnSync(process.platform === 'win32' ? 'npm.cmd' : 'npm', args, options);
+assertGate(packed.status === 0, 'runtime_script_pack_dry_run_failed', { stderr: packed.stderr || '', stdout: packed.stdout || '' });
+let info = null;
+try {
+    const parsed = JSON.parse(packed.stdout || 'null');
+    info = Array.isArray(parsed) ? parsed[0] : parsed;
+}
+catch (error) {
+    assertGate(false, 'runtime_script_pack_dry_run_unparseable', { error: String(error) });
+}
+assertGate(Boolean(info && Array.isArray(info.files)), 'runtime_script_pack_dry_run_missing_info');
+const packedScripts = info.files
+    .map((entry) => String(entry.path || ''))
+    .filter((file) => file.startsWith('dist/scripts/') && file.endsWith('.js'))
+    .sort();
+assertGate(JSON.stringify(packedScripts) === JSON.stringify(analysis.closure), 'runtime_script_packed_closure_mismatch', {
+    missing: analysis.closure.filter((file) => !packedScripts.includes(file)),
+    unexpected: packedScripts.filter((file) => !analysis.closure.includes(file))
+});
+assertGate(Number(info.entryCount) <= MAX_FILES, 'runtime_script_pack_file_count_over_limit', { actual: info.entryCount, limit: MAX_FILES });
+assertGate(Number(info.size) <= MAX_PACKED, 'runtime_script_pack_packed_bytes_over_limit', { actual: info.size, limit: MAX_PACKED });
+assertGate(Number(info.unpackedSize) <= MAX_UNPACKED, 'runtime_script_pack_unpacked_bytes_over_limit', { actual: info.unpackedSize, limit: MAX_UNPACKED });
+const report = {
+    ...analysis,
+    ok: true,
+    generated_at: new Date().toISOString(),
+    pack: {
+        filename: info.filename,
+        entry_count: info.entryCount,
+        packed_bytes: info.size,
+        unpacked_bytes: info.unpackedSize,
+        max_files: MAX_FILES,
+        max_packed_bytes: MAX_PACKED,
+        max_unpacked_bytes: MAX_UNPACKED
+    },
+    blockers: []
+};
+const output = path.join(root, '.sneakoscope', 'reports', 'runtime-script-pack-closure.json');
+fs.mkdirSync(path.dirname(output), { recursive: true });
+fs.writeFileSync(output, `${JSON.stringify(report, null, 2)}\n`);
+emitGate('publish:runtime-script-closure', {
+    candidates: analysis.candidates.length,
+    packed_scripts: analysis.closure.length,
+    excluded_scripts: analysis.excluded.length,
+    closure_sha256: analysis.closure_sha256,
+    dynamic_reference_warnings: analysis.dynamic_reference_warnings.length
+});

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

@@ -13,7 +13,7 @@ import { root, assertGate, emitGate, importDist, readText, readJson } from './sk
 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:prep-ignore-scripts', 'publish:ignore-scripts', 'publish:npm']) {
+for (const s of ['prepack', 'prepublishOnly', 'release:pack-receipt', 'runtime:installed-smoke', '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.
@@ -71,4 +71,3 @@ 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

@@ -52,4 +52,3 @@ function walk(dir, out = []) {
     }
     return out;
 }
-//# sourceMappingURL=runtime-ts-source-of-truth-check.js.map

package/dist/scripts/scheduler-batch-dispatch-check.js

@@ -14,4 +14,3 @@ const partition = { slices: Array.from({ length: count }, (_, i) => ({ id: `w${i
 const result = await runAgentScheduler({ root: ledgerRoot, missionId, rootHash: 'fixture', roster, partition, targetActiveSlots: count, maxActiveSlots: count, launchSession: async ({ generation, agent, workItem }) => ({ schema: 'sks.agent-result.v1', mission_id: missionId, agent_id: agent.id, session_id: generation.session_id, persona_id: agent.persona_id, task_slice_id: workItem.id, status: 'done', backend: 'fake', summary: 'ok', findings: [], proposed_changes: [], changed_files: [], lease_compliance: { ok: true, violations: [] }, artifacts: [], blockers: [], confidence: 'high', handoff_notes: '', unverified: [], writes: [], recursion_guard: { ok: true, violations: [] }, verification: { status: 'passed', checks: [] } }) });
 assertGate(result.state.batch_dispatch_count >= 1 && result.state.largest_batch_size >= result.state.target_active_slots, 'scheduler did not dispatch a full effective launch batch', result.state);
 emitGate('scheduler:batch-dispatch', result.state);
-//# sourceMappingURL=scheduler-batch-dispatch-check.js.map

package/dist/scripts/scheduler-parallel-proof-consistency-check.js

@@ -62,4 +62,3 @@ const proof = await writeParallelRuntimeProof(root, missionId, {
 assertGate(proof.utilization_proof_consistency?.ok === true, 'scheduler/proof consistency must pass', proof);
 assertGate(proof.utilization_proof_consistency.scheduler_max_active >= workers - 1 && proof.utilization_proof_consistency.proof_max_active >= workers - 1, 'scheduler and proof max active counts must roughly agree', proof);
 emitGate('scheduler:parallel-proof-consistency', proof.utilization_proof_consistency);
-//# sourceMappingURL=scheduler-parallel-proof-consistency-check.js.map

package/dist/scripts/scheduler-utilization-integral-check.js

@@ -102,4 +102,3 @@ assertFixtureWallTime('2-slot', two);
 assertActiveTimeIntegral('2-slot', two);
 assertSchedulerShape('2-slot', two, 0.75);
 emitGate('scheduler:utilization-integral', { ten: ten.state, two: two.state });
-//# sourceMappingURL=scheduler-utilization-integral-check.js.map

package/dist/scripts/search-visibility-gate-lib.js

@@ -121,4 +121,3 @@ function walk(dir, out) {
             out.push(full);
     }
 }
-//# sourceMappingURL=search-visibility-gate-lib.js.map

package/dist/scripts/secret-preservation-check.js

@@ -8,4 +8,3 @@ const snapshot = await captureSecretPreservationSnapshot({ root });
 assertGate(snapshot.fingerprints.length >= 2, 'secret snapshot must capture protected Supabase keys', snapshot);
 assertGate(!JSON.stringify(snapshot).includes('secret-value-123'), 'secret snapshot must not store raw values', snapshot);
 emitGate('secret:preservation', { fingerprints: snapshot.fingerprints.length });
-//# sourceMappingURL=secret-preservation-check.js.map

package/dist/scripts/secret-preservation-guard-check.js

@@ -34,4 +34,3 @@ const restoredAfterChange = await fs.readFile(envFile, 'utf8');
 assertGate(changeBlocked, 'secret preservation guard must block changed protected key values');
 assertGate(restoredAfterChange.includes('guard-secret') && !restoredAfterChange.includes('changed-secret'), 'secret preservation guard must roll back changed protected values');
 emitGate('secret:preservation-guard');
-//# sourceMappingURL=secret-preservation-guard-check.js.map

package/dist/scripts/seo-audit-fixture-check.js

@@ -11,6 +11,5 @@ const proof = assertMissionArtifact(json.mission_id, 'completion-proof.json', fi
 assertGate(inventory.detected_adapter.adapterId === 'static-site', 'fixture should detect static-site adapter', inventory.detected_adapter);
 assertGate(Array.isArray(findings.findings) && findings.findings.every((finding) => finding.evidence?.length > 0), 'SEO findings must be atomic and evidence-backed', findings);
 assertGate(gate.route === '$SEO-GEO-OPTIMIZER' && gate.completion_proof.endsWith('/completion-proof.json'), 'seo gate must link completion proof', gate);
-assertGate(proof.schema === 'sks.completion-proof.v1' && proof.route === '$SEO-GEO-OPTIMIZER', 'completion proof must retain unified route identity', proof);
+assertGate(proof.schema === 'sks.completion-proof.v1' && proof.route === '$sks-seo-geo-optimizer', 'completion proof must retain current public route identity', proof);
 emitGate('seo:audit-fixture', { mission_id: json.mission_id, findings: findings.findings.length });
-//# sourceMappingURL=seo-audit-fixture-check.js.map

package/dist/scripts/seo-cli-blackbox-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, runSks, runSksJson } from './search-visibility-gate-lib.js';
+const commands = runSksJson(['commands', '--json']).json;
+assertGate(commands.commands.some((row) => row.name === 'seo-geo-optimizer' && /unified SEO\/GEO optimizer/i.test(row.description)), 'commands --json must expose seo-geo-optimizer');
+assertGate(!commands.commands.some((row) => row.name === 'seo' || row.name === 'geo'), 'commands --json must not expose split seo/geo command surfaces');
+const optimizerUsage = runSks(['usage', 'seo-geo-optimizer']);
+assertGate(/sks seo-geo-optimizer \[seo\|geo\] doctor\|audit\|plan\|apply\|verify\|status\|rollback\|fixture/.test(optimizerUsage.stdout), 'usage seo-geo-optimizer must expose unified lifecycle');
+const doctor = runSksJson(['seo-geo-optimizer', 'doctor', '--mode', 'seo', '--json']).json;
+assertGate(doctor.route === '$SEO-GEO-OPTIMIZER' && doctor.schema === 'sks.search-visibility.doctor-command.v1', 'optimizer seo doctor must preserve unified route identity', doctor);
+const invalid = runSks(['seo-geo-optimizer', 'nonsense-subcommand'], { allowFailure: true });
+assertGate(invalid.status === 2 && /Usage: sks seo-geo-optimizer/.test(invalid.stderr), 'invalid optimizer subcommand must exit 2 with usage', {
+    status: invalid.status,
+    stdout: invalid.stdout,
+    stderr: invalid.stderr,
+});
+emitGate('seo:cli-blackbox', { adapter: doctor.adapter, confidence: doctor.confidence });

package/dist/scripts/seo-geo-geo-disambiguation-check.js

@@ -9,4 +9,3 @@ assertGate(commandFor('SEO audit canonical sitemap metadata') === '$SEO-GEO-OPTI
 assertGate(commandFor('fix GeoIP regional redirect bug') !== '$SEO-GEO-OPTIMIZER', 'GeoIP/geolocation request must not route to optimizer');
 assertGate(commandFor('map coordinates and location permission issue') !== '$SEO-GEO-OPTIMIZER', 'location permission request must not route to optimizer');
 emitGate('seo-geo:geo-disambiguation');
-//# sourceMappingURL=seo-geo-geo-disambiguation-check.js.map

package/dist/scripts/seo-geo-route-identity-check.js

@@ -35,4 +35,3 @@ assertGate(/\$SEO-GEO-OPTIMIZER/.test(geoText) && /sks seo-geo-optimizer/.test(g
 assertGate(!/\$AutoResearch/.test(seoText) && !/\$AutoResearch/.test(geoText), 'SEO/GEO route identity must not collapse into AutoResearch', { seo, geo });
 assertGate(!fs.existsSync(fixture), 'SEO/GEO route identity fixture must be removed after the check', { fixture });
 emitGate('seo-geo:route-identity', { seo_status: seo.status, geo_status: geo.status, hermetic_fixture_removed: true });
-//# sourceMappingURL=seo-geo-route-identity-check.js.map