sneakoscope 2.0.6 → 2.0.8

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-check.js

@@ -269,7 +269,7 @@ const tasks = [
     task('docs:truthfulness', 'npm run docs:truthfulness --silent', { dependencies: ['build'] }),
     task('official-docs:compat', 'npm run official-docs:compat --silent', { dependencies: ['build'] }),
     task('blackbox:matrix:contract', 'npm run blackbox:matrix:contract --silent', { dependencies: ['build'] }),
-    task('test:blackbox', 'npm run test:blackbox --silent', { dependencies: ['build'], timeout_ms: 20 * 60 * 1000 }),
+    task('test:blackbox', 'npm run test:blackbox --silent', { dependencies: ['build', 'naruto:shadow-clone-swarm'], timeout_ms: 20 * 60 * 1000 }),
     task('rust:check', 'npm run rust:check --silent', { dependencies: ['build'] }),
     task('rust:smoke', 'npm run rust:smoke --silent', { dependencies: ['build'] }),
     task('release:dist-freshness', 'npm run release:dist-freshness --silent', { dependencies: ['build'] }),

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -312,10 +312,10 @@
     "ultra-router:classification": "node ./dist/scripts/ultra-router-classification-check.js",
     "ultra-router:auto-router": "node ./dist/scripts/ultra-router-auto-router-check.js",
     "coverage": "node --experimental-test-coverage --test \"test/**/*.test.mjs\"",
-    "release:check": "npm run release:check:parallel && npm run mad-sks:app-ui-no-mutation && npm run codex-app:fast-ui-preservation && npm run codex-app:ui-clobber-guard && npm run doctor:fixes-codex-app-fast-ui && npm run provider:badge-context && npm run provider:context-config-toml && npm run codex-app:provider-badge && npm run zellij:spawn-on-demand-layout && npm run zellij:worker-pane-manager && npm run zellij:worker-pane-manager-single-owner && npm run agent:worker-pane-communication-contract && npm run runtime:no-mjs-scripts && npm run runtime:ts-python-boundary && npm run codex-sdk:capability && npm run codex-sdk:no-legacy-fallback && npm run codex-sdk:backend-router && npm run codex-sdk:structured-output && npm run codex-sdk:event-stream-ledger && npm run codex-sdk:thread-registry && npm run codex-sdk:sandbox-policy && npm run codex-sdk:zellij-pane-binding && npm run codex-sdk:all-pipelines && npm run codex-sdk:dfix-pipeline && npm run codex-sdk:qa-pipeline && npm run codex-sdk:research-pipeline && npm run codex-sdk:team-naruto-agent-pipeline && npm run codex-sdk:release-review-pipeline && npm run codex-sdk:ux-ppt-review-pipeline && npm run codex-sdk:core-skill-pipeline && npm run codex-control:capability && npm run codex-control:no-legacy-fallback && npm run codex-control:structured-output && npm run codex-control:event-stream-ledger && npm run codex-control:thread-registry && npm run codex-control:side-effect-scope && npm run codex-control:all-pipelines && npm run codex-control:empty-result-retry && npm run codex-control:stream-idle-watchdog && npm run codex-control:tool-call-sequence-repair && npm run codex-control:keepalive-no-cot-leak && npm run local-collab:policy && npm run local-collab:gpt-final-arbiter && npm run local-collab:no-local-only-final && npm run local-collab:gpt-final-availability && npm run local-llm:capability && npm run local-llm:structured-output && npm run local-llm:tool-call-repair && npm run local-llm:all-pipelines && npm run local-collab:all-pipelines-final-gpt && npm run python-sdk:capability && npm run python-sdk:stream-bridge && npm run python-sdk:sandbox-policy && npm run python-sdk:all-pipelines && npm run codex:plugin-list-json && npm run codex:product-design-plugin-routing && npm run codex:product-design-auto-install && npm run codex:thread-runtime-choice && npm run codex:environment-scoped-approvals && npm run ultra-router:classification && npm run ultra-router:auto-router && npm run release:version-truth && npm run codex:0.137-compat && npm run codex:0.136-compat && npm run codex:0.135-compat && npm run doctor:codex-doctor-parity && npm run codex:permission-profiles && npm run codex:legacy-profile-consumers-removed && npm run terminal:keyboard-enhancement-safety && npm run terminal:tui-output-stability && npm run codex:resume-cwd-truth && npm run mcp:tool-naming-parity && npm run responses:retry-policy-centralized && npm run runtime:no-tmux && npm run zellij:layout-valid && npm run agent:zellij-dynamic-backfill-panes && npm run agent:worker-pane-communication-contract && npm run agent:slot-pane-binding-proof && npm run zellij:worker-pane-manager && npm run zellij:spawn-on-demand-layout && npm run zellij:lane-renderer && npm run mad-sks:zellij-launch && npm run mad-sks:zellij-default-pane-worker && npm run agent:zellij-runtime && npm run codex:config-eperm-fixture && npm run doctor:fix-proves-codex-read && npm run mad:preflight-blocks-unreadable-config && npm run fast:codex-service-tier-proof && npm run codex:project-config-policy-splitter && npm run test:no-orphan-dist-imports && npm run agent:patch-envelope-extraction && npm run agent:patch-queue-runtime && npm run agent:strategy-to-lease-wiring && npm run agent:patch-swarm-runtime && npm run agent:patch-transaction-journal && npm run agent:patch-conflict-rebase && npm run agent:strategy-to-patch-strict && npm run agent:patch-swarm-runtime-truth && npm run agent:rollback-command && npm run agent:patch-verification-dag && npm run agent:patch-rollback-dag && npm run agent:patch-proof-runtime && npm run agent:patch-swarm-route-blackbox && npm run team:patch-swarm-route-blackbox && npm run dfix:patch-swarm-route-blackbox && npm run appshots:thread-attachment-discovery && npm run mcp:readonly-runtime-scheduler && npm run naruto:work-graph && npm run naruto:readonly-routing && npm run naruto:concurrency-governor && npm run naruto:active-pool && npm run naruto:role-distribution && npm run naruto:parallel-patch-apply && npm run naruto:verification-pool && npm run naruto:zellij-massive-ui && npm run naruto:gpt-final-pack && npm run prompt:placeholder-guard && npm run codex:0.134-runner-truth && npm run agent:native-cli-session-swarm && npm run naruto:shadow-clone-swarm && npm run agent:native-cli-session-swarm-10 && npm run agent:native-cli-session-swarm-20 && npm run agent:no-subagent-scaling && npm run agent:native-cli-session-proof && npm run agent:worker-backend-router && npm run agent:codex-child-overlap && npm run agent:model-authored-patch-envelope && npm run agent:fast-mode-default && npm run agent:fast-mode-worker-propagation && npm run codex:fast-mode-profile-propagation && npm run mad-sks:fast-mode-propagation && npm run zellij:launch-command-truth && npm run zellij:real-session-heartbeat && npm run zellij:ui-design && npm run zellij:doctor-readiness && npm run legacy:upgrade-zero-break && npm run publish:packlist-performance && npm run postinstall:safe-side-effects && npm run runtime:ts-rust-boundary && npm run core-skill:card-schema && npm run core-skill:rollout-scoring && npm run core-skill:patch && npm run core-skill:heldout-validation && npm run core-skill:deployment-snapshot && npm run core-skill:no-inference-optimizer && npm run core-skill:route-runtime-integration && npm run core-skill:promotion-side-effect-ledger && npm run core-skill:legacy-promotion-api-audit && npm run safety:side-effect-zero && npm run safety:mutation-callsite-coverage && npm run safety:mutation-callsite-coverage:repo-wide && npm run side-effect:runtime-report && npm run release:gate-planner && npm run release:dynamic-performance && npm run release:provenance && npm run release:gate-budget && npm run agent:wiki-context-proof && npm run shared-memory:check && npm run wrongness:check && npm run wrongness:fixtures && npm run trust:check && npm run git-collaboration:e2e && node ./dist/scripts/release-check-stamp.js write && npm run release:readiness --silent && node ./dist/scripts/release-check-stamp.js write",
-    "release:real-check": "node ./dist/scripts/release-real-check.js && npm run codex-control:real-smoke -- --require-real && npm run codex-sdk:real-smoke -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:smoke && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:throughput && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:cache-performance && SKS_REQUIRE_PYTHON_CODEX_SDK=1 npm run python-sdk:real-smoke && SKS_REQUIRE_CODEX_0137=1 npm run codex:0.137-compat:require-real && npm run zellij:real-session-launch -- --require-real --main-only --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run zellij:pane-proof -- --require-real --mission M-release-real-zellij-extra --session sks-rrz-extra --expected-lanes 0 && npm run zellij:screen-proof -- --require-real --main-only --mission M-release-real-zellij-extra && npm run zellij:real-session-cleanup -- --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run agent:real-codex-in-zellij-worker-pane -- --require-real && SKS_REQUIRE_ZELLIJ=1 npm run naruto:zellij-massive-ui -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run naruto:real-local-gpt-final-smoke && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run local-collab:gpt-final-performance",
+    "release:check": "npm run build --silent && node ./dist/scripts/release-gate-dag-runner.js --preset release && node ./dist/scripts/release-check-stamp.js write",
+    "release:real-check": "node ./dist/scripts/release-real-check.js && SKS_REQUIRE_GIT_WORKTREE=1 npm run naruto:worktree-coding:blackbox -- --require-real && npm run codex-control:real-smoke -- --require-real && npm run codex-sdk:real-smoke -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:smoke && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:throughput && SKS_REQUIRE_LOCAL_LLM=1 npm run local-llm:cache-performance && SKS_REQUIRE_PYTHON_CODEX_SDK=1 npm run python-sdk:real-smoke && SKS_REQUIRE_CODEX_0137=1 npm run codex:0.137-compat:require-real && npm run zellij:real-session-launch -- --require-real --main-only --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run zellij:pane-proof -- --require-real --mission M-release-real-zellij-extra --session sks-rrz-extra --expected-lanes 0 && npm run zellij:screen-proof -- --require-real --main-only --mission M-release-real-zellij-extra && npm run zellij:real-session-cleanup -- --mission M-release-real-zellij-extra --session sks-rrz-extra && npm run agent:real-codex-in-zellij-worker-pane -- --require-real && SKS_REQUIRE_ZELLIJ=1 npm run naruto:zellij-massive-ui -- --require-real && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run naruto:real-local-gpt-final-smoke && SKS_REQUIRE_LOCAL_LLM=1 SKS_REQUIRE_GPT_FINAL=1 npm run local-collab:gpt-final-performance && SKS_REQUIRE_ZELLIJ=1 npm run zellij:worker-pane-real-ui:blackbox -- --require-real",
     "release:publish": "npm run publish:npm",
-    "publish:dry": "npm run release:metadata && npm run release:version-truth && npm run publish:packlist-performance && npm run prepublish:release-check-or-fast && node ./dist/scripts/release-check-stamp.js verify && npm run release:provenance -- --publish && npm run release:dist-freshness && npm --cache /tmp/sks-npm-cache publish --dry-run --registry https://registry.npmjs.org/ --access public",
+    "publish:dry": "npm run release:metadata && npm run release:version-truth && npm run publish:packlist-performance && npm run prepublish:release-check-or-fast && node ./dist/scripts/check-publish-tag.js && node ./dist/scripts/release-check-stamp.js verify && npm run release:provenance -- --publish && npm run release:dist-freshness && node ./dist/scripts/release-registry-check.js --require-unpublished && npm --cache /tmp/sks-npm-cache publish --dry-run --ignore-scripts --registry https://registry.npmjs.org/ --access public",
     "publish:npm": "npm --cache /tmp/sks-npm-cache publish --registry https://registry.npmjs.org/ --access public",
     "prepack": "npm run build",
     "prepublishOnly": "npm run release:metadata && npm run release:version-truth && npm run release:dist-freshness && npm run publish:packlist-performance && npm run prepublish:release-check-or-fast && node ./dist/scripts/check-publish-tag.js && node ./dist/scripts/release-check-stamp.js verify && npm run release:provenance -- --publish && node ./dist/scripts/release-registry-check.js --require-unpublished --require-publish-auth",
@@ -453,6 +453,14 @@
     "agent:strategy-to-patch-strict": "node ./dist/scripts/agent-strategy-to-patch-strict-check.js",
     "agent:rollback-command": "node ./dist/scripts/agent-rollback-command-check.js",
     "agent:native-cli-session-swarm": "node ./dist/scripts/agent-native-cli-session-swarm-check.js",
+    "release:worktree-gates": "npm run git:worktree-capability && npm run git:worktree-manager && npm run git:worktree-diff-export && npm run git:worktree-merge-queue && npm run git:worktree-cleanup && npm run git:worktree-cache-performance && npm run git:worktree-pool-performance && npm run naruto:worktree-coding && npm run naruto:worktree-zellij-ui && npm run naruto:worktree-gpt-final",
+    "git:worktree-capability": "node ./dist/scripts/git-worktree-capability-check.js",
+    "git:worktree-manager": "node ./dist/scripts/git-worktree-manager-check.js",
+    "git:worktree-diff-export": "node ./dist/scripts/git-worktree-diff-export-check.js",
+    "git:worktree-merge-queue": "node ./dist/scripts/git-worktree-merge-queue-check.js",
+    "git:worktree-cleanup": "node ./dist/scripts/git-worktree-cleanup-check.js",
+    "git:worktree-cache-performance": "node ./dist/scripts/git-worktree-cache-performance-check.js",
+    "git:worktree-pool-performance": "node ./dist/scripts/git-worktree-pool-performance-check.js",
     "naruto:shadow-clone-swarm": "node ./dist/scripts/naruto-shadow-clone-swarm-check.js",
     "naruto:work-graph": "node ./dist/scripts/naruto-work-graph-check.js",
     "naruto:readonly-routing": "node ./dist/scripts/naruto-readonly-routing-check.js",
@@ -463,6 +471,9 @@
     "naruto:verification-pool": "node ./dist/scripts/naruto-verification-pool-check.js",
     "naruto:zellij-massive-ui": "node ./dist/scripts/naruto-zellij-massive-ui-check.js",
     "naruto:gpt-final-pack": "node ./dist/scripts/naruto-gpt-final-pack-check.js",
+    "naruto:worktree-coding": "node ./dist/scripts/naruto-worktree-coding-check.js",
+    "naruto:worktree-zellij-ui": "node ./dist/scripts/naruto-worktree-zellij-ui-check.js",
+    "naruto:worktree-gpt-final": "node ./dist/scripts/naruto-worktree-gpt-final-check.js",
     "naruto:real-local-gpt-final-smoke": "node ./dist/scripts/naruto-real-local-gpt-final-smoke.js",
     "prompt:placeholder-guard": "node ./dist/scripts/prompt-placeholder-guard-check.js",
     "agent:native-cli-session-swarm-10": "node ./dist/scripts/agent-native-cli-session-swarm-10-check.js",
@@ -490,7 +501,24 @@
     "runtime:ts-python-boundary": "node ./dist/scripts/runtime-ts-python-boundary-check.js",
     "python-tools:smoke": "node ./dist/scripts/python-tools-smoke-check.js",
     "agent:zellij-dynamic-backfill-panes": "node ./dist/scripts/agent-zellij-dynamic-backfill-panes-check.js",
-    "agent:real-codex-in-zellij-worker-pane": "node ./dist/scripts/agent-real-codex-in-zellij-worker-pane-check.js"
+    "agent:real-codex-in-zellij-worker-pane": "node ./dist/scripts/agent-real-codex-in-zellij-worker-pane-check.js",
+    "release:check:legacy": "npm run release:check:parallel && npm run mad-sks:app-ui-no-mutation && npm run codex-app:fast-ui-preservation && npm run codex-app:ui-clobber-guard && npm run doctor:fixes-codex-app-fast-ui && npm run provider:badge-context && npm run provider:context-config-toml && npm run codex-app:provider-badge && npm run zellij:spawn-on-demand-layout && npm run zellij:worker-pane-manager && npm run zellij:worker-pane-manager-single-owner && npm run agent:worker-pane-communication-contract && npm run runtime:no-mjs-scripts && npm run runtime:ts-python-boundary && npm run codex-sdk:capability && npm run codex-sdk:no-legacy-fallback && npm run codex-sdk:backend-router && npm run codex-sdk:structured-output && npm run codex-sdk:event-stream-ledger && npm run codex-sdk:thread-registry && npm run codex-sdk:sandbox-policy && npm run codex-sdk:zellij-pane-binding && npm run codex-sdk:all-pipelines && npm run codex-sdk:dfix-pipeline && npm run codex-sdk:qa-pipeline && npm run codex-sdk:research-pipeline && npm run codex-sdk:team-naruto-agent-pipeline && npm run codex-sdk:release-review-pipeline && npm run codex-sdk:ux-ppt-review-pipeline && npm run codex-sdk:core-skill-pipeline && npm run codex-control:capability && npm run codex-control:no-legacy-fallback && npm run codex-control:structured-output && npm run codex-control:event-stream-ledger && npm run codex-control:thread-registry && npm run codex-control:side-effect-scope && npm run codex-control:all-pipelines && npm run codex-control:empty-result-retry && npm run codex-control:stream-idle-watchdog && npm run codex-control:tool-call-sequence-repair && npm run codex-control:keepalive-no-cot-leak && npm run local-collab:policy && npm run local-collab:gpt-final-arbiter && npm run local-collab:no-local-only-final && npm run local-collab:gpt-final-availability && npm run local-llm:capability && npm run local-llm:structured-output && npm run local-llm:tool-call-repair && npm run local-llm:all-pipelines && npm run local-collab:all-pipelines-final-gpt && npm run python-sdk:capability && npm run python-sdk:stream-bridge && npm run python-sdk:sandbox-policy && npm run python-sdk:all-pipelines && npm run codex:plugin-list-json && npm run codex:product-design-plugin-routing && npm run codex:product-design-auto-install && npm run codex:thread-runtime-choice && npm run codex:environment-scoped-approvals && npm run ultra-router:classification && npm run ultra-router:auto-router && npm run release:version-truth && npm run release:worktree-gates && npm run codex:0.137-compat && npm run codex:0.136-compat && npm run codex:0.135-compat && npm run doctor:codex-doctor-parity && npm run codex:permission-profiles && npm run codex:legacy-profile-consumers-removed && npm run terminal:keyboard-enhancement-safety && npm run terminal:tui-output-stability && npm run codex:resume-cwd-truth && npm run mcp:tool-naming-parity && npm run responses:retry-policy-centralized && npm run runtime:no-tmux && npm run zellij:layout-valid && npm run agent:zellij-dynamic-backfill-panes && npm run agent:worker-pane-communication-contract && npm run agent:slot-pane-binding-proof && npm run zellij:worker-pane-manager && npm run zellij:spawn-on-demand-layout && npm run zellij:lane-renderer && npm run mad-sks:zellij-launch && npm run mad-sks:zellij-default-pane-worker && npm run agent:zellij-runtime && npm run codex:config-eperm-fixture && npm run doctor:fix-proves-codex-read && npm run mad:preflight-blocks-unreadable-config && npm run fast:codex-service-tier-proof && npm run codex:project-config-policy-splitter && npm run test:no-orphan-dist-imports && npm run agent:patch-envelope-extraction && npm run agent:patch-queue-runtime && npm run agent:strategy-to-lease-wiring && npm run agent:patch-swarm-runtime && npm run agent:patch-transaction-journal && npm run agent:patch-conflict-rebase && npm run agent:strategy-to-patch-strict && npm run agent:patch-swarm-runtime-truth && npm run agent:rollback-command && npm run agent:patch-verification-dag && npm run agent:patch-rollback-dag && npm run agent:patch-proof-runtime && npm run agent:patch-swarm-route-blackbox && npm run team:patch-swarm-route-blackbox && npm run dfix:patch-swarm-route-blackbox && npm run appshots:thread-attachment-discovery && npm run mcp:readonly-runtime-scheduler && npm run naruto:work-graph && npm run naruto:readonly-routing && npm run naruto:concurrency-governor && npm run naruto:active-pool && npm run naruto:role-distribution && npm run naruto:parallel-patch-apply && npm run naruto:verification-pool && npm run naruto:zellij-massive-ui && npm run naruto:gpt-final-pack && npm run prompt:placeholder-guard && npm run codex:0.134-runner-truth && npm run agent:native-cli-session-swarm && npm run naruto:shadow-clone-swarm && npm run agent:native-cli-session-swarm-10 && npm run agent:native-cli-session-swarm-20 && npm run agent:no-subagent-scaling && npm run agent:native-cli-session-proof && npm run agent:worker-backend-router && npm run agent:codex-child-overlap && npm run agent:model-authored-patch-envelope && npm run agent:fast-mode-default && npm run agent:fast-mode-worker-propagation && npm run codex:fast-mode-profile-propagation && npm run mad-sks:fast-mode-propagation && npm run zellij:launch-command-truth && npm run zellij:real-session-heartbeat && npm run zellij:ui-design && npm run zellij:doctor-readiness && npm run legacy:upgrade-zero-break && npm run publish:packlist-performance && npm run postinstall:safe-side-effects && npm run runtime:ts-rust-boundary && npm run core-skill:card-schema && npm run core-skill:rollout-scoring && npm run core-skill:patch && npm run core-skill:heldout-validation && npm run core-skill:deployment-snapshot && npm run core-skill:no-inference-optimizer && npm run core-skill:route-runtime-integration && npm run core-skill:promotion-side-effect-ledger && npm run core-skill:legacy-promotion-api-audit && npm run safety:side-effect-zero && npm run safety:mutation-callsite-coverage && npm run safety:mutation-callsite-coverage:repo-wide && npm run side-effect:runtime-report && npm run release:gate-planner && npm run release:dynamic-performance && npm run release:provenance && npm run release:gate-budget && npm run agent:wiki-context-proof && npm run shared-memory:check && npm run wrongness:check && npm run wrongness:fixtures && npm run trust:check && npm run git-collaboration:e2e && node ./dist/scripts/release-check-stamp.js write && npm run release:readiness --silent && node ./dist/scripts/release-check-stamp.js write",
+    "release:check:dag": "node ./dist/scripts/release-gate-dag-runner.js --preset release",
+    "release:check:dag:explain": "node ./dist/scripts/release-gate-dag-runner.js --preset release --explain",
+    "release:check:dag:no-cache": "node ./dist/scripts/release-gate-dag-runner.js --preset release --no-cache",
+    "release:check:dag:fail-fast": "node ./dist/scripts/release-gate-dag-runner.js --preset release --fail-fast",
+    "release:dag-runner": "node ./dist/scripts/release-gate-dag-runner-check.js",
+    "release:parallel-speed-budget": "node ./dist/scripts/release-parallel-speed-budget-check.js",
+    "release:stability-report": "node ./dist/scripts/release-stability-report-check.js",
+    "git:worktree-manifest-append": "node ./dist/scripts/git-worktree-manifest-append-check.js",
+    "git:worktree-dirty-main-detection": "node ./dist/scripts/git-worktree-dirty-main-detection-check.js",
+    "git:worktree-untracked-diff": "node ./dist/scripts/git-worktree-untracked-diff-check.js",
+    "git:worktree-diff-envelope": "node ./dist/scripts/git-worktree-diff-envelope-check.js",
+    "git:worktree-integration-primary": "node ./dist/scripts/git-worktree-integration-primary-check.js",
+    "git:worktree-dirty-lock": "node ./dist/scripts/git-worktree-dirty-lock-check.js",
+    "naruto:worktree-coding:blackbox": "node ./dist/scripts/naruto-worktree-coding-blackbox.js",
+    "zellij:worker-pane-real-ui:blackbox": "node ./dist/scripts/zellij-worker-pane-real-ui-blackbox.js",
+    "zellij:dashboard-pane": "node ./dist/scripts/zellij-dashboard-pane-check.js"
   },
   "keywords": [
     "sneakoscope",