sneakoscope 6.2.0 → 6.4.0

package/dist/scripts/lib/native-cli-session-swarm-check-lib.js

@@ -1,242 +0,0 @@
-// @ts-nocheck
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { execFileSync } from 'node:child_process';
-import { assertGate, root } from '../sks-1-18-gate-lib.js';
-const MAX_EMPTY_OUTPUT_ATTEMPTS = 2;
-const CLI_COMPLETION_TIMEOUT_MS = 180_000;
-const CLI_STABILITY_WAIT_MS = 500;
-const CLI_STABILITY_SAMPLE_MS = 25;
-const stabilityWaitCell = new Int32Array(new SharedArrayBuffer(4));
-export function runNativeCliSwarmCheck({ agents, workItems = agents, reportName, backend = 'fake', extraArgs = [], expectedFastMode = null }) {
-    const distCli = path.join(root, 'dist', 'bin', 'sks.js');
-    assertGate(fs.existsSync(distCli), 'dist CLI missing for native CLI swarm check', { distCli });
-    const args = [
-        distCli,
-        'agent',
-        'run',
-        `native cli session swarm ${agents}`,
-        '--backend',
-        backend,
-        '--mock',
-        '--agents',
-        String(agents),
-        '--concurrency',
-        String(agents),
-        '--work-items',
-        String(workItems),
-        '--minimum-work-items',
-        String(agents),
-        '--json',
-        ...extraArgs
-    ];
-    const attempts = [];
-    let inspected = null;
-    while (attempts.length < MAX_EMPTY_OUTPUT_ATTEMPTS) {
-        const attempt = runCliAttempt({ distCli, args, backend, attemptNumber: attempts.length + 1 });
-        attempts.push(attempt);
-        inspected = inspectNativeCliSwarmOutput(attempt.stdout);
-        if (inspected.ok || inspected.reason !== 'empty_stdout')
-            break;
-        if (attempts.length >= MAX_EMPTY_OUTPUT_ATTEMPTS)
-            break;
-        const stable = waitForStableNonemptyCli(distCli);
-        assertGate(stable.ok, 'native CLI session swarm emitted empty JSON and the CLI did not settle for a bounded retry', {
-            dist_cli: distCli,
-            attempt_count: attempts.length,
-            completion_timeout_ms: CLI_COMPLETION_TIMEOUT_MS,
-            stability_wait_ms: CLI_STABILITY_WAIT_MS,
-            before: attempt.cli_before,
-            after: attempt.cli_after,
-            stable
-        });
-    }
-    assertGate(inspected?.ok === true, inspected?.reason === 'empty_stdout'
-        ? 'native CLI session swarm completed without JSON output after one bounded retry'
-        : 'native CLI session swarm emitted incomplete or invalid JSON', {
-        dist_cli: distCli,
-        attempt_count: attempts.length,
-        completion_timeout_ms: CLI_COMPLETION_TIMEOUT_MS,
-        attempts: attempts.map(attemptDiagnostic),
-        output: inspected
-    });
-    const result = inspected.value;
-    const proof = result.native_cli_session_proof || {};
-    const noSubagent = result.no_subagent_scaling_policy || {};
-    const officialHelper = result.official_subagent_helper_policy || {};
-    const fast = result.fast_mode_propagation || {};
-    const policy = fast.policy || result.fast_mode_policy || {};
-    const expectedFast = expectedFastMode === null || expectedFastMode === undefined ? Boolean(policy.fast_mode) : Boolean(expectedFastMode);
-    const expectedTier = expectedFast ? 'fast' : 'standard';
-    const report = {
-        schema: 'sks.native-cli-session-swarm-check.v1',
-        ok: result.ok === true,
-        agents,
-        work_items: workItems,
-        mission_id: result.mission_id,
-        backend: result.backend,
-        native_cli_session_proof: proof,
-        no_subagent_scaling_policy: noSubagent,
-        official_subagent_helper_policy: officialHelper,
-        fast_mode_propagation: fast,
-        proof_status: result.proof?.status || null,
-        completion_protocol: {
-            schema: 'sks.native-cli-check-completion.v1',
-            attempt_count: attempts.length,
-            max_attempts: MAX_EMPTY_OUTPUT_ATTEMPTS,
-            bounded_timeout_ms: CLI_COMPLETION_TIMEOUT_MS,
-            atomic_output_read: true,
-            transient_empty_output_recovered: attempts.length > 1,
-            output_bytes: attempts.at(-1)?.output_bytes || 0
-        }
-    };
-    const out = path.join(root, '.sneakoscope', 'reports', reportName);
-    fs.mkdirSync(path.dirname(out), { recursive: true });
-    fs.writeFileSync(out, `${JSON.stringify(report, null, 2)}\n`);
-    assertGate(result.ok === true, 'native CLI session swarm run must pass', report);
-    assertGate(proof.spawned_worker_process_count >= agents, 'spawned native worker process count below requested agents', report);
-    assertGate(proof.unique_worker_session_count >= agents, 'unique worker session count below requested agents', report);
-    const expectedSlots = Math.min(agents, Number(proof.target_active_slots || agents));
-    assertGate(proof.unique_slot_count >= expectedSlots, 'unique slot count below effective concurrency target', report);
-    assertGate(Array.isArray(proof.process_ids) && proof.process_ids.length >= agents, 'process ids missing from native CLI proof', report);
-    assertGate(proof.close_report_count >= agents, 'worker close report count below requested agents', report);
-    assertGate(noSubagent.ok === true && noSubagent.subagent_events_counted_as_worker_sessions === false, 'no-subagent scaling policy must pass', report);
-    assertGate(officialHelper.ok === true && officialHelper.official_codex_subagent_helper_lane_enabled === true, 'official subagent helper policy must pass', report);
-    assertGate(officialHelper.worker_capacity_credit === 0 && officialHelper.subagent_events_counted_as_worker_sessions === false, 'official helper lane must not count toward worker capacity', report);
-    assertGate(noSubagent.official_codex_subagent_helper_lane_allowed === true && noSubagent.official_helper_lane_worker_capacity_credit === 0, 'no-subagent policy must allow helper lane with zero capacity credit', report);
-    assertGate(fast.ok === true, 'fast mode propagation proof must pass', report);
-    assertGate(fast.fast_mode === expectedFast && fast.service_tier === expectedTier, 'worker service tier must match the selected fast-mode policy', { ...report, expected_fast_mode: expectedFast, expected_service_tier: expectedTier });
-    if (expectedFast && expectedFastMode === true) {
-        assertGate(policy.explicit_fast === true || policy.preference_mode === 'fast' || policy.explicit_service_tier === 'fast', 'fast-mode propagation gate must use explicit fast opt-in', report);
-    }
-    assertGate((proof.worker_command_lines || []).every((line) => line.includes('--agent') && line.includes('worker')), 'worker command lines must use --agent worker', report);
-    return report;
-}
-export function inspectNativeCliSwarmOutput(stdout) {
-    const text = typeof stdout === 'string' ? stdout : String(stdout || '');
-    if (text.trim().length === 0)
-        return { ok: false, reason: 'empty_stdout', output_bytes: Buffer.byteLength(text) };
-    try {
-        const value = JSON.parse(text);
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            return { ok: false, reason: 'non_object_json', output_bytes: Buffer.byteLength(text) };
-        }
-        return { ok: true, value, output_bytes: Buffer.byteLength(text) };
-    }
-    catch (error) {
-        return {
-            ok: false,
-            reason: 'invalid_json',
-            output_bytes: Buffer.byteLength(text),
-            parse_error: error instanceof Error ? error.message : String(error),
-            output_sha256: crypto.createHash('sha256').update(text).digest('hex')
-        };
-    }
-}
-function runCliAttempt({ distCli, args, backend, attemptNumber }) {
-    const fixtureRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-native-cli-swarm-fixture-'));
-    const fixtureHome = path.join(fixtureRoot, 'home');
-    const outputDraft = path.join(fixtureRoot, `.native-cli-result-${attemptNumber}.json.partial`);
-    const outputComplete = path.join(fixtureRoot, `.native-cli-result-${attemptNumber}.json`);
-    let outputFd = fs.openSync(outputDraft, 'wx', 0o600);
-    const cleanupFixture = () => fs.rmSync(fixtureRoot, { recursive: true, force: true });
-    process.once('exit', cleanupFixture);
-    const cliBefore = cliSnapshot(distCli);
-    try {
-        execFileSync(process.execPath, args, {
-            cwd: fixtureRoot,
-            env: {
-                ...process.env,
-                HOME: fixtureHome,
-                CODEX_HOME: path.join(fixtureHome, '.codex'),
-                SKS_GLOBAL_ROOT: path.join(fixtureHome, '.sneakoscope-global'),
-                TMPDIR: fixtureRoot,
-                TMP: fixtureRoot,
-                TEMP: fixtureRoot,
-                PWD: fixtureRoot,
-                SKS_TEST_ISOLATION: '1',
-                SKS_UPDATE_MIGRATION_GATE_DISABLED: '1',
-                NODE_ENV: 'test',
-                CI: 'true',
-                ...(backend === 'codex-sdk' ? { SKS_CODEX_SDK_FAKE: '1' } : {})
-            },
-            timeout: CLI_COMPLETION_TIMEOUT_MS,
-            killSignal: 'SIGTERM',
-            stdio: ['ignore', outputFd, 'pipe'],
-            maxBuffer: 96 * 1024 * 1024
-        });
-        fs.fsyncSync(outputFd);
-        fs.closeSync(outputFd);
-        outputFd = null;
-        fs.renameSync(outputDraft, outputComplete);
-        const stdout = fs.readFileSync(outputComplete, 'utf8');
-        const cliAfter = cliSnapshot(distCli);
-        return {
-            attempt: attemptNumber,
-            stdout,
-            output_bytes: Buffer.byteLength(stdout),
-            cli_before: cliBefore,
-            cli_after: cliAfter
-        };
-    }
-    finally {
-        if (outputFd !== null) {
-            try {
-                fs.closeSync(outputFd);
-            }
-            catch { }
-        }
-        process.removeListener('exit', cleanupFixture);
-        cleanupFixture();
-    }
-}
-function waitForStableNonemptyCli(distCli) {
-    const startedAt = Date.now();
-    let previous = cliSnapshot(distCli);
-    while (Date.now() - startedAt < CLI_STABILITY_WAIT_MS) {
-        Atomics.wait(stabilityWaitCell, 0, 0, CLI_STABILITY_SAMPLE_MS);
-        const current = cliSnapshot(distCli);
-        if (current.ok && current.size > 0 && sameCliSnapshot(previous, current)) {
-            return { ok: true, waited_ms: Date.now() - startedAt, snapshot: current };
-        }
-        previous = current;
-    }
-    return { ok: false, waited_ms: Date.now() - startedAt, snapshot: previous };
-}
-function cliSnapshot(file) {
-    try {
-        const stat = fs.statSync(file);
-        const bytes = fs.readFileSync(file);
-        return {
-            ok: stat.isFile(),
-            size: stat.size,
-            mtime_ms: stat.mtimeMs,
-            dev: String(stat.dev),
-            ino: String(stat.ino),
-            sha256: crypto.createHash('sha256').update(bytes).digest('hex')
-        };
-    }
-    catch (error) {
-        return { ok: false, size: 0, error: error instanceof Error ? error.message : String(error) };
-    }
-}
-function sameCliSnapshot(left, right) {
-    return left?.ok === true
-        && right?.ok === true
-        && left.size === right.size
-        && left.mtime_ms === right.mtime_ms
-        && left.dev === right.dev
-        && left.ino === right.ino
-        && left.sha256 === right.sha256;
-}
-function attemptDiagnostic(attempt) {
-    return {
-        attempt: attempt.attempt,
-        output_bytes: attempt.output_bytes,
-        cli_before: attempt.cli_before,
-        cli_after: attempt.cli_after
-    };
-}
-//# sourceMappingURL=native-cli-session-swarm-check-lib.js.map

