sneakoscope 4.0.13 → 4.0.15

package/dist/scripts/parallel-runtime-real-blackbox.js

@@ -0,0 +1,44 @@
+#!/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/parallel-strict-pid-proof-check.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { appendParallelRuntimeEvent, writeParallelRuntimeProof } from '../core/agents/parallel-runtime-proof.js';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-strict-pid-'));
+const missingMission = 'M-strict-pid-missing';
+const missingLedger = path.join(root, '.sneakoscope', 'missions', missingMission, 'agents');
+await appendParallelRuntimeEvent(missingLedger, missingMission, { event_type: 'batch_dispatch_started', slot_id: null, generation_index: null, session_id: null, pid: null, backend: 'fixture', placement: 'unknown', batch_id: 'b1' });
+for (let i = 1; i <= 16; i++) {
+    await appendParallelRuntimeEvent(missingLedger, missingMission, { event_type: 'worker_launch_invoked', slot_id: `slot-${i}`, generation_index: 1, session_id: `s-${i}`, pid: null, backend: 'fixture', placement: 'process', batch_id: 'b1' });
+}
+await appendParallelRuntimeEvent(missingLedger, missingMission, { event_type: 'batch_dispatch_completed', slot_id: null, generation_index: null, session_id: null, pid: null, backend: 'fixture', placement: 'unknown', batch_id: 'b1' });
+await new Promise((resolve) => setTimeout(resolve, 20));
+for (let i = 1; i <= 16; i++) {
+    await appendParallelRuntimeEvent(missingLedger, missingMission, { event_type: 'worker_completed', slot_id: `slot-${i}`, generation_index: 1, session_id: `s-${i}`, pid: null, backend: 'fixture', placement: 'process' });
+}
+const missingProof = await writeParallelRuntimeProof(missingLedger, missingMission, {
+    proofMode: 'production',
+    requireWorkerPids: true,
+    requestedWorkers: 16,
+    targetActiveSlots: 16,
+    expectedWorkerRuntimeMs: 4000,
+    minActiveWorkers: 16,
+    minSpeedupRatio: 1
+});
+assertGate(missingProof.passed === false, 'production proof without worker PIDs must fail', missingProof);
+assertGate(missingProof.blockers.includes('unique_worker_pids_missing_in_production_proof'), 'missing PID blocker absent', missingProof);
+const presentMission = 'M-strict-pid-present';
+const presentLedger = path.join(root, '.sneakoscope', 'missions', presentMission, 'agents');
+await appendParallelRuntimeEvent(presentLedger, presentMission, { event_type: 'batch_dispatch_started', slot_id: null, generation_index: null, session_id: null, pid: null, backend: 'fixture', placement: 'unknown', batch_id: 'b2' });
+for (let i = 1; i <= 16; i++) {
+    await appendParallelRuntimeEvent(presentLedger, presentMission, { event_type: 'worker_launch_invoked', slot_id: `slot-${i}`, generation_index: 1, session_id: `s-${i}`, pid: null, backend: 'fixture', placement: 'process', batch_id: 'b2' });
+    await appendParallelRuntimeEvent(presentLedger, presentMission, { event_type: 'worker_process_spawned', slot_id: `slot-${i}`, generation_index: 1, session_id: `s-${i}`, pid: 5000 + i, backend: 'fixture', placement: 'process', batch_id: 'b2' });
+}
+await appendParallelRuntimeEvent(presentLedger, presentMission, { event_type: 'batch_dispatch_completed', slot_id: null, generation_index: null, session_id: null, pid: null, backend: 'fixture', placement: 'unknown', batch_id: 'b2' });
+await new Promise((resolve) => setTimeout(resolve, 20));
+for (let i = 1; i <= 16; i++) {
+    await appendParallelRuntimeEvent(presentLedger, presentMission, { event_type: 'worker_completed', slot_id: `slot-${i}`, generation_index: 1, session_id: `s-${i}`, pid: 5000 + i, backend: 'fixture', placement: 'process' });
+}
+const presentProof = await writeParallelRuntimeProof(presentLedger, presentMission, {
+    proofMode: 'production',
+    requireWorkerPids: true,
+    requestedWorkers: 16,
+    targetActiveSlots: 16,
+    expectedWorkerRuntimeMs: 4000,
+    minActiveWorkers: 16,
+    minSpeedupRatio: 1
+});
+assertGate(presentProof.passed === true && presentProof.unique_worker_pids === 16, 'production proof with PID evidence must pass', presentProof);
+emitGate('parallel:strict-pid-proof', { missing: missingProof.blockers, unique_worker_pids: presentProof.unique_worker_pids });
+//# sourceMappingURL=parallel-strict-pid-proof-check.js.map

