sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/zellij-worker-pane-real-ui-blackbox.js

@@ -0,0 +1,202 @@
+#!/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), 30000);"
+        ].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 workerKindRecords = records.filter((record) => record.pane_kind === 'worker_codex_sdk').length;
+    const workerPrimitiveRecords = records.filter((record) => record.scaling_primitive === 'native_cli_process_in_zellij_worker_pane').length;
+    const recordProofOk = records.length === 3
+        && realPaneIds === 3
+        && workerKindRecords === 3
+        && workerPrimitiveRecords === 3
+        && requestedTitleCommands === 3
+        && heartbeatSeen === 3
+        && resultSeen === 3;
+    const listPanesVisibilityOk = matchedTitles === 3
+        || commandMatchedWorkers === 3
+        || terminalRows.length >= beforeTerminalCount + 3;
+    const report = {
+        schema: 'sks.zellij-worker-pane-real-ui-blackbox.v1',
+        ok: recordProofOk && dump.ok,
+        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,
+        worker_kind_records: workerKindRecords,
+        worker_primitive_records: workerPrimitiveRecords,
+        matched_titles: matchedTitles,
+        command_matched_workers: commandMatchedWorkers,
+        requested_title_commands: requestedTitleCommands,
+        heartbeat_seen: heartbeatSeen,
+        result_seen: resultSeen,
+        dump_screen_ok: dump.ok,
+        record_proof_ok: recordProofOk,
+        list_panes_visibility_ok: listPanesVisibilityOk,
+        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']),
+            ...(workerKindRecords === 3 ? [] : ['worker_pane_kind_missing']),
+            ...(workerPrimitiveRecords === 3 ? [] : ['worker_pane_scaling_primitive_missing']),
+            ...(requestedTitleCommands === 3 ? [] : ['worker_pane_title_request_missing']),
+            ...(heartbeatSeen === 3 ? [] : ['worker_heartbeat_missing']),
+            ...(resultSeen === 3 ? [] : ['worker_result_missing']),
+            ...(dump.ok ? [] : ['worker_pane_dump_screen_failed'])
+        ];
+    }
+    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/dist/scripts/zellij-worker-pane-spawn-order-check.js

@@ -0,0 +1,35 @@
+#!/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 manager = await import(pathToFileURL(path.join(root, 'dist', 'core', 'zellij', 'zellij-worker-pane-manager.js')).href);
+const valid = manager.evaluateZellijWorkerPaneSpawnOrder([
+    { 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' }
+]);
+const invalid = manager.evaluateZellijWorkerPaneSpawnOrder([
+    { event_type: 'session_launch_started' },
+    { event_type: 'worker_started' },
+    { event_type: 'zellij_worker_pane_created' },
+    { event_type: 'result_written' }
+]);
+const ok = valid.ok && invalid.ok === false && invalid.blockers.includes('spawn_order_missing_codex_sdk_thread_started');
+emit({
+    schema: 'sks.zellij-worker-pane-spawn-order-check.v1',
+    ok,
+    valid,
+    invalid,
+    blockers: ok ? [] : ['zellij_worker_pane_spawn_order_check_failed']
+});
+function emit(report) { console.log(JSON.stringify(report, null, 2)); if (!report.ok)
+    process.exitCode = 1; }
+function fail(blocker, detail) { emit({ schema: 'sks.zellij-worker-pane-spawn-order-check.v1', ok: false, blockers: [blocker], detail }); process.exit(1); }
+//# sourceMappingURL=zellij-worker-pane-spawn-order-check.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "4.0.13",
+  "version": "4.0.15",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -33,12 +33,11 @@
     "!dist/**/__tests__",
     "!dist/**/*.test.js",
     "!dist/vendor/openai-codex/rust-v0.131.0",
-    "!dist/scripts/*-blackbox.js",
-    "!dist/scripts/*-check.js",
-    "!dist/scripts/*-check-lib.js",
-    "!dist/scripts/*-report.js",
-    "!dist/scripts/release-readiness-report.js",
+    "config/codex-releases/rust-v0.142.0.json",
     "schemas",
+    "!schemas/codex/app-server-0.142/**",
+    "schemas/codex/app-server-0.142/codex_app_server_protocol.v2.schemas.json",
+    "!schemas/codex/app-server-0.142-ts/**",
     "crates/sks-core/Cargo.lock",
     "crates/sks-core/Cargo.toml",
     "crates/sks-core/src",
@@ -124,6 +123,16 @@
     "prepublish:fast-check": "node ./dist/scripts/prepublish-fast-check.js",
     "prepublish:release-check-or-fast": "node ./dist/scripts/prepublish-release-check-or-fast.js",
     "mad:preflight-blocks-unreadable-config": "node ./dist/scripts/mad-preflight-blocks-unreadable-config-check.js",
+    "codex:0142:manifest": "node ./dist/scripts/codex-0142-manifest-check.js",
+    "codex:0142:binary-identity": "node ./dist/scripts/codex-0142-binary-identity-check.js",
+    "codex:0142:policy": "node ./dist/scripts/codex-0142-policy-check.js",
+    "codex:0142:app-server-v2": "node ./dist/scripts/codex-0142-app-server-v2-check.js",
+    "codex:0142:app-server-v2:real": "node ./dist/scripts/codex-0142-app-server-v2-check.js --require-real",
+    "codex:0142:thread-store": "node ./dist/scripts/codex-0142-thread-store-check.js",
+    "codex:0142:capability": "node ./dist/scripts/codex-0142-capability-check.js",
+    "codex:0142:real": "node ./dist/scripts/codex-0142-capability-check.js --require-real",
+    "codex:0.142-compat": "node ./dist/scripts/codex-0142-capability-check.js",
+    "release:codex-current": "npm run codex:0142:manifest && npm run codex:0142:binary-identity && npm run codex:0142:policy && npm run codex:0142:app-server-v2 && npm run codex:0142:thread-store && npm run codex:0142:capability",
     "codex:0.141-compat": "node ./dist/scripts/codex-0141-capability-check.js",
     "codex:0.136-compat": "node ./dist/scripts/codex-0-136-compat-check.js",
     "codex:0.136-compat:require-real": "node ./dist/scripts/codex-0-136-compat-check.js --require-real",
@@ -952,6 +961,7 @@
     "codex:0140-large-repo-performance": "node ./dist/scripts/codex-0140-large-repo-performance-check.js",
     "codex:0140-real-probes": "node ./dist/scripts/codex-0140-real-probes-check.js",
     "codex:0140-real-probes:require-real": "node ./dist/scripts/codex-0140-real-probes-check.js --require-real --allow-network",
+    "package:published-contract": "node ./dist/scripts/package-published-contract-check.js",
     "pipeline:codex-0140-integration": "node ./dist/scripts/pipeline-codex-0140-integration-check.js",
     "codex:0140-integration-blackbox": "node ./dist/scripts/codex-0140-integration-blackbox.js",
     "doctor:transaction-engine": "node ./dist/scripts/doctor-transaction-engine-check.js",
@@ -1067,7 +1077,7 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",
-    "@openai/codex-sdk": "^0.138.0",
+    "@openai/codex-sdk": "0.142.0",
     "figlet": "^1.11.0",
     "typescript": "^5.9.3"
   },