package/dist/scripts/lib/real-codex-parallel-gate.js

@@ -1,94 +0,0 @@
-// @ts-nocheck
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { tmpdir } from '../../core/fsx.js';
-import { emitGate, importDist, root } from '../sks-1-18-gate-lib.js';
-export async function runRealCodexParallelGate({ workers, gate }) {
-    const reportPath = path.join(root, '.sneakoscope', 'reports', `${gate.replace(/[:]/g, '-')}.json`);
-    fs.mkdirSync(path.dirname(reportPath), { recursive: true });
-    const required = process.env.SKS_REQUIRE_REAL_CODEX_PARALLEL === '1';
-    if (process.env.SKS_TEST_REAL_CODEX_PARALLEL !== '1') {
-        const report = {
-            schema: 'sks.real-codex-parallel-gate.v1',
-            ok: !required,
-            status: required ? 'blocked' : 'integration_optional',
-            proof_level: required ? 'real_required_missing' : 'integration_optional',
-            requested_workers: workers,
-            required,
-            blockers: required ? ['real_codex_parallel_not_requested'] : []
-        };
-        fs.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
-        emitGate(gate, { status: report.status, requested_workers: workers });
-        process.exit(required ? 1 : 0);
-    }
-    const fixture = tmpdir('sks-real-codex-parallel-');
-    const targetFiles = Array.from({ length: workers }, (_, index) => `target-${String(index + 1).padStart(3, '0')}.txt`);
-    for (const file of targetFiles)
-        fs.writeFileSync(path.join(fixture, file), `before ${file}\n`);
-    const prompt = [
-        'Real Codex parallel worker proof.',
-        `Each worker has an independent write target: ${targetFiles.map((file) => `\`${file}\``).join(', ')}.`,
-        'Return valid SKS agent result JSON.',
-        'For write-capable slices, emit model_authored patch_envelopes with lease proof, verification hints, and rollback hints.'
-    ].join(' ');
-    const run = spawnSync(process.execPath, [
-        path.join(root, 'dist', 'bin', 'sks.js'),
-        'agent',
-        'run',
-        prompt,
-        '--backend',
-        'codex-sdk',
-        '--real',
-        '--agents',
-        String(workers),
-        '--target-active-slots',
-        String(workers),
-        '--minimum-work-items',
-        String(workers),
-        '--work-items',
-        String(workers),
-        '--write-mode',
-        'parallel',
-        '--json'
-    ], {
-        cwd: fixture,
-        encoding: 'utf8',
-        env: { ...process.env, SKS_SKIP_NPM_FRESHNESS_CHECK: '1', SKS_TEST_REAL_CODEX_PARALLEL: '1' },
-        timeout: Number(process.env.SKS_REAL_CODEX_PARALLEL_TIMEOUT_MS || 15 * 60 * 1000),
-        maxBuffer: 1024 * 1024 * 32
-    });
-    if (run.status !== 0) {
-        const report = {
-            schema: 'sks.real-codex-parallel-gate.v1',
-            ok: false,
-            status: 'blocked',
-            proof_level: 'blocked',
-            requested_workers: workers,
-            required,
-            fixture_root: fixture,
-            blockers: [`real_codex_parallel_command_exit_${run.status}`],
-            stdout_tail: run.stdout.slice(-4000),
-            stderr_tail: run.stderr.slice(-4000)
-        };
-        fs.writeFileSync(reportPath, `${JSON.stringify(report, null, 2)}\n`);
-        console.error(JSON.stringify(report, null, 2));
-        process.exit(1);
-    }
-    const json = parseJson(run.stdout);
-    const ledgerRoot = path.join(fixture, json.ledger_root || '');
-    const mod = await importDist('core/agents/real-codex-parallel-proof.js');
-    const proof = await mod.writeRealCodexParallelProof(ledgerRoot, { requestedWorkers: workers, required: true });
-    fs.writeFileSync(reportPath, `${JSON.stringify(proof, null, 2)}\n`);
-    if (!proof.ok) {
-        console.error(JSON.stringify({ ok: false, proof }, null, 2));
-        process.exit(1);
-    }
-    emitGate(gate, { status: proof.status, requested_workers: workers, overlap: proof.max_observed_codex_child_process_overlap });
-}
-function parseJson(stdout) {
-    const start = stdout.indexOf('{');
-    const end = stdout.lastIndexOf('}');
-    return JSON.parse(stdout.slice(start, end + 1));
-}
-//# sourceMappingURL=real-codex-parallel-gate.js.map

package/dist/scripts/lib/real-codex-parallel-proof-fixture.js

@@ -1,55 +0,0 @@
-// @ts-nocheck
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { importDist } from '../sks-1-18-gate-lib.js';
-export async function buildFixtureProof({ workers, required }) {
-    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-real-codex-proof-'));
-    const dirs = [];
-    const base = Date.now();
-    for (let index = 0; index < workers; index += 1) {
-        const dir = path.join('sessions', `slot-${String(index + 1).padStart(3, '0')}`, 'gen-1', 'worker');
-        dirs.push(dir);
-        await fs.mkdir(path.join(root, dir), { recursive: true });
-        await fs.writeFile(path.join(root, dir, 'worker-backend-router-report.json'), JSON.stringify({
-            schema: 'sks.native-worker-backend-router.v1',
-            ok: true,
-            selected_backend: 'codex-sdk',
-            worker_process_id: 3000 + index,
-            child_process_ids: [],
-            sdk_thread_id: `sdk-thread-${index}`,
-            stream_event_count: 4,
-            structured_output_valid: true,
-            patch_envelope_count: 1,
-            model_authored_patch_envelopes: true,
-            fixture_patch_envelopes: false,
-            proof_level: 'model_authored',
-            fast_mode: true,
-            service_tier: 'fast',
-            blockers: []
-        }, null, 2));
-        await fs.writeFile(path.join(root, dir, 'codex-control-proof.json'), JSON.stringify({
-            schema: 'sks.codex-control-proof.v1',
-            ok: true,
-            backend: 'codex-sdk',
-            sdk_thread_id: `sdk-thread-${index}`,
-            sdk_run_id: `sdk-run-${index}`,
-            stream_event_count: 4,
-            structured_output_valid: true,
-            output_schema_id: 'sks.agent-worker-result.v1',
-            fast_mode: true,
-            service_tier: 'fast'
-        }, null, 2));
-        await fs.writeFile(path.join(root, dir, 'codex-worker-output-truth.json'), JSON.stringify({ ok: true, patch_envelope_count: 1 }, null, 2));
-    }
-    await fs.writeFile(path.join(root, 'agent-native-cli-session-swarm.json'), JSON.stringify({
-        schema: 'sks.agent-native-cli-session-swarm.v1',
-        requested_agents: workers,
-        target_active_slots: workers,
-        process_ids: dirs.map((_, index) => 3000 + index),
-        worker_artifact_dirs: dirs
-    }, null, 2));
-    const mod = await importDist('core/agents/real-codex-parallel-proof.js');
-    return mod.writeRealCodexParallelProof(root, { requestedWorkers: workers, required });
-}
-//# sourceMappingURL=real-codex-parallel-proof-fixture.js.map

package/dist/scripts/local-collab-gpt-final-availability-check.js

@@ -1,58 +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 { assertGate, emitGate, importDist, root } from './lib/codex-sdk-gate-lib.js';
-const arbiterMod = await importDist('core/codex-control/gpt-final-arbiter.js');
-const doctorMod = await importDist('core/doctor/doctor-readiness-matrix.js');
-const old = snapshotEnv();
-try {
-    process.env.SKS_GPT_FINAL_ARBITER_UNAVAILABLE = '1';
-    const unavailable = await arbiterMod.runGptFinalArbiter(input('unavailable'), { writeArtifact: false, forceUnavailable: true });
-    assertGate(unavailable.ok === false, 'GPT unavailable fixture must block final apply');
-    assertGate(unavailable.blockers.includes('gpt_final_arbiter_unavailable'), 'GPT unavailable blocker must be present');
-    const doctor = doctorMod.buildDoctorReadinessMatrix({
-        codex: { available: false },
-        codex_config: { ok: true, checks: [] },
-        local_collaboration: { mode: 'local-parallel-gpt-final', gpt_final_arbiter_available: false }
-    });
-    assertGate(doctor.blockers.includes('gpt_final_arbiter_unavailable'), 'doctor must report gpt_final_arbiter_unavailable');
-    delete process.env.SKS_GPT_FINAL_ARBITER_UNAVAILABLE;
-    process.env.NODE_ENV = 'test';
-    process.env.SKS_CODEX_SDK_FAKE = '1';
-    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-gpt-final-available-'));
-    const available = await arbiterMod.runGptFinalArbiter(input('available'), { cwd: root, mutationLedgerRoot: tmp });
-    assertGate(available.ok === true, 'GPT available fixture must pass final arbiter');
-    emitGate('local-collab:gpt-final-availability', { unavailable: unavailable.result.status, available: available.result.status });
-}
-finally {
-    restoreEnv(old);
-}
-function input(label) {
-    return {
-        schema: 'sks.gpt-final-arbiter-input.v1',
-        route: '$Team',
-        mission_id: `M-${label}`,
-        local_mode: 'local-parallel-gpt-final',
-        local_outputs: [{ worker_id: 'local', backend: 'local-llm', summary: 'candidate' }],
-        candidate_patch_envelopes: [],
-        verification_results: []
-    };
-}
-function snapshotEnv() {
-    return {
-        NODE_ENV: process.env.NODE_ENV,
-        SKS_CODEX_SDK_FAKE: process.env.SKS_CODEX_SDK_FAKE,
-        SKS_GPT_FINAL_ARBITER_UNAVAILABLE: process.env.SKS_GPT_FINAL_ARBITER_UNAVAILABLE
-    };
-}
-function restoreEnv(old) {
-    for (const [key, value] of Object.entries(old)) {
-        if (value === undefined)
-            delete process.env[key];
-        else
-            process.env[key] = value;
-    }
-}
-//# sourceMappingURL=local-collab-gpt-final-availability-check.js.map

package/dist/scripts/local-collab-no-local-only-final-check.js

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
-const policyMod = await importDist('core/local-llm/local-collaboration-policy.js');
-const arbiterMod = await importDist('core/codex-control/gpt-final-arbiter.js');
-const gate = policyMod.evaluateLocalCollaborationFinalGate({
-    mode: 'local-only-draft',
-    localParticipated: true,
-    gptFinalStatus: null,
-    gptFinalAvailable: false,
-    applyPatches: true
-});
-assertGate(gate.ok === false, 'local-only-draft must not be final accepted');
-assertGate(gate.final_status === 'draft_only', 'local-only-draft must end as draft_only');
-assertGate(gate.apply_allowed === false, 'local-only-draft must block apply');
-const result = await arbiterMod.runGptFinalArbiter({
-    schema: 'sks.gpt-final-arbiter-input.v1',
-    route: '$DFix',
-    mission_id: 'M-local-only-draft',
-    local_mode: 'local-only-draft',
-    local_outputs: [{ worker_id: 'local', backend: 'local-llm', summary: 'draft only' }],
-    candidate_patch_envelopes: []
-}, { writeArtifact: false });
-assertGate(result.ok === false, 'local-only-draft arbiter result must not pass');
-assertGate(result.blockers.includes('needs_gpt_final_review'), 'local-only-draft arbiter must include needs_gpt_final_review');
-emitGate('local-collab:no-local-only-final', { final_status: gate.final_status, blockers: result.blockers.length });
-//# sourceMappingURL=local-collab-no-local-only-final-check.js.map

package/dist/scripts/local-collab-policy-check.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist, readText } from './lib/codex-sdk-gate-lib.js';
-const policyMod = await importDist('core/local-llm/local-collaboration-policy.js');
-const schemaText = readText('schemas/local-llm/local-collaboration-policy.schema.json');
-const policy = policyMod.resolveLocalCollaborationPolicy({ env: {} });
-assertGate(policy.mode === 'local-parallel-gpt-final', 'default local collaboration mode must be local-parallel-gpt-final');
-assertGate(policy.gpt_final_required === true, 'default local collaboration mode must require GPT final');
-assertGate(policy.final_patch_source_when_enabled === 'gpt_final_arbiter', 'final patch source must be GPT final arbiter');
-assertGate(schemaText.includes('local-only-draft'), 'policy schema must include local-only-draft mode');
-const draft = policyMod.resolveLocalCollaborationPolicy({ mode: 'local-only-draft' });
-const draftGate = policyMod.evaluateLocalCollaborationFinalGate({ policy: draft, localParticipated: true, applyPatches: true });
-assertGate(draftGate.ok === false, 'local-only-draft must not pass final gate');
-assertGate(draftGate.blockers.includes('needs_gpt_final_review'), 'local-only-draft must carry needs_gpt_final_review');
-assertGate(draftGate.blockers.includes('local_only_draft_apply_blocked'), 'local-only-draft must block apply');
-emitGate('local-collab:policy', { default_mode: policy.mode, draft_blockers: draftGate.blockers.length });
-//# sourceMappingURL=local-collab-policy-check.js.map

package/dist/scripts/local-collab-worktree-gpt-final-apply-policy-check.js

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
-import { gptFinalRequiredForPipeline } from '../core/pipeline/gpt-final-required.js';
-import { finalizePipelineResult } from '../core/pipeline/finalize-pipeline-result.js';
-import { selectFinalGptPatchSource } from '../core/pipeline/final-gpt-patch-stage.js';
-const worktreeEnvelope = {
-    schema: 'sks.agent-patch-envelope.v1',
-    source: 'git-worktree-diff',
-    git_worktree: {
-        worktree_path: '/tmp/sks-worker',
-        changed_files: ['src/core/example.ts']
-    },
-    operations: [{ op: 'git_apply_patch', path: '.', diff: 'diff --git a/src/core/example.ts b/src/core/example.ts\n' }]
-};
-const requirement = gptFinalRequiredForPipeline({
-    localParticipated: false,
-    candidateResults: [{ backend: 'codex-sdk', patch_envelopes: [worktreeEnvelope] }],
-    candidatePatchEnvelopes: [worktreeEnvelope]
-});
-const blocked = await finalizePipelineResult({
-    route: '$Naruto',
-    missionId: 'M-worktree-gpt-final-policy',
-    localParticipated: false,
-    candidateResults: [{ backend: 'codex-sdk', patch_envelopes: [worktreeEnvelope] }],
-    candidatePatchEnvelopes: [worktreeEnvelope],
-    verificationResults: [],
-    sideEffectReport: {},
-    mutationLedger: {},
-    rollbackPlan: {},
-    applyPatches: true,
-    forceGptFinalUnavailable: true
-});
-const modified = selectFinalGptPatchSource({
-    result: {
-        status: 'modified',
-        modified_patch_envelopes: [{ ...worktreeEnvelope, source: 'model_authored', operations: [{ op: 'replace', path: 'src/core/example.ts', search: 'old', replace: 'new' }] }]
-    }
-}, [worktreeEnvelope]);
-const rejected = selectFinalGptPatchSource({ result: { status: 'rejected' } }, [worktreeEnvelope]);
-const ok = requirement.gpt_final_required === true
-    && requirement.worktree_participated === true
-    && blocked.ok === false
-    && blocked.apply_allowed === false
-    && blocked.blockers.includes('gpt_final_arbiter_required_not_passed')
-    && modified.ok === true
-    && modified.final_patch_source === 'gpt_final_arbiter'
-    && modified.patch_envelopes[0]?.source === 'model_authored'
-    && rejected.ok === false
-    && rejected.final_patch_source === 'blocked';
-assertGate(ok, 'Worktree/local candidate output must require GPT Final before apply, and GPT modified/rejected decisions must control final patch source', {
-    requirement,
-    blocked,
-    modified,
-    rejected
-});
-emitGate('local-collab:worktree-gpt-final-apply-policy', {
-    requirement,
-    blocked_apply_allowed: blocked.apply_allowed,
-    modified_source: modified.final_patch_source,
-    rejected_source: rejected.final_patch_source
-});
-//# sourceMappingURL=local-collab-worktree-gpt-final-apply-policy-check.js.map

package/dist/scripts/local-llm-cache-performance-check.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
-const cache = await importDist('core/local-llm/local-llm-prompt-cache.js');
-const a = cache.buildLocalLlmPromptCacheRecord({ routeSystemEnvelopeHash: 'a', localWorkerPolicyHash: 'b', coreSkillSnapshotHash: 'c', triwikiContextPackHash: 'd', repoSummaryHash: 'e', capabilityCardHash: 'f' });
-const b = cache.buildLocalLlmPromptCacheRecord({ routeSystemEnvelopeHash: 'a', localWorkerPolicyHash: 'b', coreSkillSnapshotHash: 'c', triwikiContextPackHash: 'd2', repoSummaryHash: 'e', capabilityCardHash: 'f' });
-assertGate(a.cacheable === true, 'prompt cache record should be cacheable when hashes exist');
-assertGate(a.cache_key !== b.cache_key, 'source hash change must invalidate cache');
-emitGate('local-llm:cache-performance', { cacheable: a.cacheable, invalidates_on_hash_change: true });
-//# sourceMappingURL=local-llm-cache-performance-check.js.map

package/dist/scripts/local-llm-capability-check.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist, readText } from './lib/codex-sdk-gate-lib.js';
-const mod = await importDist('core/agents/ollama-worker-config.js');
-const schemaText = readText('schemas/local-llm/local-model-config.schema.json');
-const config = mod.normalizeLocalModelConfig({ enabled: true, status: 'enabled_unverified' });
-const mlx = mod.normalizeLocalModelConfig({ enabled: true, provider: 'mlx-lm', model: 'mlx-community/Qwen3.6-35B-A3B-4bit', base_url: 'http://127.0.0.1:8080' });
-assertGate(config.schema === 'sks.local-model-config.v2', 'local model config must use v2 schema');
-assertGate(config.status === 'enabled_unverified', 'enabled without smoke must be enabled_unverified');
-assertGate(mlx.provider === 'mlx-lm' && mlx.base_url === 'http://127.0.0.1:8080', 'local model config must preserve MLX LM provider settings');
-assertGate(schemaText.includes('verified'), 'local model schema must include verified status');
-assertGate(schemaText.includes('mlx-lm'), 'local model schema must allow MLX LM provider');
-emitGate('local-llm:capability', { status: config.status, schema: config.schema, mlx_provider: mlx.provider });
-//# sourceMappingURL=local-llm-capability-check.js.map

package/dist/scripts/local-llm-smoke-check.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist, root } from './lib/codex-sdk-gate-lib.js';
-const cfg = await importDist('core/agents/ollama-worker-config.js');
-const smokeMod = await importDist('core/local-llm/local-llm-smoke.js');
-const config = cfg.normalizeLocalModelConfig({ enabled: true, status: 'enabled_unverified' });
-const updateConfig = process.argv.includes('--update-config') || process.argv.includes('--write-config');
-if (process.env.SKS_REQUIRE_LOCAL_LLM !== '1' && !process.argv.includes('--require-real')) {
-    const skipped = cfg.applyLocalLlmSmokeResult(config, { ok: false, skipped: true, status: 'enabled_unverified', reason: 'release_check_no_real_smoke', schema_valid: false });
-    assertGate(skipped.status === 'enabled_unverified', '--skip-smoke or hermetic mode must not verify local LLM');
-    emitGate('local-llm:smoke', { status: 'hermetic_skip', config_status: skipped.status });
-}
-else {
-    const reportPath = `${root}/.sneakoscope/reports/local-llm-smoke-real.json`;
-    const realConfig = await cfg.readLocalModelConfig();
-    const first = await smokeMod.runLocalLlmGenerationSmoke(realConfig, { reportPath, timeoutMs: 60_000 });
-    const shouldRetry = first.ok !== true && String(first.blockers || []).match(/aborted|timeout|local_llm_generate_failed/i);
-    const smoke = shouldRetry
-        ? await smokeMod.runLocalLlmGenerationSmoke(realConfig, { reportPath, timeoutMs: 90_000 })
-        : first;
-    assertGate(smoke.ok === true && smoke.schema_valid === true, 'real local LLM smoke failed', { smoke, retry_count: shouldRetry ? 1 : 0, first_failure_blockers: first.blockers || [] });
-    const updatedConfig = updateConfig ? await cfg.writeLocalModelConfig(cfg.applyLocalLlmSmokeResult(realConfig, smoke)) : null;
-    emitGate('local-llm:smoke', {
-        status: 'real_verified',
-        latency_ms: smoke.latency_ms,
-        tokens_per_second: smoke.tokens_per_second,
-        retry_count: shouldRetry ? 1 : 0,
-        config_updated: updateConfig,
-        config_status: updatedConfig?.status || realConfig.status
-    });
-}
-//# sourceMappingURL=local-llm-smoke-check.js.map

package/dist/scripts/local-llm-structured-output-check.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
-const mod = await importDist('core/local-llm/local-llm-schema-enforcer.js');
-const schema = { type: 'object', required: ['status'], properties: { status: { type: 'string' } }, additionalProperties: false };
-const good = mod.enforceLocalLlmJsonSchema('{"status":"ok"}', schema);
-const bad = mod.enforceLocalLlmJsonSchema('plain words', schema);
-assertGate(good.ok === true && good.schema_valid === true, 'valid local JSON should pass');
-assertGate(bad.ok === false, 'natural language local output must not pass');
-emitGate('local-llm:structured-output', { good: good.ok, bad: bad.ok });
-//# sourceMappingURL=local-llm-structured-output-check.js.map

package/dist/scripts/local-llm-throughput-check.js

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
-const scheduler = await importDist('core/local-llm/local-llm-scheduler.js');
-const plan = scheduler.planLocalLlmSchedule({ workItems: Array.from({ length: 20 }, (_, i) => ({ id: i })), maxParallelRequests: 4 });
-assertGate(plan.ok === true, 'local scheduler must not exceed max parallel requests');
-assertGate(plan.active_requests <= plan.max_parallel_requests, 'active requests exceeded max_parallel_requests');
-assertGate(plan.queued_count === 16, '20 worker fixture should queue work beyond max parallel requests');
-emitGate('local-llm:throughput', { active_requests: plan.active_requests, queued_count: plan.queued_count, backpressure: plan.backpressure });
-//# sourceMappingURL=local-llm-throughput-check.js.map