sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/ux-review-generate-callouts-fixture-check.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readMissionJson, runUxFixture } from './sks-1-11-gate-lib.js';
+const result = runUxFixture();
+const ledger = readMissionJson(result.mission_id, 'image-ux-generated-review-ledger.json');
+assertGate(ledger.status === 'generated'
+    || (ledger.generated_images || ledger.review_images || ledger.generated_review_images || []).length > 0, 'generated image UX callout ledger missing generated evidence', ledger);
+emitGate('ux-review:generate-callouts-fixture', { mission_id: result.mission_id });
+//# sourceMappingURL=ux-review-generate-callouts-fixture-check.js.map

package/dist/scripts/ux-review-image-voxel-relations-check.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const root = process.cwd();
+const ledgerMod = await import(pathToFileURL(path.join(root, 'dist/core/wiki-image/image-voxel-ledger.js')));
+const validationMod = await import(pathToFileURL(path.join(root, 'dist/core/wiki-image/validation.js')));
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-ux-rel-'));
+await fs.mkdir(path.join(tmp, 'img'), { recursive: true });
+const png = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMB/axX7V8AAAAASUVORK5CYII=', 'base64');
+await fs.writeFile(path.join(tmp, 'img/source.png'), png);
+await fs.writeFile(path.join(tmp, 'img/generated.png'), png);
+await ledgerMod.ingestImage(tmp, 'img/source.png', { id: 'source-screen', missionId: 'M-fixture' });
+await ledgerMod.ingestImage(tmp, 'img/generated.png', { id: 'generated-callout', missionId: 'M-fixture' });
+const relation = await ledgerMod.addImageRelation(tmp, {
+    missionId: 'M-fixture',
+    type: 'generated_callout_review_of',
+    beforeImageId: 'source-screen',
+    afterImageId: 'generated-callout',
+    sourceImageId: 'source-screen',
+    generatedImageId: 'generated-callout',
+    verification: 'fixture',
+    status: 'verified_partial'
+});
+const validation = validationMod.validateImageVoxelLedger(relation.ledger, { requireRelations: true });
+assert.equal(validation.ok, true, validation.issues.join(', '));
+console.log(JSON.stringify({ schema: 'sks.ux-review-image-voxel-relations.v1', ok: true, relations: relation.ledger.relations.length }, null, 2));
+//# sourceMappingURL=ux-review-image-voxel-relations-check.js.map

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

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { osTempPngFixtureArg } from './lib/valid-png-fixture.js';
+const sourceImage = osTempPngFixtureArg('ux-review-imagegen-blackbox-source.png');
+const run = spawnSync(process.execPath, ['./dist/bin/sks.js', 'ux-review', 'run', '--image', sourceImage, '--generate-callouts', '--json'], {
+    cwd: process.cwd(),
+    env: { ...process.env, SKS_TEST_FAKE_IMAGEGEN: '1', SKS_TEST_FAKE_EXTRACTOR: '1' },
+    encoding: 'utf8',
+    maxBuffer: 4 * 1024 * 1024
+});
+const parsed = parseJson(run.stdout);
+const missionDir = parsed?.mission_id ? path.join(process.cwd(), '.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)
+    && run.status === 0
+    && parsed?.status === 'verified_partial_reference'
+    && request?.validation?.ok === true
+    && response?.fake_adapter === true
+    && 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')
+    && proof?.status === 'verified_partial'
+    && 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,
+    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;
+    }
+}
+//# sourceMappingURL=ux-review-imagegen-blackbox-check.js.map

package/dist/scripts/ux-review-no-fake-callouts-check.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readMissionJson, runUxFixture } from './sks-1-11-gate-lib.js';
+const result = runUxFixture();
+const proof = readMissionJson(result.mission_id, 'completion-proof.json');
+assertGate(proof.status !== 'verified' && JSON.stringify(proof).includes('mock'), 'mock image UX callouts were allowed to claim full real verification', { status: proof.status });
+emitGate('ux-review:no-fake-callouts', { mission_id: result.mission_id, status: proof.status });
+//# sourceMappingURL=ux-review-no-fake-callouts-check.js.map

