sneakoscope 6.2.0 → 6.4.0

package/dist/scripts/sks-uninstall-regression-check.js

@@ -51,4 +51,3 @@ emitGate('sks:uninstall-regression', { removed_steps: applied.removed.length, in
 async function exists(file) {
     return fs.stat(file).then(() => true, () => false);
 }
-//# sourceMappingURL=sks-uninstall-regression-check.js.map

package/dist/scripts/sksd-daemon-check.js

@@ -16,4 +16,3 @@ try {
 finally {
     await fs.rm(fixtureRoot, { recursive: true, force: true });
 }
-//# sourceMappingURL=sksd-daemon-check.js.map

package/dist/scripts/supabase-secret-preservation-blackbox.js

@@ -26,4 +26,3 @@ const restored = await fs.readFile(envFile, 'utf8');
 assertGate(blocked, 'Supabase value mutation must be blocked after rollback');
 assertGate(restored.includes('super-secret-anon') && !restored.includes('mutated-secret'), 'Supabase value mutation must be rolled back');
 emitGate('secret:supabase-preservation-blackbox');
-//# sourceMappingURL=supabase-secret-preservation-blackbox.js.map

package/dist/scripts/super-search-live-smoke-check.js

@@ -114,4 +114,3 @@ function runJson(args) {
         json
     };
 }
-//# sourceMappingURL=super-search-live-smoke-check.js.map

package/dist/scripts/super-search-local-http-smoke-check.js

@@ -15,4 +15,3 @@ emitGate('super-search:local-http-smoke', {
     content_sha256: report.content_sha256,
     report: '.sneakoscope/reports/super-search-local-http-smoke.json'
 });
-//# sourceMappingURL=super-search-local-http-smoke-check.js.map

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

@@ -42,4 +42,3 @@ emitGate('super-search:offline-contract', {
     blockers: result.blockers,
     gate: gatePath
 });
-//# sourceMappingURL=super-search-offline-contract-check.js.map

package/dist/scripts/super-search-provider-interface-check.js

@@ -37,4 +37,3 @@ finally {
     globalThis.fetch = originalFetch;
     await fs.rm(missionDir, { recursive: true, force: true });
 }
-//# sourceMappingURL=super-search-provider-interface-check.js.map

package/dist/scripts/triwiki-cache-key-check.js

@@ -6,4 +6,3 @@ const b = mod.computeTriWikiCacheKey({ root, id: 'triwiki:cache-key', inputs: ['
 assertGate(a.schema === 'sks.triwiki-cache-key.v1', 'cache key schema mismatch', a);
 assertGate(a.key === b.key && a.file_count >= 1 && a.input_hash && a.implementation_hash && a.package_lock_hash, 'cache key must be deterministic and complete', { a, b });
 emitGate('triwiki:cache-key', { key: a.key, files: a.file_count });
-//# sourceMappingURL=triwiki-cache-key-check.js.map

package/dist/scripts/triwiki-proof-bank-blackbox.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { assertGate, emitGate, makeTempRoot } from './sks-3-1-8-check-lib.js';
+import { importDist } from './sks-1-18-gate-lib.js';
+const tmp = await makeTempRoot('sks-triwiki-proof-bank-');
+await fs.writeFile(path.join(tmp, 'package.json'), JSON.stringify({ version: '4.0.0' }));
+await fs.writeFile(path.join(tmp, 'package-lock.json'), JSON.stringify({ lockfileVersion: 3 }));
+const cardMod = await importDist('core/triwiki/triwiki-proof-card.js');
+const bank = await importDist('core/triwiki/triwiki-proof-bank.js');
+const card = cardMod.createTriWikiProofCard({
+    subject_type: 'gate',
+    subject_id: 'fixture:gate',
+    cache_key: 'fixture-cache',
+    input_hash: 'input',
+    implementation_hash: 'impl',
+    tool_version: '4.0.0',
+    fixture_version: 'sks-4.0.0',
+    result: 'passed',
+    reusable: true,
+    evidence: { blackbox: true }
+});
+bank.writeTriWikiProofCard(tmp, card);
+const hit = bank.readReusableTriWikiProofCard({ root: tmp, subjectId: 'fixture:gate', cacheKey: 'fixture-cache' });
+assertGate(hit.hit === true && hit.card?.proof_id === card.proof_id, 'proof bank must reuse matching passed card', hit);
+bank.markTriWikiProofInvalidated(tmp, 'fixture:gate', card.proof_id, 'fixture_invalidated');
+const miss = bank.readReusableTriWikiProofCard({ root: tmp, subjectId: 'fixture:gate', cacheKey: 'fixture-cache' });
+assertGate(miss.hit === false, 'invalidated proof card must not be reused', miss);
+emitGate('triwiki:proof-bank-blackbox', { hit: true, invalidation_blocked_reuse: true });

package/dist/scripts/triwiki-proof-bank-check.js

@@ -4,4 +4,3 @@ const bank = await importDist('core/triwiki/triwiki-proof-bank.js');
 const status = bank.summarizeTriWikiProofBank(root);
 assertGate(status.schema === 'sks.triwiki-proof-bank.v1' && status.ok === true, 'proof bank status must pass', status);
 emitGate('triwiki:proof-bank', status);
-//# sourceMappingURL=triwiki-proof-bank-check.js.map

package/dist/scripts/triwiki-proof-card-check.js

@@ -20,4 +20,3 @@ const card = mod.createTriWikiProofCard({
 assertGate(card.schema === 'sks.triwiki-proof-card.v1', 'proof card schema mismatch', card);
 assertGate(card.proof_id.startsWith('proof-') && mod.isReusableTriWikiProofCard(card), 'proof card must be reusable when passed', card);
 emitGate('triwiki:proof-card', { proof_id: card.proof_id });
-//# sourceMappingURL=triwiki-proof-card-check.js.map

package/dist/scripts/trust-fixture-check.js

@@ -65,4 +65,3 @@ async function runJson(rootDir, sksBin, args, opts = {}) {
         throw new Error(`${args.join(' ')} returned invalid JSON: ${err instanceof Error ? err.message : String(err)} stdout=${result.stdout.slice(-2000)} stderr=${result.stderr.slice(-2000)}`);
     }
 }
-//# sourceMappingURL=trust-fixture-check.js.map

package/dist/scripts/type-surface-codex-app-check.js

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

package/dist/scripts/ultra-router-auto-router-check.js

@@ -16,7 +16,7 @@ assertGate(orchestrator.reason.includes('score>=threshold') || orchestrator.reas
 emitGate('ultra-router:auto-router', { worker: simpleWorker.selected_profile, image_worker: imageWorker.selected_profile, cache_hit: cachedWorker.cache_hit, orchestrator: orchestrator.selected_profile });
 function baseTask(extra = {}) {
     return {
-        route: '$Agent',
+        route: '$Naruto',
         missionId: 'M-ultra-router-auto',
         cwd: process.cwd(),
         prompt: 'fixture',
@@ -30,4 +30,3 @@ function baseTask(extra = {}) {
         ...extra
     };
 }
-//# sourceMappingURL=ultra-router-auto-router-check.js.map

package/dist/scripts/uninstall-inventory-check.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './sks-uninstall-regression-check.js';

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

@@ -27,4 +27,3 @@ const dryRunElapsed = Date.now() - startedDryRun;
 assertGate(dryRun.status === 'dry_run' && dryRun.install_code === null, 'update dry-run must not install', dryRun);
 assertGate(dryRunElapsed <= 2000, 'update dry-run fast path must stay under 2000ms', { elapsed_ms: dryRunElapsed });
 emitGate('update:fastpath', { check_elapsed_ms: checkElapsed, dry_run_elapsed_ms: dryRunElapsed });
-//# sourceMappingURL=update-fastpath-check.js.map

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

@@ -24,4 +24,3 @@ const restored = await fs.readFile(envFile, 'utf8');
 assertGate(blocked, 'update guard must block Supabase key value mutation');
 assertGate(restored.includes('update-secret') && !restored.includes('mutated-update-secret'), 'update guard must restore Supabase key value after mutation');
 emitGate('update:preserves-supabase-keys');
-//# sourceMappingURL=update-preserves-supabase-keys-blackbox.js.map

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

@@ -77,4 +77,3 @@ function parseJson(value) {
         return null;
     }
 }
-//# sourceMappingURL=upgrade-migration-matrix-check.js.map

package/dist/scripts/ux-review-extract-wires-real-extractor-check.js

@@ -12,4 +12,3 @@ requireContains('ux-review:extract-wires-real-extractor', 'src/core/image-ux-rev
     'verified_cap'
 ]);
 emitGate('ux-review:extract-wires-real-extractor', { artifact: 'image-ux-callout-extraction-report.json' });
-//# sourceMappingURL=ux-review-extract-wires-real-extractor-check.js.map

package/dist/scripts/ux-review-imagegen-blackbox-check.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { osTempPngFixtureArg } from './lib/valid-png-fixture.js';
+const repoRoot = process.cwd();
+const runRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-ux-review-imagegen-blackbox-'));
+const sksBin = path.join(repoRoot, 'dist', 'bin', 'sks.js');
+const sourceImage = osTempPngFixtureArg('ux-review-imagegen-blackbox-source.png');
+const run = spawnSync(process.execPath, [sksBin, 'ux-review', 'run', '--image', sourceImage, '--generate-callouts', '--mock', '--json'], {
+    cwd: runRoot,
+    env: { ...process.env, SKS_TEST_FAKE_IMAGEGEN: '1', SKS_TEST_FAKE_EXTRACTOR: '1', SKS_MOCK: '1', NODE_ENV: 'test', SKS_UPDATE_MIGRATION_GATE_DISABLED: '1', SKS_SKIP_NPM_FRESHNESS_CHECK: '1' },
+    encoding: 'utf8',
+    maxBuffer: 4 * 1024 * 1024
+});
+const parsed = parseJson(run.stdout);
+const missionDir = parsed?.mission_id ? path.join(runRoot, '.sneakoscope', 'missions', parsed.mission_id) : null;
+const request = missionDir ? readJson(path.join(missionDir, 'image-ux-gpt-image-2-request.json')) : null;
+const response = missionDir ? readJson(path.join(missionDir, 'image-ux-gpt-image-2-response.json')) : null;
+const issues = missionDir ? readJson(path.join(missionDir, 'image-ux-issue-ledger.json')) : null;
+const generated = missionDir ? readJson(path.join(missionDir, 'image-ux-generated-review-ledger.json')) : null;
+const proof = missionDir ? readJson(path.join(missionDir, 'completion-proof.json')) : null;
+const ok = Boolean(parsed?.mission_id)
+    && [0, 1].includes(run.status)
+    && ['blocked', 'verified_partial_reference'].includes(parsed?.status)
+    && request?.validation?.ok === true
+    && response?.evidence_class === 'mock_fixture'
+    && generated?.generated_count === 1
+    && generated?.real_generated_count === 0
+    && generated?.non_real_generated_count === 1
+    && generated?.generated_review_images?.[0]?.mock === true
+    && Array.isArray(issues?.issues)
+    && issues.issues.length > 0
+    && issues.issues.every((issue) => issue.source === 'mock_fixture')
+    && ['mock_only', 'verified_partial'].includes(proof?.status)
+    && proof?.evidence?.image_ux_review?.reference_only === true
+    && proof?.evidence?.image_ux_review?.generated_gpt_image_2_callout_images_count === 0;
+console.log(JSON.stringify({
+    schema: 'sks.ux-review-imagegen-blackbox-check.v1',
+    ok,
+    process_status: run.status,
+    mission_id: parsed?.mission_id || null,
+    gate_status: parsed?.status || null,
+    run_root: runRoot,
+    proof_status: proof?.status || null,
+    reference_only: proof?.evidence?.image_ux_review?.reference_only === true,
+    source_image: sourceImage,
+    request,
+    response,
+    issue_count: issues?.issues?.length || 0
+}, null, 2));
+if (!ok)
+    process.exitCode = 1;
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/scripts/ux-review-patch-diff-recheck-check.js

@@ -17,4 +17,3 @@ requireContains('ux-review:patch-diff-recheck', 'src/core/commands/image-ux-revi
     'recheck'
 ]);
 emitGate('ux-review:patch-diff-recheck', { patch_handoff: 'dry-run-by-default', recapture: 'required-after-change' });
-//# sourceMappingURL=ux-review-patch-diff-recheck-check.js.map

package/dist/scripts/ux-review-real-imagegen-smoke-check.js

@@ -28,4 +28,3 @@ const result = {
 console.log(JSON.stringify(result, null, 2));
 if (!result.ok)
     process.exitCode = 1;
-//# sourceMappingURL=ux-review-real-imagegen-smoke-check.js.map

package/dist/scripts/ux-review-run-wires-imagegen-check.js

@@ -12,4 +12,3 @@ requireContains('ux-review:run-wires-imagegen', 'src/core/commands/image-ux-revi
     'buildImageUxCalloutExtractionReport'
 ]);
 emitGate('ux-review:run-wires-imagegen', { command_path: 'sks ux-review run', imagegen_adapter: 'generateGptImage2CalloutReview' });
-//# sourceMappingURL=ux-review-run-wires-imagegen-check.js.map

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

@@ -69,4 +69,3 @@ async function collectSrcMjs(dir, out) {
 function sha256(value) {
     return crypto.createHash('sha256').update(value).digest('hex');
 }
-//# sourceMappingURL=write-build-manifest.js.map

package/dist/scripts/wrongness-fixture-check.js

@@ -14,7 +14,7 @@ const [ledger, imageWrongness, proofLinker] = await Promise.all([
 await fsp.mkdir(path.join(root, '.sneakoscope', 'missions', 'M-fixture'), { recursive: true });
 await ledger.recordTestFailureWrongness(root, {
     mission_id: 'M-fixture',
-    route: '$Team',
+    route: '$Naruto',
     command: 'node --test failing-fixture.test.mjs',
     failure: 'fixture assertion failed',
     artifact: '.sneakoscope/missions/M-fixture/test-report.json'
@@ -62,4 +62,3 @@ console.log(JSON.stringify({
 }, null, 2));
 if (!ok)
     process.exitCode = 1;
-//# sourceMappingURL=wrongness-fixture-check.js.map

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

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

package/dist/scripts/zellij-dashboard-pane-check.js

@@ -67,4 +67,3 @@ try {
 finally {
     await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
 }
-//# sourceMappingURL=zellij-dashboard-pane-check.js.map

package/dist/scripts/zellij-dashboard-watch.js

@@ -38,4 +38,3 @@ function readOption(list, name, fallback) {
     const prefixed = list.find((arg) => arg.startsWith(`${name}=`));
     return prefixed ? prefixed.slice(name.length + 1) : fallback;
 }
-//# sourceMappingURL=zellij-dashboard-watch.js.map

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

@@ -12,9 +12,8 @@ const report = {
     naruto_controls: ['dashboard', 'workers'].every((token) => naruto.includes(`'${token}'`)),
     dashboard_watch: zellij.includes('--watch') && zellij.includes('renderZellijDashboardText'),
     focus_uses_pane_id: zellij.includes('focus-pane-id'),
-    logs_read_swarm: zellij.includes('agent-native-cli-session-swarm.json')
+    logs_read_runtime: zellij.includes('native-cli-worker-runtime.json')
 };
-report.ok = report.zellij_controls && report.naruto_controls && report.dashboard_watch && report.focus_uses_pane_id && report.logs_read_swarm;
+report.ok = report.zellij_controls && report.naruto_controls && report.dashboard_watch && report.focus_uses_pane_id && report.logs_read_runtime;
 assertGate(report.ok, 'Zellij/Naruto developer controls missing', report);
 emitGate('zellij:developer-controls', report);
-//# sourceMappingURL=zellij-developer-controls-check.js.map

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

@@ -2,8 +2,8 @@
 // @ts-nocheck
 // zellij:doctor-readiness (1.20.2 Area 5.1/5.2).
 //
-// Verifies: (1) the doctor readiness matrix exposes the Zellij block with the
-// mad_ready=false-while-cli_ready-can-stay-true semantics and tmux removed, and
+// Verifies: (1) the doctor readiness matrix exposes only the current Zellij
+// block with mad_ready=false-while-cli_ready-can-stay-true semantics, and
 // (2) the screen-proof scrapeable section set is a strict SUBSET of the composed
 // lane section superset (so the two layers can never silently diverge).
 import fs from 'node:fs';
@@ -26,7 +26,7 @@ const missing = buildDoctorReadinessMatrix({
 });
 assertGate(missing.mad_ready === false, 'zellij missing must make mad_ready=false', { missing });
 assertGate(missing.cli_ready === true, 'zellij missing must NOT block cli_ready', { missing });
-assertGate(missing.tmux_removed_runtime === true, 'tmux must be a removed runtime', { missing });
+assertGate(!Object.hasOwn(missing, 'tmux_removed_runtime') && !Object.hasOwn(missing, 'tmux'), 'readiness must expose only the current terminal runtime', { missing });
 assertGate(missing.zellij && Array.isArray(missing.zellij.required_for), 'matrix must carry a zellij block with required_for', { missing });
 // Zellij ok → mad_ready true (config readable).
 const okMatrix = buildDoctorReadinessMatrix({
@@ -60,4 +60,3 @@ emitGate('zellij:doctor-readiness', {
     lane_sections: ZELLIJ_LANE_SECTIONS.length,
     scrapeable_sections: ZELLIJ_SCREEN_SCRAPEABLE_SECTIONS.length
 });
-//# sourceMappingURL=zellij-doctor-readiness-check.js.map

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

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

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

@@ -30,4 +30,3 @@ async function readJsonl(file) {
     const text = await fs.readFile(file, 'utf8');
     return text.trim().split(/\n+/).filter(Boolean).map((line) => JSON.parse(line));
 }
-//# sourceMappingURL=zellij-fake-adapter-check.js.map

package/dist/scripts/zellij-first-slot-down-stack-check.js

@@ -18,4 +18,3 @@ const checks = {
 };
 assertGate(Object.values(checks).every(Boolean), 'First visible Zellij worker must stack down from a right-column SLOTS anchor', checks);
 emitGate('zellij:first-slot-down-stack', checks);
-//# sourceMappingURL=zellij-first-slot-down-stack-check.js.map

package/dist/scripts/zellij-first-slot-down-stack-real-check.js

@@ -346,4 +346,3 @@ function shellQuote(value) {
         return value;
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-//# sourceMappingURL=zellij-first-slot-down-stack-real-check.js.map

package/dist/scripts/zellij-homebrew-policy-check.js

@@ -1,4 +1,3 @@
 #!/usr/bin/env node
 import { runDirective314Gate } from './sks-3-1-4-directive-check-lib.js';
 await runDirective314Gate('zellij:homebrew-policy');
-//# sourceMappingURL=zellij-homebrew-policy-check.js.map

package/dist/scripts/zellij-initial-main-only-blackbox.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+const mad = fs.readFileSync(path.join(root, 'src/core/commands/mad-sks-command.ts'), 'utf8');
+const naruto = fs.readFileSync(path.join(root, 'src/core/commands/naruto-command.ts'), 'utf8');
+const launcher = fs.readFileSync(path.join(root, 'src/core/zellij/zellij-launcher.ts'), 'utf8');
+const report = {
+    schema: 'sks.zellij-initial-main-only-blackbox.v1',
+    ok: true,
+    mad_slot_zero: /launchMadZellijUi\([\s\S]*slotCount:\s*0/.test(mad),
+    mad_no_launch_dashboard: !/launch\.dashboard_pane\s*=\s*await openZellijDashboardPane/.test(mad),
+    mad_initial_ui_artifact: mad.includes('zellij-initial-ui.json') && mad.includes("ui_architecture: 'monitor_plus_viewports'") && mad.includes('worker_panes_created: 0'),
+    naruto_slot_zero: /launchZellijLayout\([\s\S]*slotCount:\s*0/.test(naruto),
+    naruto_no_launch_dashboard: !/liveZellij\.dashboard_pane\s*=\s*await openZellijDashboardPane/.test(naruto),
+    naruto_initial_ui_artifact: naruto.includes('zellij-initial-ui.json'),
+    launcher_uses_layout_builder: launcher.includes('writeZellijLayout(root, layoutInput)')
+};
+report.ok = report.mad_slot_zero
+    && report.mad_no_launch_dashboard
+    && report.mad_initial_ui_artifact
+    && report.naruto_slot_zero
+    && report.naruto_no_launch_dashboard
+    && report.naruto_initial_ui_artifact;
+assertGate(report.ok, 'Zellij initial UI must use monitor plus fixed viewports with no worker panes at launch', report);
+emitGate('zellij:initial-main-only-blackbox', report);

package/dist/scripts/zellij-lane-renderer-check.js

@@ -11,8 +11,8 @@ if (!freshness.ok)
 const mod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-lane-renderer.js')).href);
 const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-zellij-lane-'));
 await fs.writeFile(path.join(tmp, 'agent-scheduler-state.json'), `${JSON.stringify({ target_active_slots: 1, active_slot_count: 1, pending_count: 2, completed_count: 3 }, null, 2)}\n`);
-await fs.writeFile(path.join(tmp, 'agent-native-cli-session-swarm.json'), `${JSON.stringify({
-    schema: 'sks.agent-native-cli-session-swarm.v1',
+await fs.writeFile(path.join(tmp, 'native-cli-worker-runtime.json'), `${JSON.stringify({
+    schema: 'sks.native-cli-worker-runtime.v2',
     records: [{
             slot_id: 'slot-001',
             generation_index: 1,
@@ -77,4 +77,3 @@ emit(report);
 function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
     process.exitCode = 1; }
 function fail(blocker, detail) { emit({ schema: 'sks.zellij-lane-renderer-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
-//# sourceMappingURL=zellij-lane-renderer-check.js.map

package/dist/scripts/zellij-launch-command-truth-check.js

@@ -72,4 +72,3 @@ const report = {
 fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
 fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'zellij-launch-command-truth.json'), `${JSON.stringify(report, null, 2)}\n`);
 emitGate('zellij:launch-command-truth', { launcher_ok: true, files_scanned: filesScanned });
-//# sourceMappingURL=zellij-launch-command-truth-check.js.map

package/dist/scripts/zellij-layout-valid-check.js

@@ -35,7 +35,7 @@ const narutoFanoutLayout = layoutMod.buildZellijLayoutKdl({
     slotCount: 24
 });
 const narutoFanoutPaneCount = (narutoFanoutLayout.layout_kdl.match(/pane name="sks-viewport-/g) || []).length;
-const kindsValidated = ['mad', 'agent', 'team', 'naruto'].map((kind) => {
+const kindsValidated = ['mad', 'naruto'].map((kind) => {
     const b = layoutMod.buildZellijLayoutKdl({
         missionId: `M-layout-${kind}`,
         ledgerRoot: path.join(root, '.sneakoscope', 'tmp', `layout-${kind}`),
@@ -119,4 +119,3 @@ async function waitForSocketEntriesToClear(socketDir, timeoutMs) {
 async function exists(value) {
     return fs.access(value).then(() => true).catch(() => false);
 }
-//# sourceMappingURL=zellij-layout-valid-check.js.map

package/dist/scripts/zellij-pane-creation-lock-metrics-check.js

@@ -9,4 +9,3 @@ for (const token of ['requested_at', 'acquired_at', 'released_at', 'wait_ms', 'h
 }
 assertGate(src.includes('zellij_pane_creation_lock_requested') && src.includes('zellij_pane_creation_lock_released'), 'pane lock runtime events missing');
 emitGate('zellij:pane-creation-lock-metrics');
-//# sourceMappingURL=zellij-pane-creation-lock-metrics-check.js.map

package/dist/scripts/zellij-pane-lock-concurrency-blackbox.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const missionId = 'M-zellij-pane-lock-blackbox';
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-pane-lock-'));
+const metricsFile = path.join(tmp, '.sneakoscope', 'missions', missionId, 'zellij', 'pane-creation-lock-events.jsonl');
+await fs.mkdir(path.dirname(metricsFile), { recursive: true });
+const workers = 32;
+const visiblePaneCap = 8;
+const workerSleepMs = 3000;
+const paneDelayMs = 300;
+const started = Date.now();
+let active = 0;
+let maxActive = 0;
+const pids = new Set();
+const events = [];
+let lock = Promise.resolve();
+const runs = Array.from({ length: workers }, (_, index) => runWorker(index + 1));
+await Promise.all(runs);
+const wall = Date.now() - started;
+const metricsText = await fs.readFile(metricsFile, 'utf8');
+const metrics = metricsText.trim().split(/\n+/).map((line) => JSON.parse(line));
+const visiblePanes = metrics.length;
+const headlessWorkers = workers - visiblePanes;
+const lastPaneCreated = Math.max(...events.filter((event) => event.type === 'zellij_pane_created').map((event) => event.at));
+const firstSpawn = Math.min(...events.filter((event) => event.type === 'worker_process_spawned').map((event) => event.at));
+assertGate(maxActive >= 32, 'max active workers must reach 32', { maxActive });
+assertGate(pids.size >= 32, 'unique PIDs must reach 32', { unique: pids.size });
+assertGate(wall < 9000, 'wall time must prove overlap under 9s', { wall });
+assertGate(metrics.length === visiblePaneCap && metrics.every((row) => row.wait_ms >= 0 && row.held_ms >= paneDelayMs - 40), 'pane lock metrics missing or invalid', metrics);
+assertGate(firstSpawn <= lastPaneCreated, 'worker processes must spawn before all pane creation finishes', { firstSpawn, lastPaneCreated });
+assertGate(visiblePanes <= 8 && headlessWorkers >= 24, 'visible/headless worker counts mismatch', { visiblePanes, headlessWorkers });
+emitGate('zellij:pane-lock-concurrency-blackbox', { wall_ms: wall, max_active_workers: maxActive, unique_pids: pids.size, visible_panes: visiblePanes, headless_workers: headlessWorkers });
+async function runWorker(slot) {
+    const child = spawn(process.execPath, ['-e', `setTimeout(()=>process.exit(0), ${workerSleepMs})`], { stdio: 'ignore' });
+    active += 1;
+    maxActive = Math.max(maxActive, active);
+    if (child.pid)
+        pids.add(child.pid);
+    events.push({ type: 'worker_process_spawned', slot, at: Date.now() - started, pid: child.pid || null });
+    const paneTask = slot <= visiblePaneCap ? withPaneLock(slot) : Promise.resolve();
+    await Promise.all([
+        new Promise((resolve) => child.on('close', resolve)),
+        paneTask
+    ]);
+    active -= 1;
+}
+async function withPaneLock(slot) {
+    const requestedAt = new Date().toISOString();
+    const requestedMs = Date.now();
+    events.push({ type: 'zellij_pane_creation_lock_requested', slot, at: requestedMs - started });
+    const previous = lock;
+    let release;
+    lock = new Promise((resolve) => { release = resolve; });
+    await previous;
+    const acquiredAt = new Date().toISOString();
+    const acquiredMs = Date.now();
+    await new Promise((resolve) => setTimeout(resolve, paneDelayMs));
+    events.push({ type: 'zellij_pane_created', slot, at: Date.now() - started });
+    const releasedAt = new Date().toISOString();
+    const releasedMs = Date.now();
+    await fs.appendFile(metricsFile, JSON.stringify({
+        schema: 'sks.zellij-pane-creation-lock-metrics.v1',
+        mission_id: missionId,
+        session_name: 'fixture',
+        slot_id: `slot-${String(slot).padStart(3, '0')}`,
+        generation_index: 1,
+        requested_at: requestedAt,
+        acquired_at: acquiredAt,
+        released_at: releasedAt,
+        wait_ms: acquiredMs - requestedMs,
+        held_ms: releasedMs - acquiredMs
+    }) + '\n');
+    release();
+}

package/dist/scripts/zellij-pane-lock-does-not-block-worker-check.js

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
 // @ts-nocheck
 import { assertGate, emitGate, readText } from './sks-1-18-gate-lib.js';
-const swarm = readText('src/core/agents/native-cli-session-swarm.ts');
-const processRunStart = swarm.indexOf('const processRun = liveWorkerPane');
-const compactBlock = swarm.slice(processRunStart, swarm.indexOf('const zellijRequired'));
-assertGate(processRunStart >= 0, 'native swarm compact branch missing');
+const runtime = readText('src/core/agents/native-cli-worker-runtime.ts');
+const processRunStart = runtime.indexOf('const processRun = liveWorkerPane');
+const compactBlock = runtime.slice(processRunStart, runtime.indexOf('const zellijRequired'));
+assertGate(processRunStart >= 0, 'worker runtime compact branch missing');
 assertGate(compactBlock.indexOf('spawnCompactSlotWorkerProcess') >= 0 && compactBlock.indexOf('spawnCompactSlotWorkerProcess') < compactBlock.indexOf('openWorkerPane'), 'compact worker process must spawn before pane creation');
 const parallel = readText('src/core/agents/parallel-runtime-proof.ts');
 for (const event of ['worker_process_spawned', 'zellij_pane_creation_lock_requested', 'zellij_pane_created']) {
     assertGate(parallel.includes(event), `parallel proof event missing ${event}`);
 }
 emitGate('zellij:pane-lock-does-not-block-worker');
-//# sourceMappingURL=zellij-pane-lock-does-not-block-worker-check.js.map