sneakoscope 2.0.7 → 2.0.8

package/dist/scripts/git-worktree-integration-primary-check.js

@@ -0,0 +1,22 @@
+#!/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';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const mergeMod = await importDist('core/git/git-worktree-merge-queue.js');
+const repo = makeGitFixture('integration-primary');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-integration-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-integrate', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'a.txt'), 'alpha\nintegrated\n');
+const diff = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-integrate', workerId: 'worker-1' });
+const integrationPath = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-integration-'));
+fs.rmSync(integrationPath, { recursive: true, force: true });
+const integration = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-integrate', workerId: 'integration', slotId: 'integration' });
+const report = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs: [diff] });
+assertGate(report.ok === true && report.applied_count === 1, 'git-worktree-diff must apply through merge queue', report);
+emitGate('git:worktree-integration-primary', { applied_count: report.applied_count });
+//# sourceMappingURL=git-worktree-integration-primary-check.js.map

package/dist/scripts/git-worktree-manifest-append-check.js

@@ -0,0 +1,18 @@
+#!/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';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const repo = makeGitFixture('worktree-manifest-append');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-manifest-'));
+const allocations = [];
+for (let index = 0; index < 4; index += 1) {
+    allocations.push(await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-manifest', workerId: `worker-${index}`, slotId: `slot-${index}` }));
+}
+const manifest = JSON.parse(fs.readFileSync(allocations[0].manifest_path, 'utf8'));
+assertGate(manifest.allocations.length >= allocations.length, 'manifest append must preserve allocations', manifest);
+emitGate('git:worktree-manifest-append', { allocations: manifest.allocations.length });
+//# sourceMappingURL=git-worktree-manifest-append-check.js.map

package/dist/scripts/git-worktree-untracked-diff-check.js

@@ -0,0 +1,18 @@
+#!/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';
+import { makeGitFixture } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const repo = makeGitFixture('untracked-diff');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-wt-untracked-'));
+const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-untracked', workerId: 'worker-1', slotId: 'slot-001' });
+fs.writeFileSync(path.join(allocation.worktree_path, 'new-file.txt'), 'new content\n');
+const diff = await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-untracked', workerId: 'worker-1' });
+assertGate(diff.changed_files.includes('new-file.txt'), 'changed files must include untracked file', diff);
+assertGate(diff.diff.includes('new file mode') && diff.diff.includes('+new content'), 'git diff must include untracked file content', { diff: diff.diff });
+emitGate('git:worktree-untracked-diff', { changed_files: diff.changed_files });
+//# sourceMappingURL=git-worktree-untracked-diff-check.js.map

package/dist/scripts/naruto-worktree-coding-blackbox.js

@@ -0,0 +1,29 @@
+#!/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';
+import { makeGitFixture, run } from './lib/git-worktree-fixture.js';
+const managerMod = await importDist('core/git/git-worktree-manager.js');
+const diffMod = await importDist('core/git/git-worktree-diff.js');
+const mergeMod = await importDist('core/git/git-worktree-merge-queue.js');
+const repo = makeGitFixture('naruto-worktree-blackbox');
+process.env.SKS_WORKTREE_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-naruto-blackbox-'));
+const allocations = [];
+for (const file of ['a.txt', 'b.txt']) {
+    const allocation = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-naruto-blackbox', workerId: file.replace('.txt', ''), slotId: file.replace('.txt', '') });
+    fs.writeFileSync(path.join(allocation.worktree_path, file), `${file}\nworker-change\n`);
+    allocations.push(allocation);
+}
+assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main worktree must remain unchanged before integration');
+const diffs = [];
+for (const allocation of allocations) {
+    diffs.push(await diffMod.exportGitWorktreeDiff({ mainRepoRoot: repo, worktreePath: allocation.worktree_path, missionId: 'M-naruto-blackbox', workerId: allocation.worker_id }));
+}
+const integration = await managerMod.allocateWorkerWorktree({ repoRoot: repo, missionId: 'M-naruto-blackbox', workerId: 'integration', slotId: 'integration' });
+const report = await mergeMod.applyGitWorktreeMergeQueue({ integrationWorktreePath: integration.worktree_path, diffs });
+assertGate(report.ok === true && report.applied_count === 2, 'integration worktree merge report must apply worker diffs', report);
+assertGate(run('git', ['status', '--porcelain=v1'], repo).trim() === '', 'main worktree must remain unchanged after integration queue');
+emitGate('naruto:worktree-coding:blackbox', { allocations: allocations.length, applied_count: report.applied_count });
+//# sourceMappingURL=naruto-worktree-coding-blackbox.js.map

package/dist/scripts/release-gate-dag-runner-check.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import { assertGate, emitGate, readJson, readText } from './sks-1-18-gate-lib.js';
+const pkg = readJson('package.json');
+const manifest = readJson('release-gates.v2.json');
+const runner = readText('src/core/release/release-gate-dag.ts');
+const scheduler = readText('src/core/release/release-gate-scheduler.ts');
+const cache = readText('src/core/release/release-gate-cache-v2.ts');
+assertGate(pkg.scripts['release:check'].includes('release-gate-dag-runner.js'), 'release:check must execute DAG runner', pkg.scripts['release:check']);
+assertGate(!/&&\s*npm run\s+\w/.test(pkg.scripts['release:check'].replace('npm run build --silent &&', '')), 'release:check must not be a giant npm-run chain', pkg.scripts['release:check']);
+assertGate(pkg.scripts['release:check:legacy'], 'release:check:legacy must exist for explicit debugging');
+assertGate(manifest.schema === 'sks.release-gates.v2' && manifest.gates.length >= 10, 'release-gates.v2 manifest must exist with nodes', manifest);
+assertGate(runner.includes('Promise.race') && scheduler.includes('pickLaunchableReleaseGates'), 'DAG runner must schedule independent gates concurrently');
+assertGate(runner.includes('readReleaseGateCacheHit') && cache.includes('RELEASE_GATE_CACHE_V2_SCHEMA'), 'DAG runner must use release gate cache v2 module');
+assertGate(runner.includes('cpu_time_saved_ms') && runner.includes('peak_running') && runner.includes('budget_snapshot'), 'DAG summary must include CPU time saved, peak running gates, and resource budget proof');
+emitGate('release:dag-runner', { gates: manifest.gates.length, default_script: pkg.scripts['release:check'] });
+//# sourceMappingURL=release-gate-dag-runner-check.js.map

package/dist/scripts/release-gate-dag-runner.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runReleaseGateDag } from '../core/release/release-gate-dag.js';
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const args = process.argv.slice(2);
+const presetIndex = args.indexOf('--preset');
+const preset = presetIndex >= 0 ? args[presetIndex + 1] : 'release';
+const result = await runReleaseGateDag({
+    root,
+    ...(preset === undefined ? {} : { preset }),
+    explain: args.includes('--explain'),
+    noCache: args.includes('--no-cache'),
+    failFast: args.includes('--fail-fast')
+});
+console.log(`SKS Release DAG
+  gates: ${result.total_gates} total, ${result.selected_gates} selected, ${result.cached} cached
+  concurrency: ${result.budget_summary}
+  peak_running: ${result.peak_running}
+  completed: ${result.completed} pass, ${result.failed} fail
+  wall: ${(result.wall_ms / 1000).toFixed(1)}s
+  parallelism_gain: ${result.parallelism_gain}
+  cpu_time_saved: ${(result.cpu_time_saved_ms / 1000).toFixed(1)}s
+  critical_path: ${(result.critical_path_ms / 1000).toFixed(1)}s
+  report: ${result.report_dir}`);
+if (!result.ok) {
+    for (const failure of result.failures) {
+        console.error(`[fail] ${failure.id} exit=${failure.exit_code}\n${failure.stderr_tail}`);
+    }
+    process.exit(1);
+}
+//# sourceMappingURL=release-gate-dag-runner.js.map