package/dist/scripts/ux-review-no-text-fallback-check.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import assert from 'node:assert/strict';
+import { pathToFileURL } from 'node:url';
+import path from 'node:path';
+const root = process.cwd();
+const mod = await import(pathToFileURL(path.join(root, 'dist/core/image-ux-review.js')));
+const contract = { prompt: 'text-only fallback fixture', answers: { IMAGE_UX_REVIEW_SOURCE_IMAGES: ['test/fixtures/images/one-by-one.png'] } };
+const inventory = await mod.hydrateImageUxScreenInventory(root, mod.buildImageUxScreenInventory(contract));
+const generatedReviewLedger = mod.buildImageUxGeneratedReviewLedger(contract, inventory, {
+    generated_review_images: [{
+            id: 'text-only-review',
+            source_screen_id: 'screen-1',
+            text_only: true,
+            status: 'text_only',
+            mock: false,
+            real_generated: false
+        }]
+});
+const issueLedger = mod.buildImageUxIssueLedger(contract, generatedReviewLedger, null);
+const gate = mod.defaultImageUxReviewGate(contract, { inventory, generatedReviewLedger, issueLedger });
+assert.equal(gate.passed, false);
+assert.ok(gate.blockers.includes('ux_review_text_only_fallback'));
+console.log(JSON.stringify({ schema: 'sks.ux-review-no-text-fallback.v1', ok: true, blockers: gate.blockers }, null, 2));
+//# sourceMappingURL=ux-review-no-text-fallback-check.js.map

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

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { emitGate, requireContains } from './sks-1-12-real-execution-check-lib.js';
+requireContains('ux-review:patch-diff-recheck', 'src/core/image-ux-review/fix-loop.ts', [
+    'changed_files',
+    'recapture_required',
+    'no_op_patch_wrongness',
+    'regression'
+]);
+requireContains('ux-review:patch-diff-recheck', 'src/core/image-ux-review/patch-handoff.ts', [
+    'explicit_apply_opt_in',
+    'dry_run',
+    'recapture_required'
+]);
+requireContains('ux-review:patch-diff-recheck', 'src/core/commands/image-ux-review-command.ts', [
+    'attachAfterImageCommand',
+    '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-patch-handoff-fixture-check.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readMissionJson, runUxFixture } from './sks-1-11-gate-lib.js';
+const result = runUxFixture();
+const plan = readMissionJson(result.mission_id, 'image-ux-fix-task-plan.json');
+assertGate(/^sks\.image-ux-fix-task-plan\.v[12]$/.test(plan.schema) && Array.isArray(plan.tasks), 'image UX patch handoff plan invalid', plan);
+emitGate('ux-review:patch-handoff-fixture', { mission_id: result.mission_id, tasks: plan.tasks.length });
+//# sourceMappingURL=ux-review-patch-handoff-fixture-check.js.map

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

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { spawnSync } from 'node:child_process';
+const enabled = process.env.SKS_TEST_REAL_IMAGEGEN === '1' || process.env.SKS_REAL_IMAGEGEN === '1';
+const hasKey = Boolean(process.env.OPENAI_API_KEY || process.env.SKS_CODEX_APP_IMAGEGEN === '1');
+if (!enabled || !hasKey) {
+    const result = {
+        schema: 'sks.ux-real-imagegen-smoke.v1',
+        ok: true,
+        status: 'integration_optional',
+        reason: !enabled ? 'SKS_TEST_REAL_IMAGEGEN=1 not set' : 'OPENAI_API_KEY or Codex App imagegen capability not configured',
+        fake_adapter: false,
+        real_generated: false
+    };
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(0);
+}
+const run = spawnSync(process.execPath, ['./dist/scripts/imagegen-real-smoke-check.js'], { cwd: process.cwd(), env: process.env, encoding: 'utf8', maxBuffer: 8 * 1024 * 1024 });
+const result = {
+    schema: 'sks.ux-real-imagegen-smoke.v1',
+    ok: run.status === 0,
+    status: run.status === 0 ? 'passed' : 'blocked',
+    fake_adapter: false,
+    real_generated: run.status === 0,
+    stdout_tail: run.stdout.slice(-4000),
+    stderr_tail: run.stderr.slice(-4000)
+};
+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-real-loop-fixture-check.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+const root = process.cwd();
+const result = spawnSync(process.execPath, [path.join(root, 'dist/bin/sks.js'), 'image-ux-review', 'fixture', '--mock', '--json'], {
+    cwd: root,
+    encoding: 'utf8',
+    env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' },
+    timeout: Number(process.env.SKS_UX_REVIEW_REAL_LOOP_FIXTURE_TIMEOUT_MS || 180_000)
+});
+assert.equal(result.status, 0, JSON.stringify({
+    stderr: result.stderr,
+    stdout: result.stdout,
+    signal: result.signal,
+    error: result.error?.message || null
+}, null, 2));
+const json = JSON.parse(result.stdout);
+assert.equal(json.artifacts.gate.mock_fixture_cannot_claim_real, true);
+assert.equal(json.artifacts.generated_review_ledger.real_generated_count, 0);
+assert.equal(json.artifacts.generated_review_ledger.generated_count, 1);
+console.log(JSON.stringify({ schema: 'sks.ux-review-real-loop-fixture.v1', ok: true, mission_id: json.mission_id }, null, 2));
+//# sourceMappingURL=ux-review-real-loop-fixture-check.js.map

package/dist/scripts/ux-review-recapture-recheck-fixture-check.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readMissionJson, runUxFixture } from './sks-1-11-gate-lib.js';
+const result = runUxFixture();
+const recapture = readMissionJson(result.mission_id, 'image-ux-recapture-plan.json');
+assertGate(recapture.changed_screens_rechecked_or_not_applicable === true, 'image UX recapture/recheck did not pass', recapture);
+emitGate('ux-review:recapture-recheck-fixture', { mission_id: result.mission_id });
+//# sourceMappingURL=ux-review-recapture-recheck-fixture-check.js.map

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

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { emitGate, requireContains } from './sks-1-12-real-execution-check-lib.js';
+requireContains('ux-review:run-wires-imagegen', 'src/core/commands/image-ux-review-command.ts', [
+    'const shouldGenerateCallouts = flag(args, \'--generate-callouts\') || flag(args, \'--fix\')',
+    'generateGptImage2CalloutReview',
+    'extractRealCallouts',
+    '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/worker-pane-communication-contract-check.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { writeWorkerPaneCommunicationContract, evaluateWorkerPaneCommunicationContract } from '../core/agents/worker-pane-communication-contract.js';
+import { packageRoot } from '../core/fsx.js';
+const root = packageRoot();
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-worker-pane-contract-'));
+const workerDir = path.join('sessions', 'slot-001', 'gen-1', 'worker');
+await fs.mkdir(path.join(tmp, workerDir), { recursive: true });
+await fs.writeFile(path.join(tmp, 'agent-native-cli-session-swarm.json'), `${JSON.stringify({
+    records: [{
+            session_id: 'slot-001-gen-1',
+            slot_id: 'slot-001',
+            generation_index: 1,
+            worker_artifact_dir: workerDir,
+            worker_intake: path.join(workerDir, 'worker-intake.json'),
+            result_path: path.join(workerDir, 'worker-result.json'),
+            heartbeat_path: path.join(workerDir, 'worker-heartbeat.jsonl'),
+            patch_envelope_path: path.join(workerDir, 'worker-patch-envelope.json'),
+            scaling_primitive: 'native_cli_process_in_zellij_worker_pane'
+        }]
+}, null, 2)}\n`);
+await fs.writeFile(path.join(tmp, workerDir, 'worker-intake.json'), '{"ok":true}\n');
+await fs.writeFile(path.join(tmp, workerDir, 'worker-result.json'), '{"status":"done"}\n');
+await fs.writeFile(path.join(tmp, workerDir, 'worker-heartbeat.jsonl'), '{"event":"started"}\n');
+await fs.writeFile(path.join(tmp, workerDir, 'worker-process-report.json'), '{"pid":1234}\n');
+await fs.writeFile(path.join(tmp, workerDir, 'codex-control-proof.json'), '{"ok":true,"sdk_thread_id":"sdk-thread-1"}\n');
+await fs.writeFile(path.join(tmp, workerDir, 'worker-no-patch-reason.json'), '{"ok":true}\n');
+await fs.writeFile(path.join(tmp, workerDir, 'zellij-worker-pane-events.jsonl'), [
+    '{"event_type":"session_launch_started"}',
+    '{"event_type":"zellij_worker_pane_created"}',
+    '{"event_type":"worker_started"}',
+    '{"event_type":"codex_sdk_thread_started"}',
+    '{"event_type":"result_written"}',
+    '{"event_type":"pane_closed"}'
+].join('\n') + '\n');
+await fs.writeFile(path.join(tmp, workerDir, 'zellij-worker-pane.json'), `${JSON.stringify({
+    schema: 'sks.zellij-worker-pane.v1',
+    pane_id: '9',
+    parent_child_transport: 'worker-result-json-and-heartbeat'
+})}\n`);
+const report = await writeWorkerPaneCommunicationContract(tmp, { requireZellij: true, reportPath: path.join(root, '.sneakoscope', 'reports', 'worker-pane-communication-contract.json') });
+const badRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-worker-pane-contract-bad-'));
+await fs.writeFile(path.join(badRoot, 'agent-native-cli-session-swarm.json'), '{"records":[{"worker_artifact_dir":"worker","scaling_primitive":"native_cli_process_in_zellij_worker_pane"}]}\n');
+const bad = await evaluateWorkerPaneCommunicationContract(badRoot, { requireZellij: true });
+const ok = report.ok && bad.ok === false && bad.blockers.includes('worker_pane_contract_result_missing') && bad.blockers.includes('worker_pane_contract_codex_control_proof_missing');
+emit({ schema: 'sks.worker-pane-communication-contract-check.v1', ok, report, bad, blockers: ok ? [] : ['worker_pane_communication_contract_check_failed'] });
+function emit(report) {
+    console.log(JSON.stringify(report, null, 2));
+    if (!report.ok)
+        process.exitCode = 1;
+}
+//# sourceMappingURL=worker-pane-communication-contract-check.js.map

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

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import os from 'node:os';
+import path from 'node:path';
+import fsp from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+const repo = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sks-wrongness-fixture-'));
+const [ledger, imageWrongness, proofLinker] = await Promise.all([
+    import(path.join(repo, 'dist/core/triwiki-wrongness/wrongness-ledger.js')),
+    import(path.join(repo, 'dist/core/triwiki-wrongness/image-wrongness.js')),
+    import(path.join(repo, 'dist/core/triwiki-wrongness/wrongness-proof-linker.js'))
+]);
+await fsp.mkdir(path.join(root, '.sneakoscope', 'missions', 'M-fixture'), { recursive: true });
+await ledger.recordTestFailureWrongness(root, {
+    mission_id: 'M-fixture',
+    route: '$Team',
+    command: 'node --test failing-fixture.test.mjs',
+    failure: 'fixture assertion failed',
+    artifact: '.sneakoscope/missions/M-fixture/test-report.json'
+});
+await ledger.recordDbSafetyMismatchWrongness(root, {
+    mission_id: 'M-fixture',
+    expected: 'blocked',
+    actual: 'safe',
+    command: 'sks db check --sql "DROP TABLE users"',
+    sql: 'DROP TABLE users'
+});
+await ledger.recordHookPolicyMismatchWrongness(root, {
+    mission_id: 'M-fixture',
+    expected: 'block',
+    actual: 'continue',
+    artifact: 'test/fixtures/hooks/mismatch.json'
+});
+await ledger.recordAgentMismatchWrongness(root, {
+    mission_id: 'M-fixture',
+    agent_id: 'agent-2-verification',
+    issues: ['parse_failed'],
+    artifact: '.sneakoscope/missions/M-fixture/agent-2-verification.json'
+});
+await imageWrongness.recordImageWrongnessFromValidation(root, {
+    missionId: 'M-fixture',
+    route: '$Wiki',
+    artifact: '.sneakoscope/missions/M-fixture/image-voxel-ledger.json',
+    validation: {
+        ok: false,
+        issues: ['missing_anchors:$Wiki', 'bbox_out_of_bounds:anchor-001']
+    }
+});
+const validation = await ledger.validateWrongnessScope(root, 'latest');
+const evidence = await proofLinker.wrongnessProofEvidence(root, 'M-fixture');
+const ok = validation.ok
+    && validation.checked >= 5
+    && evidence.active_count >= 5
+    && evidence.high_severity_active >= 2;
+console.log(JSON.stringify({
+    schema: 'sks.wrongness-fixture-check.v1',
+    ok,
+    root,
+    validation,
+    evidence
+}, null, 2));
+if (!ok)
+    process.exitCode = 1;
+//# sourceMappingURL=wrongness-fixture-check.js.map

package/dist/scripts/xai-mcp-capability-check.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
+const detector = await importDist('core/mcp/xai-mcp-detector.js');
+const detection = detector.detectXaiMcpFromConfig([
+    { path: 'fixture.toml', source: 'provided', text: '[mcp_servers.grok]\ntools = ["search", "query"]\n' }
+]);
+assertGate(detection.ok === true, 'X AI detector must not fail');
+assertGate(detection.configured === true, 'X AI detector must detect configured Grok MCP');
+assertGate(detection.search_capable === true, 'X AI detector must detect search-capable tools');
+const missing = detector.detectXaiMcpFromConfig([]);
+assertGate(missing.ok === true && missing.status === 'missing', 'missing X AI MCP must be ok fallback');
+emitGate('xai-mcp:capability', { configured_status: detection.status, missing_status: missing.status });
+//# sourceMappingURL=xai-mcp-capability-check.js.map

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

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

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

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+import { ensureDistFresh } from './lib/ensure-dist-fresh.js';
+import fs from 'node:fs';
+const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || process.argv.includes('--require-real');
+const freshness = ensureDistFresh({ rebuild: false });
+assertGate(freshness.ok === true, 'dist must be fresh for zellij dashboard pane check', freshness);
+const managerSource = fs.readFileSync(path.join(root, 'src', 'core', 'zellij', 'zellij-right-column-manager.ts'), 'utf8');
+const narutoSource = fs.readFileSync(path.join(root, 'src', 'core', 'commands', 'naruto-command.ts'), 'utf8');
+const madSource = fs.readFileSync(path.join(root, 'src', 'core', 'commands', 'mad-sks-command.ts'), 'utf8');
+assertGate(managerSource.includes('openZellijDashboardPane') && narutoSource.includes("dashboard_created: false") && madSource.includes("dashboard_created: false"), 'Dashboard pane must be created by right-column manager after first worker spawn, not at launch', {
+    manager: managerSource.includes('openZellijDashboardPane'),
+    naruto_initial_dashboard_false: narutoSource.includes("dashboard_created: false"),
+    mad_initial_dashboard_false: madSource.includes("dashboard_created: false")
+});
+const dashboard = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-dashboard-pane.js')).href);
+const command = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
+const missionId = `M-zellij-dashboard-${Date.now()}`;
+const sessionName = `sks-dashboard-${process.pid}`;
+if (!requireReal) {
+    const snapshotMod = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-dashboard-renderer.js')).href);
+    const snapshot = snapshotMod.buildZellijDashboardSnapshot({ mission_id: missionId, active_workers: 4, visible_panes: 2, headless_workers: 2 });
+    const text = snapshotMod.renderZellijDashboardText(snapshot);
+    assertGate(text.includes('Mission') && text.includes('Backend counts') && text.includes('headless') && text.includes('GPT final status') && text.includes('Patch / verify'), 'dashboard renderer must include required fields', { text });
+    assertGate(fs.readFileSync(path.join(root, 'src', 'scripts', 'zellij-dashboard-watch.ts'), 'utf8').includes('--interval-ms')
+        && fs.existsSync(path.join(root, 'dist', 'scripts', 'zellij-dashboard-watch.js')), 'dashboard watch script must support interval updates');
+    emitGate('zellij:dashboard-pane', { real_required: false, renderer_fields: true });
+    process.exit(0);
+}
+await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
+try {
+    const record = await dashboard.openZellijDashboardPane({
+        root,
+        missionId,
+        sessionName,
+        cwd: root,
+        snapshot: {
+            mode: 'naruto',
+            backend_counts: { 'codex-sdk': 2, 'local-llm': 1 },
+            placement_counts: { 'zellij-pane': 2, headless: 1 },
+            active_workers: 3,
+            visible_panes: 2,
+            headless_workers: 1,
+            queue_depth: 7,
+            worktrees: { active: 2, completed: 1, retained: 0 },
+            local_llm: { tps: 12, queue: 1 },
+            gpt_final_status: 'pending',
+            gate_progress: 'release: 8/12'
+        }
+    });
+    const ok = record.ok === true && record.pane_kind === 'dashboard' && record.worker_pane === false && record.pane_id
+        && String(record.command || '').includes('zellij-dashboard-watch.js')
+        && String(record.command || '').includes('--interval-ms 1000');
+    assertGate(ok, 'real Zellij dashboard pane must open and not count as worker pane', record);
+    emitGate('zellij:dashboard-pane', {
+        real_required: true,
+        pane_id: record.pane_id,
+        pane_kind: record.pane_kind,
+        worker_pane: record.worker_pane,
+        mission_id: missionId,
+        session_name: sessionName
+    });
+}
+finally {
+    await command.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
+}
+//# sourceMappingURL=zellij-dashboard-pane-check.js.map

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

@@ -0,0 +1,20 @@
+#!/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 zellij = fs.readFileSync(path.join(root, 'src/commands/zellij.ts'), 'utf8');
+const naruto = fs.readFileSync(path.join(root, 'src/core/commands/naruto-command.ts'), 'utf8');
+const report = {
+    schema: 'sks.zellij-developer-controls-check.v1',
+    ok: true,
+    zellij_controls: ['focus-worker', 'worker-logs', 'dashboard', 'close-drained'].every((token) => zellij.includes(token)),
+    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')
+};
+report.ok = report.zellij_controls && report.naruto_controls && report.dashboard_watch && report.focus_uses_pane_id && report.logs_read_swarm;
+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

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

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

@@ -0,0 +1,21 @@
+#!/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 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 report = {
+    schema: 'sks.zellij-dynamic-pane-lifecycle-check.v1',
+    ok: true,
+    close_success_default: worker.includes("SKS_ZELLIJ_CLOSE_WORKER_PANE !== '0'"),
+    keep_failed_default: worker.includes('SKS_ZELLIJ_KEEP_FAILED_PANE'),
+    close_updates_right_column: worker.includes('closeWorkerInRightColumn'),
+    drained_status_recorded: manager.includes('worker_pane_drained'),
+    overflow_headless_recorded: swarm.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

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