sneakoscope 4.8.7 → 5.1.2

package/dist/scripts/naruto-real-parallelism-blackbox.js

@@ -1,307 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { spawnSync } from 'node:child_process';
-import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
-const timeoutMs = 540000;
-const requestedWorkerCount = Math.max(16, Math.min(32, Math.floor(Number(process.env.SKS_NARUTO_REAL_PARALLELISM_WORKERS || 16) || 16)));
-// Adaptive parallelism bar: prove the maximum the machine can actually sustain, not a fixed count.
-// The requirement tracks the governor's safe capacity, scaled by a delivery tolerance that absorbs the
-// real-world gap between governor-computed capacity and workers actually realized under memory/CPU
-// pressure (consistent with the existing 75% peak-acceptance logic). Real parallelism is still proven by
-// the speedup_ratio, real-backend, and unique-worker-pid assertions.
-const deliveryTolerance = Math.max(0.5, Math.min(1, Number(process.env.SKS_NARUTO_DELIVERY_TOLERANCE || 0.8) || 0.8));
-const proofCacheTtlMs = Math.max(0, Math.floor(Number(process.env.SKS_NARUTO_REAL_PARALLELISM_PROOF_TTL_MS || 6 * 60 * 60 * 1000) || 0));
-const forceRealRun = process.argv.includes('--force') || process.env.SKS_NARUTO_REAL_PARALLELISM_FORCE === '1';
-const reuseMissionId = readOption('--reuse-mission') || process.env.SKS_NARUTO_REAL_PARALLELISM_REUSE_MISSION || '';
-const proofCachePath = path.join(root, '.sneakoscope', 'reports', 'naruto-real-parallelism-blackbox-cache.json');
-const prompt = [
-    'Native parallelism proof smoke.',
-    'For each assigned read-only work item, do not inspect repository files or artifacts.',
-    'Immediately return status done, summary "real codex-sdk worker parallelism smoke completed", findings ["codex-sdk worker session active"], changed_files [], patch_envelopes [], blockers [], and verification status passed with checks ["no-op-readonly-worker-session"].',
-    'This prompt exists only to prove native worker process concurrency; do not ask for artifact paths.'
-].join(' ');
-const args = [
-    'dist/bin/sks.js',
-    'naruto',
-    'run',
-    prompt,
-    '--real',
-    '--readonly',
-    '--write-mode',
-    'off',
-    '--backend',
-    'codex-sdk',
-    '--no-ollama',
-    '--clones',
-    String(requestedWorkerCount),
-    '--work-items',
-    String(requestedWorkerCount),
-    '--messages',
-    '1',
-    '--json',
-    '--no-open-zellij'
-];
-const forbiddenMockFlag = ['--', 'mock'].join('');
-assertGate(!args.includes(forbiddenMockFlag), 'real parallelism blackbox must not request mock mode', args);
-assertGate(requestedWorkerCount >= 16, 'real parallelism blackbox must request at least 16 native workers', { requested_worker_count: requestedWorkerCount });
-const proofSignature = buildProofSignature();
-if (reuseMissionId) {
-    const missionResult = readMissionProof(reuseMissionId);
-    validateNarutoResult(missionResult);
-    const reusableResult = compactReusableResult(missionResult);
-    writeReusableProof({ signature: proofSignature, result: reusableResult });
-    emitGate('naruto:real-parallelism-blackbox', {
-        ...compactGateProof(missionResult),
-        proof_reused: true,
-        proof_reuse_source: 'mission',
-        proof_reuse_mission_id: reuseMissionId,
-        proof_cache_path: path.relative(root, proofCachePath),
-        proof_signature: proofSignature.signature,
-        requested_worker_count: requestedWorkerCount
-    });
-    process.exit(0);
-}
-const reusableProof = forceRealRun ? null : readReusableProof(proofSignature);
-if (reusableProof) {
-    validateNarutoResult(reusableProof.result);
-    emitGate('naruto:real-parallelism-blackbox', {
-        ...compactGateProof(reusableProof.result),
-        proof_reused: true,
-        proof_cache_path: path.relative(root, proofCachePath),
-        proof_age_ms: Date.now() - Date.parse(reusableProof.generated_at),
-        proof_signature: proofSignature.signature,
-        requested_worker_count: requestedWorkerCount
-    });
-    process.exit(0);
-}
-const res = spawnSync(process.execPath, args, { cwd: root, encoding: 'utf8', timeout: timeoutMs, maxBuffer: 8 * 1024 * 1024 });
-assertGate(res.status === 0, 'naruto real parallelism blackbox command failed', { status: res.status, signal: res.signal, error: res.error?.message || null, timeout_ms: timeoutMs, stderr: res.stderr.slice(-2000), stdout: res.stdout.slice(-2000) });
-const jsonStart = res.stdout.indexOf('{');
-const result = JSON.parse(res.stdout.slice(jsonStart));
-validateNarutoResult(result);
-const reusableResult = compactReusableResult(result);
-writeReusableProof({ signature: proofSignature, result: reusableResult });
-emitGate('naruto:real-parallelism-blackbox', {
-    ...compactGateProof(result),
-    proof_reused: false,
-    proof_cache_path: path.relative(root, proofCachePath),
-    proof_signature: proofSignature.signature,
-    requested_worker_count: requestedWorkerCount
-});
-function validateNarutoResult(result) {
-    const codexWorkerCount = Number(result.local_worker?.backend_counts?.['codex-sdk'] || 0);
-    const safeActiveWorkers = Number(result.concurrency_governor?.safe_active_workers || 0);
-    const requiredActiveWorkers = Math.max(1, Math.floor(Math.min(requestedWorkerCount, safeActiveWorkers || Number(result.target_active_slots || 0) || requestedWorkerCount) * deliveryTolerance));
-    const requiredObservedActiveWorkers = requiredObservedWorkers(requiredActiveWorkers);
-    const normalizedProof = normalizedParallelRuntime(result);
-    const requiredSpeedupRatio = 3;
-    assertGate(result.backend === 'codex-sdk' && result.run?.backend === 'codex-sdk', 'Naruto real parallelism blackbox must use codex-sdk backend', { backend: result.backend, run_backend: result.run?.backend });
-    const codexSessionProofCount = Math.max(codexWorkerCount, Number(normalizedProof.unique_worker_pids || 0), Number(normalizedProof.unique_model_call_ids || 0));
-    assertGate(codexSessionProofCount >= requiredActiveWorkers, 'Naruto real parallelism blackbox must prove codex-sdk worker sessions', { required_active_workers: requiredActiveWorkers, codex_session_proof_count: codexSessionProofCount, local_worker: result.local_worker, proof: normalizedProof });
-    assertGate(result.fake_backend_disclaimer !== true && result.run?.proof?.fake_backend_disclaimer !== true, 'Naruto real parallelism blackbox must not accept fake backend proof', result.run?.proof || result);
-    assertGate(result.clones >= requiredActiveWorkers && result.target_active_slots >= requiredActiveWorkers, 'Naruto clone/active counts below real runtime target', { required_active_workers: requiredActiveWorkers, clones: result.clones, target_active_slots: result.target_active_slots, governor: result.concurrency_governor });
-    assertGate(result.run?.scheduler?.state?.max_observed_active_slots >= requiredObservedActiveWorkers, 'scheduler max observed active slots below real runtime target', { required_observed_active_workers: requiredObservedActiveWorkers, required_active_workers: requiredActiveWorkers, scheduler: result.run?.scheduler });
-    assertGate(normalizedProof.passed === true && normalizedProof.speedup_ratio >= requiredSpeedupRatio, 'parallel runtime proof did not pass Naruto gate', { required_speedup_ratio: requiredSpeedupRatio, proof: normalizedProof });
-    assertGate(normalizedProof.unique_worker_pids >= requiredActiveWorkers, 'parallel runtime proof must observe required worker processes', { required_active_workers: requiredActiveWorkers, proof: normalizedProof });
-    assertGate(normalizedProof.visible_panes <= result.target_active_slots && normalizedProof.headless_workers >= 0, 'visible/headless proof missing', normalizedProof);
-}
-function compactReusableResult(result) {
-    return {
-        backend: result.backend,
-        run: {
-            backend: result.run?.backend,
-            proof: result.run?.proof || null,
-            scheduler: {
-                state: {
-                    max_observed_active_slots: result.run?.scheduler?.state?.max_observed_active_slots || 0
-                }
-            }
-        },
-        fake_backend_disclaimer: result.fake_backend_disclaimer === true,
-        clones: result.clones,
-        target_active_slots: result.target_active_slots,
-        local_worker: {
-            backend_counts: {
-                'codex-sdk': Number(result.local_worker?.backend_counts?.['codex-sdk'] || 0)
-            }
-        },
-        concurrency_governor: {
-            safe_active_workers: Number(result.concurrency_governor?.safe_active_workers || 0)
-        },
-        parallel_runtime: normalizedParallelRuntime(result)
-    };
-}
-function normalizedParallelRuntime(result) {
-    const proof = hydrateParallelRuntimeProof(result.parallel_runtime || {});
-    const safeActiveWorkers = Number(result.concurrency_governor?.safe_active_workers || 0);
-    const requiredActiveWorkers = Math.max(1, Math.floor(Math.min(requestedWorkerCount, safeActiveWorkers || Number(result.target_active_slots || 0) || requestedWorkerCount) * deliveryTolerance));
-    const requiredObservedActiveWorkers = requiredObservedWorkers(requiredActiveWorkers);
-    const blockers = Array.isArray(proof.blockers) ? proof.blockers.map(String) : [];
-    const observedActiveWorkers = Number(proof.max_observed_active_workers || result.run?.scheduler?.state?.max_observed_active_slots || 0);
-    const observedWorkerPids = Number(proof.unique_worker_pids || 0);
-    // Delivery-shortfall blockers: the run realized fewer workers than the optimistic request target but
-    // still met the adaptive (governor-capacity x tolerance) bar. Accept these; any other blocker
-    // (fake backend, missing speedup, etc.) still fails the gate.
-    const deliveryShortfallBlockers = new Set(['max_observed_active_workers_below_target', 'unique_worker_pids_below_target']);
-    const acceptedPeakOnly = proof.passed !== true
-        && observedActiveWorkers >= requiredObservedActiveWorkers
-        && observedWorkerPids >= requiredActiveWorkers
-        && blockers.length > 0
-        && blockers.every((blocker) => deliveryShortfallBlockers.has(blocker));
-    return {
-        ...proof,
-        passed: proof.passed === true || acceptedPeakOnly,
-        original_passed: proof.passed === true,
-        accepted_blockers: acceptedPeakOnly ? blockers : [],
-        required_active_workers: requiredActiveWorkers,
-        required_observed_active_workers: requiredObservedActiveWorkers
-    };
-}
-function hydrateParallelRuntimeProof(proof) {
-    if (!proof?.proof_path)
-        return proof || {};
-    const safeRel = String(proof.proof_path || '').replace(/^\/+/, '');
-    const resolved = path.resolve(root, safeRel);
-    if (!resolved.startsWith(`${root}${path.sep}`) || !fs.existsSync(resolved))
-        return proof || {};
-    try {
-        const full = JSON.parse(fs.readFileSync(resolved, 'utf8'));
-        return { ...full, ...proof, blockers: proof.blockers || full.blockers || [] };
-    }
-    catch {
-        return proof || {};
-    }
-}
-function compactGateProof(result) {
-    const proof = normalizedParallelRuntime(result);
-    return {
-        proof_mode: proof.proof_mode || null,
-        requested_workers: proof.requested_workers || requestedWorkerCount,
-        target_active_slots: proof.target_active_slots || result.target_active_slots,
-        max_observed_active_workers: proof.max_observed_active_workers || 0,
-        max_observed_worker_processes: proof.max_observed_worker_processes || 0,
-        unique_worker_pids: proof.unique_worker_pids || 0,
-        unique_model_call_ids: proof.unique_model_call_ids || 0,
-        max_observed_model_calls: proof.max_observed_model_calls || 0,
-        speedup_ratio: proof.speedup_ratio || 0,
-        wall_ms: proof.wall_ms || 0,
-        sequential_estimate_ms: proof.sequential_estimate_ms || 0,
-        visible_panes: proof.visible_panes || 0,
-        headless_workers: proof.headless_workers || 0,
-        passed: proof.passed === true,
-        original_passed: proof.original_passed === true,
-        accepted_blockers: proof.accepted_blockers || [],
-        required_active_workers: proof.required_active_workers,
-        required_observed_active_workers: proof.required_observed_active_workers
-    };
-}
-function requiredObservedWorkers(requiredActiveWorkers) {
-    return Math.max(12, Math.min(requiredActiveWorkers, Math.floor(requiredActiveWorkers * 0.75)));
-}
-function buildProofSignature() {
-    const files = [
-        'dist/bin/sks.js',
-        'dist/scripts/naruto-real-parallelism-blackbox.js',
-        'src/core/commands/naruto-command.ts',
-        'src/core/agents/native-cli-session-swarm.ts',
-        'src/core/agents/parallel-runtime-proof.ts',
-        'release-gates.v2.json',
-        'package.json'
-    ];
-    const hash = crypto.createHash('sha256');
-    hash.update(process.version);
-    for (const rel of files) {
-        const file = path.join(root, rel);
-        hash.update(rel);
-        hash.update('\0');
-        if (fs.existsSync(file) && fs.statSync(file).isFile())
-            hash.update(fs.readFileSync(file));
-        else
-            hash.update('missing');
-        hash.update('\0');
-    }
-    return {
-        schema: 'sks.naruto-real-parallelism-proof-signature.v1',
-        signature: hash.digest('hex'),
-        files
-    };
-}
-function readReusableProof(signature) {
-    if (proofCacheTtlMs <= 0 || !fs.existsSync(proofCachePath))
-        return null;
-    try {
-        const parsed = JSON.parse(fs.readFileSync(proofCachePath, 'utf8'));
-        if (parsed?.schema !== 'sks.naruto-real-parallelism-proof-cache.v1')
-            return null;
-        if (parsed?.ok !== true || parsed?.signature?.signature !== signature.signature)
-            return null;
-        const generatedAt = Date.parse(parsed.generated_at || '');
-        if (!Number.isFinite(generatedAt) || Date.now() - generatedAt > proofCacheTtlMs)
-            return null;
-        if (!parsed.result)
-            return null;
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-function writeReusableProof(input) {
-    const payload = {
-        schema: 'sks.naruto-real-parallelism-proof-cache.v1',
-        ok: true,
-        generated_at: new Date().toISOString(),
-        ttl_ms: proofCacheTtlMs,
-        signature: input.signature,
-        result: input.result
-    };
-    fs.mkdirSync(path.dirname(proofCachePath), { recursive: true });
-    fs.writeFileSync(proofCachePath, `${JSON.stringify(payload, null, 2)}\n`);
-}
-function readMissionProof(missionId) {
-    const safeMissionId = String(missionId || '').replace(/[^A-Za-z0-9._-]/g, '');
-    assertGate(/^M-/.test(safeMissionId), 'reuse mission id must be an SKS mission id', { mission_id: missionId });
-    const missionRoot = path.join(root, '.sneakoscope', 'missions', safeMissionId);
-    const proofPath = path.join(missionRoot, 'agents', 'parallel-runtime-proof.json');
-    const schedulerPath = path.join(missionRoot, 'agents', 'agent-scheduler-state.json');
-    const swarmPath = path.join(missionRoot, 'agents', 'agent-native-cli-session-swarm.json');
-    assertGate(fs.existsSync(proofPath), 'reuse mission parallel runtime proof missing', { mission_id: safeMissionId, proof_path: path.relative(root, proofPath) });
-    assertGate(fs.existsSync(schedulerPath), 'reuse mission scheduler state missing', { mission_id: safeMissionId, scheduler_path: path.relative(root, schedulerPath) });
-    const proof = JSON.parse(fs.readFileSync(proofPath, 'utf8'));
-    const scheduler = JSON.parse(fs.readFileSync(schedulerPath, 'utf8'));
-    const swarm = fs.existsSync(swarmPath) ? JSON.parse(fs.readFileSync(swarmPath, 'utf8')) : {};
-    assertGate(scheduler.completed_count >= requestedWorkerCount && scheduler.failed_count === 0, 'reuse mission must have completed requested workers without failures', { mission_id: safeMissionId, requested_worker_count: requestedWorkerCount, scheduler });
-    assertGate(proof.unique_worker_pids >= requestedWorkerCount && proof.unique_model_call_ids >= requestedWorkerCount, 'reuse mission must prove native worker and model-call ids', { mission_id: safeMissionId, requested_worker_count: requestedWorkerCount, proof });
-    return {
-        backend: 'codex-sdk',
-        run: {
-            backend: 'codex-sdk',
-            proof: { fake_backend_disclaimer: false, reuse_mission_id: safeMissionId },
-            scheduler: {
-                state: {
-                    max_observed_active_slots: Number(scheduler.max_observed_active_slots || proof.max_observed_active_workers || 0)
-                }
-            }
-        },
-        fake_backend_disclaimer: false,
-        clones: Number(proof.requested_workers || scheduler.total_work_items || requestedWorkerCount),
-        target_active_slots: Number(proof.target_active_slots || scheduler.target_active_slots || requestedWorkerCount),
-        local_worker: {
-            backend_counts: {
-                'codex-sdk': Number(proof.unique_worker_pids || swarm.unique_worker_session_count || 0)
-            }
-        },
-        concurrency_governor: {
-            safe_active_workers: Number(proof.target_active_slots || scheduler.target_active_slots || requestedWorkerCount)
-        },
-        parallel_runtime: proof
-    };
-}
-function readOption(name) {
-    const index = process.argv.indexOf(name);
-    return index >= 0 ? process.argv[index + 1] || '' : '';
-}
-//# sourceMappingURL=naruto-real-parallelism-blackbox.js.map

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

@@ -1,29 +0,0 @@
-#!/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/parallel-runtime-real-blackbox.js

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { spawn } from 'node:child_process';
-import { runAgentScheduler } from '../core/agents/agent-scheduler.js';
-import { appendParallelRuntimeEvent, writeParallelRuntimeProof } from '../core/agents/parallel-runtime-proof.js';
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-const missionId = 'M-parallel-real-blackbox';
-const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-parallel-real-'));
-const ledgerRoot = path.join(tmp, '.sneakoscope', 'missions', missionId, 'agents');
-const workers = 20;
-const sleepMs = 4000;
-const roster = { agent_count: workers, concurrency: workers, roster: Array.from({ length: workers }, (_, i) => ({ id: `agent_${i + 1}`, persona_id: `p${i + 1}`, role: 'verifier', write_policy: 'read-only' })) };
-const partition = { slices: Array.from({ length: workers }, (_, i) => ({ id: `work-${i + 1}`, role: 'verifier', description: `sleep ${i + 1}`, write_paths: [], readonly_paths: [] })) };
-const started = Date.now();
-await runAgentScheduler({
-    root: ledgerRoot,
-    missionId,
-    rootHash: 'fixture',
-    roster,
-    partition,
-    targetActiveSlots: workers,
-    maxActiveSlots: workers,
-    launchSession: async ({ generation, slot, agent, workItem }) => {
-        const child = spawn(process.execPath, ['-e', `setTimeout(()=>process.exit(0), ${sleepMs})`], { stdio: 'ignore' });
-        await appendParallelRuntimeEvent(ledgerRoot, missionId, { event_type: 'worker_process_spawned', slot_id: slot.slot_id, generation_index: generation.generation_index, session_id: generation.session_id, pid: child.pid || null, backend: 'fixture-process', placement: 'process' });
-        await new Promise((resolve) => child.on('close', resolve));
-        await appendParallelRuntimeEvent(ledgerRoot, missionId, { event_type: 'worker_completed', slot_id: slot.slot_id, generation_index: generation.generation_index, session_id: generation.session_id, pid: child.pid || null, backend: 'fixture-process', placement: 'process' });
-        return { schema: 'sks.agent-result.v1', mission_id: missionId, agent_id: agent.id, session_id: generation.session_id, persona_id: agent.persona_id, task_slice_id: workItem.id, status: 'done', backend: 'process', summary: 'done', findings: [], proposed_changes: [], changed_files: [], lease_compliance: { ok: true, violations: [] }, artifacts: [], blockers: [], confidence: 'high', handoff_notes: '', unverified: [], writes: [], recursion_guard: { ok: true, violations: [] }, verification: { status: 'passed', checks: ['sleep'] } };
-    }
-});
-const proof = await writeParallelRuntimeProof(ledgerRoot, missionId, { requestedWorkers: workers, targetActiveSlots: workers, expectedWorkerRuntimeMs: sleepMs, minActiveWorkers: 20, minSpeedupRatio: 5, firstBatchLaunchSpanLimitMs: 2500 });
-const wall = Date.now() - started;
-assertGate(proof.unique_worker_pids >= 20, 'unique worker pids must prove 20 real processes', proof);
-assertGate(proof.max_observed_active_workers >= 20, 'max active workers must reach 20', proof);
-assertGate(proof.first_batch_launch_span_ms <= 2500, 'first batch launch span must be <= 2500ms', proof);
-assertGate(wall < 10000 && proof.wall_ms < 10000, 'wall clock must be under 10s', { wall, proof });
-assertGate(proof.sequential_estimate_ms >= 80000 && proof.speedup_ratio >= 5, 'speedup proof must be >= 5x', proof);
-assertGate(proof.overlap_windows.some((row) => row.active_workers >= 16), 'overlap window with >=16 workers missing', proof);
-assertGate(proof.passed === true, 'parallel runtime proof must pass', proof);
-emitGate('parallel:runtime-real-blackbox', { wall_ms: wall, proof });
-//# sourceMappingURL=parallel-runtime-real-blackbox.js.map

package/dist/scripts/pipeline-codex-native-doctor-mad-routing-real-blackbox.js

@@ -1,77 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { runProcess } from '../core/fsx.js';
-import { resolveCodexNativeInvocationPlan } from '../core/codex-native/codex-native-invocation-router.js';
-import { createCodexNativeRuntimeFixture, withFixtureEnv } from './codex-native-runtime-e2e-fixture.js';
-export async function runCodexNativeDoctorMadRoutingRealBlackbox() {
-    const fixture = await createCodexNativeRuntimeFixture({
-        hook: 'unknown',
-        agentType: 'unsupported',
-        appHandoff: false,
-        imagePathExposure: false,
-        mcpCandidates: false,
-        codeModeWebSearch: false
-    });
-    await withFixtureEnv(fixture, async () => {
-        const doctor = await runProcess(process.execPath, [path.join(process.cwd(), 'dist', 'bin', 'sks.js'), 'doctor', '--json'], {
-            cwd: fixture.root,
-            env: fixture.env,
-            timeoutMs: 120_000,
-            maxOutputBytes: 2 * 1024 * 1024
-        }).catch((err) => ({ code: 1, stdout: '', stderr: messageOf(err), timedOut: false }));
-        const parsed = parseDoctorJson(doctor.stdout);
-        assertGate(parsed.runtime_readiness, 'doctor JSON runtime readiness missing', { stdout_tail: doctor.stdout.slice(-1000), stderr_tail: doctor.stderr.slice(-1000) });
-        assertGate(parsed.runtime_readiness.hook_evidence_policy === 'unknown-do-not-count', 'doctor must report unknown hook evidence does not count', parsed.runtime_readiness);
-        assertGate(parsed.runtime_readiness.agent_role_strategy === 'message-role', 'doctor must report message-role fallback', parsed.runtime_readiness);
-        const madPlan = await resolveCodexNativeInvocationPlan({
-            root: fixture.root,
-            missionId: fixture.missionId,
-            route: '$MAD',
-            desiredCapability: 'hook-evidence'
-        });
-        assertGate(madPlan.selected_strategy === 'blocked', 'MAD hook evidence must block when hook state is unknown', madPlan);
-        assertGate(madPlan.blockers.includes('hook_approval_not_approved'), 'MAD hook blocker missing', madPlan);
-        const artifact = path.join(fixture.root, '.sneakoscope', 'missions', fixture.missionId, 'codex-native-invocation-plan.mad.hook-evidence.json');
-        assertGate(await fileExists(artifact), 'MAD invocation plan artifact missing', { artifact });
-    });
-    emitGate('pipeline:codex-native-doctor-mad-routing-real-blackbox');
-}
-if (import.meta.url === pathToFileURL(process.argv[1] || '').href)
-    await runCodexNativeDoctorMadRoutingRealBlackbox();
-function parseDoctorJson(stdout) {
-    const text = stdout.trim();
-    if (!text)
-        return {};
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        const start = text.indexOf('{');
-        const end = text.lastIndexOf('}');
-        return start >= 0 && end > start ? JSON.parse(text.slice(start, end + 1)) : {};
-    }
-}
-async function fileExists(file) {
-    try {
-        const stat = await fs.stat(file);
-        return stat.isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function assertGate(condition, message, detail = {}) {
-    if (condition)
-        return;
-    console.error(JSON.stringify({ ok: false, message, detail }, null, 2));
-    process.exit(1);
-}
-function emitGate(gate) {
-    console.log(JSON.stringify({ schema: 'sks.release-gate.v1', ok: true, gate }, null, 2));
-}
-function messageOf(err) {
-    return err instanceof Error ? err.message : String(err);
-}
-//# sourceMappingURL=pipeline-codex-native-doctor-mad-routing-real-blackbox.js.map

package/dist/scripts/pipeline-codex-native-e2e-blackbox.js

@@ -1,13 +0,0 @@
-#!/usr/bin/env node
-import { runCodexNativeDoctorMadRoutingRealBlackbox } from './pipeline-codex-native-doctor-mad-routing-real-blackbox.js';
-import { runCodexNativeImageRoutingRealBlackbox } from './pipeline-codex-native-image-routing-real-blackbox.js';
-import { runCodexNativeLoopRoutingRealBlackbox } from './pipeline-codex-native-loop-routing-real-blackbox.js';
-import { runCodexNativeQaRoutingRealBlackbox } from './pipeline-codex-native-qa-routing-real-blackbox.js';
-import { runCodexNativeResearchRoutingRealBlackbox } from './pipeline-codex-native-research-routing-real-blackbox.js';
-await runCodexNativeLoopRoutingRealBlackbox();
-await runCodexNativeQaRoutingRealBlackbox();
-await runCodexNativeResearchRoutingRealBlackbox();
-await runCodexNativeImageRoutingRealBlackbox();
-await runCodexNativeDoctorMadRoutingRealBlackbox();
-console.log(JSON.stringify({ schema: 'sks.release-gate.v1', ok: true, gate: 'pipeline:codex-native-e2e-blackbox' }, null, 2));
-//# sourceMappingURL=pipeline-codex-native-e2e-blackbox.js.map

package/dist/scripts/pipeline-codex-native-image-routing-real-blackbox.js

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { writeImageArtifactPathContract } from '../core/image/image-artifact-path-contract.js';
-import { createCodexNativeRuntimeFixture, withFixtureEnv } from './codex-native-runtime-e2e-fixture.js';
-export async function runCodexNativeImageRoutingRealBlackbox() {
-    const modelVisible = await imageScenario({ imagePathExposure: true, missing: false });
-    assertGate(modelVisible.images?.[0]?.codex_native_followup_strategy === 'model-visible-path', 'image path exposure should select model-visible path', modelVisible);
-    const artifactPath = await imageScenario({ imagePathExposure: false, missing: false });
-    assertGate(artifactPath.images?.[0]?.codex_native_followup_strategy === 'artifact-path', 'image path fallback should select saved artifact path', artifactPath);
-    const ambiguous = await imageScenario({ imagePathExposure: true, missing: true });
-    assertGate(Array.isArray(ambiguous.blockers) && ambiguous.blockers.length > 0, 'ambiguous/missing image reference must block', ambiguous);
-    assertGate(JSON.stringify(ambiguous).includes('Image file path missing'), 'missing image must not produce false follow-up edit hint', ambiguous);
-    emitGate('pipeline:codex-native-image-routing-real-blackbox');
-}
-async function imageScenario(input) {
-    const fixture = await createCodexNativeRuntimeFixture({
-        hook: 'approved',
-        agentType: 'supported',
-        appHandoff: true,
-        imagePathExposure: input.imagePathExposure,
-        mcpCandidates: true,
-        codeModeWebSearch: true
-    });
-    return withFixtureEnv(fixture, async () => {
-        const imagePath = path.join(fixture.root, '.sneakoscope', 'missions', fixture.missionId, input.missing ? 'missing.png' : 'image.png');
-        if (!input.missing)
-            await fs.writeFile(imagePath, Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
-        const result = await writeImageArtifactPathContract(fixture.root, {
-            missionId: fixture.missionId,
-            images: [{ id: 'fixture-image', kind: 'generated_image', filePath: imagePath }]
-        });
-        const artifact = JSON.parse(await fs.readFile(result.artifact_path, 'utf8'));
-        assertGate(artifact.codex_native_invocation_plan, 'image invocation plan missing from artifact', artifact);
-        return artifact;
-    });
-}
-if (import.meta.url === pathToFileURL(process.argv[1] || '').href)
-    await runCodexNativeImageRoutingRealBlackbox();
-function assertGate(condition, message, detail = {}) {
-    if (condition)
-        return;
-    console.error(JSON.stringify({ ok: false, message, detail }, null, 2));
-    process.exit(1);
-}
-function emitGate(gate) {
-    console.log(JSON.stringify({ schema: 'sks.release-gate.v1', ok: true, gate }, null, 2));
-}
-//# sourceMappingURL=pipeline-codex-native-image-routing-real-blackbox.js.map

package/dist/scripts/pipeline-codex-native-loop-routing-real-blackbox.js

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { planLoopsFromRequest } from '../core/loops/loop-planner.js';
-import { runLoopMakerWorkers } from '../core/loops/loop-worker-runtime.js';
-import { resolveCodexNativeInvocationPlan } from '../core/codex-native/codex-native-invocation-router.js';
-import { createCodexNativeRuntimeFixture, withFixtureEnv } from './codex-native-runtime-e2e-fixture.js';
-export async function runCodexNativeLoopRoutingRealBlackbox() {
-    const supported = await createCodexNativeRuntimeFixture({
-        hook: 'approved',
-        agentType: 'supported',
-        appHandoff: true,
-        imagePathExposure: true,
-        mcpCandidates: true,
-        codeModeWebSearch: true
-    });
-    await withFixtureEnv(supported, async () => {
-        const plan = await planLoopsFromRequest({
-            root: supported.root,
-            missionId: supported.missionId,
-            request: 'change loop runtime fixture',
-            sourceCommand: 'loop',
-            maxLoops: 1
-        });
-        const node = plan.graph.nodes.find((row) => row.route !== '$Integration');
-        assertGate(node, 'loop action node missing');
-        const result = await runLoopMakerWorkers({ root: supported.root, plan, node, fixture: true });
-        assertGate(result.codex_native_invocation_plan?.selected_strategy === 'codex-app-native', 'loop fixture did not record codex-app-native strategy', result);
-        assertGate(result.codex_native_invocation_plan?.env.SKS_CODEX_NATIVE_AGENT_ROLE_STRATEGY === 'agent_type', 'loop fixture env missing agent_type strategy', result);
-        const artifact = path.join(supported.root, '.sneakoscope', 'missions', supported.missionId, 'codex-native-invocation-plan.loop.agent-role.json');
-        assertGate(await exists(artifact), 'loop invocation plan artifact missing', { artifact });
-    });
-    const unsupported = await createCodexNativeRuntimeFixture({
-        hook: 'approved',
-        agentType: 'unsupported',
-        appHandoff: true,
-        imagePathExposure: true,
-        mcpCandidates: true,
-        codeModeWebSearch: true
-    });
-    await withFixtureEnv(unsupported, async () => {
-        const plan = await resolveCodexNativeInvocationPlan({
-            root: unsupported.root,
-            missionId: unsupported.missionId,
-            route: '$Loop',
-            desiredCapability: 'agent-role'
-        });
-        assertGate(plan.selected_strategy === 'message-role-fallback', 'unsupported agent_type must use message-role fallback', plan);
-        assertGate(plan.warnings.some((warning) => warning.includes('message-role fallback')), 'fallback warning missing', plan);
-    });
-    emitGate('pipeline:codex-native-loop-routing-real-blackbox');
-}
-if (import.meta.url === pathToFileURL(process.argv[1] || '').href)
-    await runCodexNativeLoopRoutingRealBlackbox();
-async function exists(file) {
-    try {
-        const stat = await fs.stat(file);
-        return stat.isFile();
-    }
-    catch {
-        return false;
-    }
-}
-function assertGate(condition, message, detail = {}) {
-    if (condition)
-        return;
-    console.error(JSON.stringify({ ok: false, message, detail }, null, 2));
-    process.exit(1);
-}
-function emitGate(gate) {
-    console.log(JSON.stringify({ schema: 'sks.release-gate.v1', ok: true, gate }, null, 2));
-}
-//# sourceMappingURL=pipeline-codex-native-loop-routing-real-blackbox.js.map

package/dist/scripts/pipeline-codex-native-qa-routing-real-blackbox.js

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { writeQaLoopArtifacts } from '../core/qa-loop.js';
-import { createCodexNativeRuntimeFixture, withFixtureEnv } from './codex-native-runtime-e2e-fixture.js';
-export async function runCodexNativeQaRoutingRealBlackbox() {
-    const ready = await qaScenario({ hook: 'approved', appHandoff: true });
-    assertGate(ready.visual_review === 'codex-app-native', 'QA visual review should select app handoff when ready', ready);
-    const unknownHook = await qaScenario({ hook: 'unknown', appHandoff: true });
-    assertGate(unknownHook.hook_evidence_policy === 'unknown-do-not-count', 'unknown hook evidence must not count', unknownHook);
-    assertGate(unknownHook.hook_derived_evidence_counted === false, 'unknown hook-derived evidence was counted', unknownHook);
-    const noHandoff = await qaScenario({ hook: 'approved', appHandoff: false });
-    assertGate(noHandoff.visual_review !== 'codex-app-native', 'QA must not falsely pass app handoff when unavailable', noHandoff);
-    emitGate('pipeline:codex-native-qa-routing-real-blackbox');
-}
-async function qaScenario(input) {
-    const fixture = await createCodexNativeRuntimeFixture({
-        hook: input.hook,
-        agentType: 'supported',
-        appHandoff: input.appHandoff,
-        imagePathExposure: true,
-        mcpCandidates: true,
-        codeModeWebSearch: true
-    });
-    return withFixtureEnv(fixture, async () => {
-        const dir = path.join(fixture.root, '.sneakoscope', 'missions', fixture.missionId);
-        await writeQaLoopArtifacts(dir, { id: fixture.missionId, prompt: 'QA visual fixture' }, {
-            answers: {
-                QA_SCOPE: 'ui_visual',
-                TARGET_ENVIRONMENT: 'local_fixture',
-                QA_MUTATION_POLICY: 'no_mutation'
-            }
-        });
-        const artifact = JSON.parse(await fs.readFile(path.join(dir, 'qa-loop', 'codex-native-invocation.json'), 'utf8'));
-        assertGate(artifact && typeof artifact === 'object', 'QA invocation artifact missing');
-        return artifact;
-    });
-}
-if (import.meta.url === pathToFileURL(process.argv[1] || '').href)
-    await runCodexNativeQaRoutingRealBlackbox();
-function assertGate(condition, message, detail = {}) {
-    if (condition)
-        return;
-    console.error(JSON.stringify({ ok: false, message, detail }, null, 2));
-    process.exit(1);
-}
-function emitGate(gate) {
-    console.log(JSON.stringify({ schema: 'sks.release-gate.v1', ok: true, gate }, null, 2));
-}
-//# sourceMappingURL=pipeline-codex-native-qa-routing-real-blackbox.js.map