package/dist/scripts/parallel-verification-engine-check.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+// @ts-nocheck
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const issues = [];
+for (const rel of [
+    'src/core/verification/verification-dag.ts',
+    'src/core/verification/verification-worker-pool.ts',
+    'src/core/verification/verification-artifact-lock.ts',
+    'src/core/verification/verification-result.ts',
+    'src/core/verification/verification-proof.ts',
+    'src/scripts/release-parallel-check.ts'
+]) {
+    if (!fs.existsSync(path.join(root, rel)))
+        issues.push(`missing:${rel}`);
+}
+await runFixture();
+const releaseSource = read('src/scripts/release-parallel-check.ts');
+for (const token of ['runVerificationDag', 'buildVerificationDag', 'writeParallelVerificationProof']) {
+    if (!releaseSource.includes(token))
+        issues.push(`release_parallel_runner_missing:${token}`);
+}
+const result = { schema: 'sks.parallel-verification-engine-check.v1', ok: issues.length === 0, issues };
+console.log(JSON.stringify(result, null, 2));
+if (!result.ok)
+    process.exitCode = 1;
+async function runFixture() {
+    const dagPath = path.join(root, 'dist', 'core', 'verification', 'verification-dag.js');
+    const poolPath = path.join(root, 'dist', 'core', 'verification', 'verification-worker-pool.js');
+    if (!fs.existsSync(dagPath) || !fs.existsSync(poolPath))
+        return;
+    const dagMod = await import(pathToFileURL(dagPath).href);
+    const poolMod = await import(pathToFileURL(poolPath).href);
+    const dag = dagMod.buildVerificationDag([
+        { id: 'a', command: `${process.execPath} -e "process.exit(0)"`, outputs: ['a.json'] },
+        { id: 'b', command: `${process.execPath} -e "process.exit(0)"`, dependencies: ['a'], outputs: ['b.json'] }
+    ]);
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-verify-'));
+    const result = await poolMod.runVerificationDag(dag, { cwd: root, concurrency: 2, logDir: tmp });
+    if (!result.ok || result.task_count !== 2)
+        issues.push('fixture_parallel_verification_failed');
+    const failedDag = dagMod.buildVerificationDag([
+        { id: 'fail', command: `${process.execPath} -e "process.exit(3)"`, outputs: ['fail.json'] },
+        { id: 'after', command: `${process.execPath} -e "process.exit(0)"`, dependencies: ['fail'], outputs: ['after.json'] }
+    ]);
+    const failed = await poolMod.runVerificationDag(failedDag, { cwd: root, concurrency: 2, logDir: tmp });
+    const after = failed.results.find((row) => row.id === 'after');
+    if (!after?.skipped || failed.skipped !== 1 || failed.failed !== 1 || failed.task_count !== 2)
+        issues.push('fixture_failed_dependency_not_skipped');
+    const timeoutDag = dagMod.buildVerificationDag([
+        { id: 'slow', command: `${process.execPath} -e "process.on('SIGTERM',()=>setTimeout(()=>process.exit(0),200)); setInterval(()=>{},50)"`, timeout_ms: 20, outputs: ['slow.json'] }
+    ]);
+    const timeoutResult = await poolMod.runVerificationDag(timeoutDag, { cwd: root, concurrency: 1, logDir: tmp });
+    const slow = timeoutResult.results.find((row) => row.id === 'slow');
+    if (!slow?.error?.startsWith('timeout:') || slow.duration_ms < 20)
+        issues.push('fixture_timeout_process_tree_not_reported');
+    try {
+        dagMod.buildVerificationDag([
+            { id: 'x', command: 'true', outputs: ['same'] },
+            { id: 'y', command: 'true', outputs: ['same'] }
+        ]);
+        issues.push('fixture_output_conflict_not_blocked');
+    }
+    catch { }
+    try {
+        dagMod.buildVerificationDag([
+            { id: 'x', command: 'true', outputs: ['reports/x.json'] },
+            { id: 'y', command: 'true', outputs: ['reports/../reports/x.json'] }
+        ]);
+        issues.push('fixture_normalized_output_conflict_not_blocked');
+    }
+    catch { }
+}
+function read(rel) {
+    try {
+        return fs.readFileSync(path.join(root, rel), 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+//# sourceMappingURL=parallel-verification-engine-check.js.map

package/dist/scripts/pipeline-codex-0140-integration-check.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { assertGate, emitGate, exists, readText } from './sks-1-18-gate-lib.js';
+const surfaces = [
+    'src/core/codex-control/codex-0140-capability.ts',
+    'src/core/codex-control/codex-0140-feature-probes.ts',
+    'src/core/codex-control/codex-0140-real-probes.ts',
+    'src/scripts/codex-0140-goal-attachment-preservation-check.ts',
+    'src/core/loops/loop-concurrency-budget.ts',
+    'src/core/naruto/naruto-loop-mesh.ts',
+    'src/core/doctor/context7-mcp-repair.ts',
+    'src/core/doctor/supabase-mcp-repair.ts'
+];
+for (const file of surfaces)
+    assertGate(exists(file), `Codex 0.140 integration surface missing: ${file}`);
+const cap = readText('src/core/codex-control/codex-0140-capability.ts');
+const probes = readText('src/core/codex-control/codex-0140-real-probes.ts');
+const budget = readText('src/core/loops/loop-concurrency-budget.ts');
+const mesh = readText('src/core/naruto/naruto-loop-mesh.ts');
+const broker = readText('src/core/codex-native/codex-native-feature-broker.ts');
+for (const token of ['usage_views', 'goal_attachment_preservation', 'session_delete', 'import_command', 'unified_mentions', 'bedrock_managed_auth', 'mcp_reliability', 'sqlite_auto_recovery', 'non_tty_interrupt', 'large_repo_responsiveness']) {
+    assertGate(cap.includes(token), `Codex 0.140 capability must expose ${token}`);
+    assertGate(broker.includes(token), `Codex native feature broker must surface ${token}`);
+}
+for (const token of ['feature_states', 'feature_certainty', 'actual_pass_count', 'discovered_count', 'skipped_count']) {
+    assertGate(cap.includes(token) || probes.includes(token), `Codex 0.140 integration must preserve probe certainty field: ${token}`);
+}
+assertGate(budget.includes('codex_usage_signal') && budget.includes('usage_budget_source'), 'Loop budget must carry Codex 0.140 usage signal provenance');
+assertGate(mesh.includes('usage_budget_source') && mesh.includes('codex_usage_signal'), 'Naruto loop routes must expose usage budget provenance');
+emitGate('pipeline:codex-0140-integration', { surfaces: surfaces.length });
+//# sourceMappingURL=pipeline-codex-0140-integration-check.js.map

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

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCodexNativeDoctorMadRoutingRealBlackbox } from './pipeline-codex-native-doctor-mad-routing-real-blackbox.js';
+await runCodexNativeDoctorMadRoutingRealBlackbox();
+//# sourceMappingURL=pipeline-codex-native-doctor-mad-routing-check.js.map

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

@@ -0,0 +1,77 @@
+#!/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

@@ -0,0 +1,13 @@
+#!/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-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCodexNativeImageRoutingRealBlackbox } from './pipeline-codex-native-image-routing-real-blackbox.js';
+await runCodexNativeImageRoutingRealBlackbox();
+//# sourceMappingURL=pipeline-codex-native-image-routing-check.js.map

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

@@ -0,0 +1,50 @@
+#!/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-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCodexNativeLoopRoutingRealBlackbox } from './pipeline-codex-native-loop-routing-real-blackbox.js';
+await runCodexNativeLoopRoutingRealBlackbox();
+//# sourceMappingURL=pipeline-codex-native-loop-routing-check.js.map

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

@@ -0,0 +1,74 @@
+#!/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-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCodexNativeQaRoutingRealBlackbox } from './pipeline-codex-native-qa-routing-real-blackbox.js';
+await runCodexNativeQaRoutingRealBlackbox();
+//# sourceMappingURL=pipeline-codex-native-qa-routing-check.js.map

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

@@ -0,0 +1,51 @@
+#!/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

package/dist/scripts/pipeline-codex-native-research-routing-check.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCodexNativeResearchRoutingRealBlackbox } from './pipeline-codex-native-research-routing-real-blackbox.js';
+await runCodexNativeResearchRoutingRealBlackbox();
+//# sourceMappingURL=pipeline-codex-native-research-routing-check.js.map

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

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { writeResearchPlan } from '../core/research.js';
+import { createCodexNativeRuntimeFixture, withFixtureEnv } from './codex-native-runtime-e2e-fixture.js';
+export async function runCodexNativeResearchRoutingRealBlackbox() {
+    const mcp = await researchScenario({ mcpCandidates: true, codeModeWebSearch: true });
+    assertGate(mcp.selected_source_strategy === 'mcp-plugin-candidates', 'research should prefer MCP plugin candidates', mcp);
+    const web = await researchScenario({ mcpCandidates: false, codeModeWebSearch: true });
+    assertGate(web.selected_source_strategy === 'web-sources', 'research should fall back to web sources when MCP candidates are absent', web);
+    const local = await researchScenario({ mcpCandidates: false, codeModeWebSearch: false });
+    assertGate(local.selected_source_strategy === 'local-files', 'research should fall back to local files when MCP/web are absent', local);
+    assertGate(local.hook_derived_source_evidence_allowed === false, 'research must exclude hook-derived evidence unless explicitly approved', local);
+    emitGate('pipeline:codex-native-research-routing-real-blackbox');
+}
+async function researchScenario(input) {
+    const fixture = await createCodexNativeRuntimeFixture({
+        hook: 'approved',
+        agentType: 'supported',
+        appHandoff: true,
+        imagePathExposure: true,
+        mcpCandidates: input.mcpCandidates,
+        codeModeWebSearch: input.codeModeWebSearch
+    });
+    return withFixtureEnv(fixture, async () => {
+        const dir = path.join(fixture.root, '.sneakoscope', 'missions', fixture.missionId);
+        await writeResearchPlan(dir, 'research source routing fixture', { root: fixture.root, missionId: fixture.missionId });
+        const artifact = JSON.parse(await fs.readFile(path.join(dir, 'research', 'codex-native-invocation.json'), 'utf8'));
+        assertGate(Array.isArray(artifact.mcp_source?.required_artifacts), 'research source candidate artifact details missing', artifact);
+        return artifact;
+    });
+}
+if (import.meta.url === pathToFileURL(process.argv[1] || '').href)
+    await runCodexNativeResearchRoutingRealBlackbox();
+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-research-routing-real-blackbox.js.map

package/dist/scripts/pipeline-execution-profile-routing-blackbox.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runDirective315Gate } from './sks-3-1-5-directive-check-lib.js';
+await runDirective315Gate('pipeline:execution-profile-routing-blackbox');
+//# sourceMappingURL=pipeline-execution-profile-routing-blackbox.js.map

package/dist/scripts/pipeline-five-minute-sla-check.js

@@ -0,0 +1,7 @@
+// @ts-nocheck
+import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
+const mod = await importDist('core/release/sla-scheduler.js');
+const plan = mod.planFiveMinuteSla(root);
+assertGate(plan.schema === 'sks.sla-scheduler.v1' && plan.certificate.sla_ms === 300000, 'five-minute SLA plan malformed', plan);
+emitGate('pipeline:five-minute-sla', { ok: plan.ok, gates: plan.graph.gates.length, blockers: plan.certificate.blockers });
+//# sourceMappingURL=pipeline-five-minute-sla-check.js.map