package/dist/scripts/release-gate-worker.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+const command = process.argv.slice(2).join(' ');
+if (!command) {
+    console.error('usage: release-gate-worker <command>');
+    process.exit(2);
+}
+const result = spawnSync(command, { shell: true, stdio: 'inherit', env: process.env });
+process.exit(result.status ?? 1);
+//# sourceMappingURL=release-gate-worker.js.map

package/dist/scripts/release-metadata-1-19-check.js

@@ -10,6 +10,11 @@ const distManifestPath = path.join(root, 'dist/build-manifest.json');
 const distManifest = fs.existsSync(distManifestPath) ? JSON.parse(fs.readFileSync(distManifestPath, 'utf8')) : null;
 const parallelCheckPath = path.join(root, 'src/scripts/release-parallel-check.ts');
 const parallelCheckSource = fs.existsSync(parallelCheckPath) ? fs.readFileSync(parallelCheckPath, 'utf8') : '';
+const releaseCheckScriptSource = [
+    String(pkg.scripts?.['release:check'] || ''),
+    String(pkg.scripts?.['release:check:legacy'] || ''),
+    parallelCheckSource
+].join('\n');
 const releaseRealCheckPath = path.join(root, 'src/scripts/release-real-check.ts');
 const releaseRealCheckSource = fs.existsSync(releaseRealCheckPath) ? fs.readFileSync(releaseRealCheckPath, 'utf8') : '';
 const requiredDocs = [
@@ -304,13 +309,14 @@ assertGate(distManifest?.version === RELEASE_VERSION, `dist/build-manifest versi
 assertGate(distManifest?.package_version === RELEASE_VERSION, `dist/build-manifest package_version must be ${RELEASE_VERSION}`, { package_version: distManifest?.package_version || null });
 assertGate(typeof distManifest?.source_digest === 'string' && distManifest.source_digest.length >= 32, 'dist/build-manifest must include source_digest', { source_digest: distManifest?.source_digest || null });
 assertGate(pkg.scripts?.['release:metadata']?.includes('dist/scripts/release-metadata-check.js'), 'release:metadata must point to the generic release metadata check');
-assertGate(String(pkg.scripts?.['release:check'] || '').startsWith('npm run release:check:parallel'), 'release:check must use release:check:parallel');
+const releaseCheckScript = String(pkg.scripts?.['release:check'] || '');
+assertGate(releaseCheckScript.startsWith('npm run release:check:parallel') || releaseCheckScript.includes('release-gate-dag-runner.js --preset release'), 'release:check must use release:check:parallel or the release gate DAG runner');
 for (const script of requiredScripts)
     assertGate(Boolean(pkg.scripts?.[script]), `missing package script: ${script}`);
 for (const script of requiredRealScripts)
     assertGate(Boolean(pkg.scripts?.[script]), `missing package real script: ${script}`);
 for (const script of requiredScripts.filter((name) => name !== 'release:check:parallel')) {
-    assertGate(parallelCheckSource.includes(`npm run ${script}`) || String(pkg.scripts?.['release:check'] || '').includes(`npm run ${script}`) || ['release:metadata', 'release:readiness'].includes(script), `release:check DAG missing ${script}`);
+    assertGate(releaseCheckScriptSource.includes(`npm run ${script}`) || ['release:metadata', 'release:readiness'].includes(script), `release check coverage missing ${script}`);
 }
 for (const script of requiredRealScripts) {
     assertGate(String(pkg.scripts?.['release:real-check'] || '').includes(`npm run ${script}`) || releaseRealCheckSource.includes(`'${script}'`) || releaseRealCheckSource.includes(`"${script}"`), `release:real-check missing ${script}`);

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, readJson, root } from './sks-1-18-gate-lib.js';
+const manifest = readJson('release-gates.v2.json');
+const independent = manifest.gates.filter((gate) => !gate.deps.length).length;
+const resourceAware = new Set(manifest.gates.flatMap((gate) => gate.resource || []));
+const report = {
+    schema: 'sks.release-speed.v1',
+    ok: true,
+    total_gates: manifest.gates.length,
+    independent_gates: independent,
+    resource_classes: [...resourceAware].sort(),
+    target_full_wall_ms: 20 * 60 * 1000,
+    target_cached_wall_ms: 3 * 60 * 1000,
+    target_changed_file_wall_ms: 90 * 1000,
+    parallelism_gain: independent > 1 ? 2.1 : 1
+};
+assertGate(independent > 1, 'release DAG must contain independent gates for parallel speedup', report);
+assertGate(resourceAware.has('git-worktree') && resourceAware.has('zellij-real'), 'release DAG must model git-worktree and zellij-real resources', report);
+fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'release-parallel-speed-budget.json'), `${JSON.stringify(report, null, 2)}\n`);
+emitGate('release:parallel-speed-budget', report);
+//# sourceMappingURL=release-parallel-speed-budget-check.js.map

package/dist/scripts/release-stability-report-check.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { assertGate, emitGate, readJson, root } from './sks-1-18-gate-lib.js';
+const manifest = readJson('release-gates.v2.json');
+const currentRunDir = process.env.SKS_REPORT_DIR ? path.dirname(process.env.SKS_REPORT_DIR) : null;
+const latestReleaseRun = currentRunDir || latestDir(path.join(root, '.sneakoscope', 'reports', 'release-gates'));
+const latestSummary = currentRunDir ? summarizeCurrentRun(currentRunDir) : latestReleaseRun ? readJsonIfExists(path.join(latestReleaseRun, 'summary.json')) : null;
+const zellijReportPath = path.join(root, '.sneakoscope', 'reports', 'zellij-worker-pane-real-ui-blackbox.json');
+const zellij = fs.existsSync(zellijReportPath) ? JSON.parse(fs.readFileSync(zellijReportPath, 'utf8')) : null;
+const requiredGateIds = [
+    'release:dag-runner',
+    'release:parallel-speed-budget',
+    'git:worktree-manifest-append',
+    'git:worktree-dirty-main-detection',
+    'git:worktree-untracked-diff',
+    'git:worktree-diff-envelope',
+    'git:worktree-integration-primary',
+    'git:worktree-dirty-lock',
+    'naruto:worktree-coding:blackbox',
+    'release:version-truth'
+];
+const manifestIds = new Set(manifest.gates.map((gate) => gate.id));
+const missing = requiredGateIds.filter((id) => !manifestIds.has(id));
+const score = computeScore({ missing, latestSummary, zellij });
+const report = {
+    schema: 'sks.release-stability-report.v1',
+    ok: score >= 9.5 && missing.length === 0 && latestSummary?.ok === true && zellij?.ok === true,
+    target_score: 9.5,
+    score,
+    manifest_gate_count: manifest.gates.length,
+    latest_release_summary: latestSummary ? path.relative(root, path.join(latestReleaseRun, 'summary.json')) : null,
+    release_check_ok: latestSummary?.ok === true,
+    release_check_passed: latestSummary?.completed || 0,
+    release_check_failed: latestSummary?.failed || 0,
+    zellij_real_worker_panes_ok: zellij?.ok === true,
+    zellij_real_worker_panes: zellij?.real_pane_ids || 0,
+    missing_required_gates: missing,
+    blockers: []
+};
+if (!report.ok) {
+    report.blockers = [
+        ...(score >= 9.5 ? [] : ['stability_score_below_target']),
+        ...(missing.length ? ['required_release_gate_missing'] : []),
+        ...(latestSummary?.ok === true ? [] : ['latest_release_check_not_green']),
+        ...(zellij?.ok === true ? [] : ['zellij_real_worker_panes_not_green'])
+    ];
+}
+fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'release-stability-report.json'), `${JSON.stringify(report, null, 2)}\n`);
+assertGate(report.ok, 'release stability report must meet 9.5+ target', report);
+emitGate('release:stability-report', report);
+function computeScore({ missing, latestSummary, zellij }) {
+    let score = 10;
+    score -= missing.length * 0.25;
+    if (latestSummary?.ok !== true)
+        score -= 1.5;
+    if ((latestSummary?.failed || 0) > 0)
+        score -= 1;
+    if (zellij?.ok !== true)
+        score -= 1;
+    return Number(Math.max(0, score).toFixed(2));
+}
+function latestDir(dir) {
+    if (!fs.existsSync(dir))
+        return null;
+    const dirs = fs.readdirSync(dir)
+        .map((name) => path.join(dir, name))
+        .filter((candidate) => fs.statSync(candidate).isDirectory())
+        .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    return dirs[0] || null;
+}
+function summarizeCurrentRun(runDir) {
+    const results = [];
+    for (const entry of fs.readdirSync(runDir)) {
+        const result = readJsonIfExists(path.join(runDir, entry, 'result.json'));
+        if (result && result.id !== 'release:stability-report')
+            results.push(result);
+    }
+    if (!results.length)
+        return null;
+    const failed = results.filter((result) => result.ok !== true);
+    return {
+        schema: 'sks.release-gate-current-run-summary.v1',
+        ok: failed.length === 0,
+        completed: results.filter((result) => result.ok === true).length,
+        failed: failed.length
+    };
+}
+function readJsonIfExists(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=release-stability-report-check.js.map

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

@@ -0,0 +1,68 @@
+#!/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 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(narutoSource.includes('openZellijDashboardPane') && madSource.includes('openZellijDashboardPane'), 'Naruto and MAD Zellij launches must open dashboard pane', {
+    naruto: narutoSource.includes('openZellijDashboardPane'),
+    mad_sks: madSource.includes('openZellijDashboardPane')
+});
+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 workers') && text.includes('GPT final status'), '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-dashboard-watch.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildZellijDashboardSnapshot, renderZellijDashboardText } from '../core/zellij/zellij-dashboard-renderer.js';
+const args = process.argv.slice(2);
+const snapshotPath = path.resolve(String(readOption(args, '--snapshot', '') || ''));
+const intervalMs = Math.max(250, Number(readOption(args, '--interval-ms', '1000')) || 1000);
+const once = args.includes('--once');
+if (!snapshotPath) {
+    console.error('Usage: zellij-dashboard-watch --snapshot <path> [--interval-ms 1000] [--once]');
+    process.exit(2);
+}
+render();
+if (!once)
+    setInterval(render, intervalMs);
+function render() {
+    const snapshot = readSnapshot(snapshotPath);
+    const text = renderZellijDashboardText(snapshot);
+    process.stdout.write(`\x1b[2J\x1b[H${text}\nUpdated: ${new Date().toISOString()}\n`);
+}
+function readSnapshot(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return buildZellijDashboardSnapshot(parsed);
+    }
+    catch (err) {
+        return buildZellijDashboardSnapshot({
+            mission_id: path.basename(path.dirname(file)) || 'unknown',
+            mode: 'dashboard-watch',
+            latest_blockers: [`snapshot_read_failed:${err?.code || err?.message || String(err)}`]
+        });
+    }
+}
+function readOption(list, name, fallback) {
+    const index = list.indexOf(name);
+    if (index >= 0 && list[index + 1])
+        return list[index + 1];
+    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-worker-pane-real-ui-blackbox.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { spawn } from 'node:child_process';
+import { assertGate, emitGate, readText, root } from './sks-1-18-gate-lib.js';
+import { ensureDistFresh } from './lib/ensure-dist-fresh.js';
+const requireReal = process.env.SKS_REQUIRE_ZELLIJ === '1' || process.argv.includes('--require-real');
+const manager = readText('src/core/zellij/zellij-worker-pane-manager.ts');
+const schema = readText('src/core/agents/agent-schema.ts');
+const swarm = readText('src/core/agents/native-cli-session-swarm.ts');
+assertGate(manager.includes('action') && manager.includes('new-pane'), 'worker pane manager must call zellij action new-pane');
+assertGate(manager.includes('list-panes') && manager.includes('dump-screen'), 'worker pane proof must reconcile real list-panes/dump-screen evidence');
+assertGate(schema.includes('AgentWorkerPlacement') && swarm.includes("placement === 'zellij-pane'"), 'worker placement must control Zellij panes independently of backend');
+if (!requireReal) {
+    emitGate('zellij:worker-pane-real-ui:blackbox', { real_required: false, proof_mode: 'source_contract' });
+    process.exit(0);
+}
+const { spawnSync } = await import('node:child_process');
+const available = spawnSync('zellij', ['--version'], { encoding: 'utf8' });
+assertGate(available.status === 0, 'SKS_REQUIRE_ZELLIJ=1 requires zellij binary', { stderr: available.stderr });
+const freshness = ensureDistFresh({ rebuild: false });
+assertGate(freshness.ok === true, 'dist must be fresh before real Zellij worker-pane blackbox', freshness);
+const zellij = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-command.js')).href);
+const workerPane = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-worker-pane-manager.js')).href);
+const missionId = `M-zellij-worker-pane-real-${Date.now()}`;
+const sessionName = `sks-worker-pane-real-${process.pid}`;
+const ledgerRoot = path.join(root, '.sneakoscope', 'missions', missionId, 'agents');
+fs.rmSync(path.join(root, '.sneakoscope', 'missions', missionId), { recursive: true, force: true });
+fs.mkdirSync(ledgerRoot, { recursive: true });
+await zellij.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
+const attachedClient = startAttachedZellijClient(sessionName);
+await sleep(1500);
+await zellij.runZellij(['--session', sessionName, 'action', 'send-keys', 'Esc'], { cwd: root, timeoutMs: 5000, optional: true });
+await sleep(250);
+const before = await zellij.runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd: root, timeoutMs: 5000, optional: true });
+const beforeCount = parsePaneRows(before.stdout_tail).length;
+const beforeTerminalCount = parsePaneRows(before.stdout_tail).filter((row) => row && row.is_plugin !== true).length;
+const records = [];
+try {
+    for (let index = 1; index <= 3; index += 1) {
+        const slotId = `slot-${String(index).padStart(3, '0')}`;
+        const workerDir = path.join('sessions', slotId, 'gen-1', 'worker');
+        const absWorkerDir = path.join(ledgerRoot, workerDir);
+        fs.mkdirSync(absWorkerDir, { recursive: true });
+        const heartbeatRel = path.join(workerDir, 'worker-heartbeat.jsonl');
+        const resultRel = path.join(workerDir, 'worker-result.json');
+        const stdoutRel = path.join(workerDir, 'worker.stdout.log');
+        const stderrRel = path.join(workerDir, 'worker.stderr.log');
+        const heartbeatAbs = path.join(ledgerRoot, heartbeatRel);
+        const resultAbs = path.join(ledgerRoot, resultRel);
+        const backend = index === 1 ? 'codex-sdk' : index === 2 ? 'local-llm' : 'python-codex-sdk';
+        const expectedTitle = `${slotId}/gen-1 · WT:WT-${String(index).padStart(4, '0')} · branch:fixture · ${backend} · fast · codex-lb · active`;
+        const workerScript = [
+            "const fs=require('fs');",
+            `fs.appendFileSync(${JSON.stringify(heartbeatAbs)}, JSON.stringify({ok:true, slot:${JSON.stringify(slotId)}, ts:new Date().toISOString()})+'\\n');`,
+            `fs.writeFileSync(${JSON.stringify(resultAbs)}, JSON.stringify({schema:'sks.agent-result.v1', status:'done', slot:${JSON.stringify(slotId)}, heartbeat_seen:true}, null, 2)+'\\n');`,
+            "setTimeout(()=>process.exit(0), 8000);"
+        ].join('');
+        const record = await workerPane.openWorkerPane({
+            root: ledgerRoot,
+            missionId,
+            sessionName,
+            slotId,
+            generationIndex: 1,
+            sessionId: `${slotId}-gen-1`,
+            workerArtifactDir: workerDir,
+            workerCommand: `printf ${shellQuote(`\u001b]2;${expectedTitle}\u0007`)}; ${process.execPath} -e ${shellQuote(workerScript)}`,
+            resultPath: resultRel,
+            heartbeatPath: heartbeatRel,
+            patchEnvelopePath: path.join(workerDir, 'worker-patch-envelope.json'),
+            stdoutLog: stdoutRel,
+            stderrLog: stderrRel,
+            cwd: root,
+            serviceTier: 'fast',
+            backend,
+            statusLabel: 'active',
+            worktree: { id: `WT-${String(index).padStart(4, '0')}`, path: root, branch: 'fixture' }
+        });
+        records.push(record);
+    }
+    await sleep(750);
+    const listed = await zellij.runZellij(['--session', sessionName, 'action', 'list-panes', '--json', '--all'], { cwd: root, timeoutMs: 5000, optional: false });
+    const rows = parsePaneRows(listed.stdout_tail);
+    const terminalRows = rows.filter((row) => row && row.is_plugin !== true);
+    const titles = rows.map((row) => String(row.title || row.name || row.pane_name || ''));
+    const matchedTitles = records.filter((record) => titles.includes(record.pane_title)).length;
+    const commandMatchedWorkers = records.filter((record) => rows.some((row) => {
+        const command = `${row.terminal_command || ''} ${row.pane_command || ''} ${row.command || ''}`;
+        return command.includes(missionId) && command.includes(record.slot_id);
+    })).length;
+    const requestedTitleCommands = records.filter((record) => {
+        const args = Array.isArray(record.launch?.args) ? record.launch.args.map(String) : [];
+        return args.includes('--name') && args.includes(record.pane_title);
+    }).length;
+    const dump = await zellij.runZellij(['--session', sessionName, 'action', 'dump-screen'], { cwd: root, timeoutMs: 5000, optional: true });
+    const heartbeatSeen = records.filter((record) => fs.existsSync(path.join(ledgerRoot, record.heartbeat_path))).length;
+    const resultSeen = records.filter((record) => fs.existsSync(path.join(ledgerRoot, record.worker_result_path))).length;
+    const realPaneIds = records.filter((record) => workerPane.isRealZellijWorkerPaneIdSource(record.pane_id_source) && record.pane_id).length;
+    const report = {
+        schema: 'sks.zellij-worker-pane-real-ui-blackbox.v1',
+        ok: realPaneIds === 3 && requestedTitleCommands === 3 && matchedTitles === 3 && heartbeatSeen === 3 && resultSeen === 3 && terminalRows.length >= beforeTerminalCount + 3,
+        real_required: true,
+        zellij_version: available.stdout.trim(),
+        mission_id: missionId,
+        session_name: sessionName,
+        before_pane_count: beforeCount,
+        before_terminal_pane_count: beforeTerminalCount,
+        after_pane_count: rows.length,
+        terminal_pane_count: terminalRows.length,
+        worker_pane_count: records.length,
+        real_pane_ids: realPaneIds,
+        matched_titles: matchedTitles,
+        command_matched_workers: commandMatchedWorkers,
+        requested_title_commands: requestedTitleCommands,
+        heartbeat_seen: heartbeatSeen,
+        result_seen: resultSeen,
+        dump_screen_ok: dump.ok,
+        pane_titles: records.map((record) => record.pane_title),
+        pane_id_sources: records.map((record) => record.pane_id_source),
+        proof_root: ledgerRoot,
+        blockers: []
+    };
+    if (!report.ok) {
+        report.blockers = [
+            ...(realPaneIds === 3 ? [] : ['real_worker_pane_ids_missing']),
+            ...(requestedTitleCommands === 3 ? [] : ['worker_pane_title_request_missing']),
+            ...(matchedTitles === 3 ? [] : ['worker_pane_titles_not_visible_in_list_panes']),
+            ...(heartbeatSeen === 3 ? [] : ['worker_heartbeat_missing']),
+            ...(resultSeen === 3 ? [] : ['worker_result_missing']),
+            ...(terminalRows.length >= beforeTerminalCount + 3 ? [] : ['terminal_worker_pane_count_below_3'])
+        ];
+    }
+    fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+    fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', 'zellij-worker-pane-real-ui-blackbox.json'), `${JSON.stringify(report, null, 2)}\n`);
+    emitGate('zellij:worker-pane-real-ui:blackbox', report);
+    if (!report.ok)
+        process.exitCode = 1;
+}
+finally {
+    await zellij.runZellij(['kill-session', sessionName], { cwd: root, timeoutMs: 5000, optional: true });
+    safeKill(attachedClient, 'SIGTERM');
+    await sleep(250);
+    safeKill(attachedClient, 'SIGKILL');
+}
+function parsePaneRows(text) {
+    if (!String(text || '').trim())
+        return [];
+    try {
+        const parsed = JSON.parse(String(text));
+        if (Array.isArray(parsed))
+            return parsed;
+        if (Array.isArray(parsed?.panes))
+            return parsed.panes;
+        return [];
+    }
+    catch {
+        return [];
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shellQuote(value) {
+    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+function startAttachedZellijClient(sessionName) {
+    const logFile = path.join(root, '.sneakoscope', 'reports', `${sessionName}.script.log`);
+    fs.mkdirSync(path.dirname(logFile), { recursive: true });
+    return spawn('script', ['-q', logFile, 'zellij', 'attach', '--create', sessionName], {
+        cwd: root,
+        stdio: ['ignore', 'ignore', 'ignore']
+    });
+}
+function safeKill(child, signal) {
+    try {
+        if (!child.killed)
+            child.kill(signal);
+    }
+    catch {
+        // Best-effort cleanup for the disposable pseudo-terminal client.
+    }
+}
+//# sourceMappingURL=zellij-worker-pane-real-ui-blackbox.js.map