sneakoscope 2.0.13 → 2.0.15

package/dist/scripts/legacy-upgrade-matrix-check.js

@@ -1,300 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-// Gate: legacy:upgrade-zero-break
-// Proves a 1.18.x -> 1.19 upgrade never breaks user Codex config across legacy
-// states. Operates entirely on temp dirs (os.tmpdir + fs.mkdtemp); never touches
-// the real ~/.codex. Always restores process.env.CODEX_HOME / HOME in finally.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { root, assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
-const policy = await importDist('core/codex/codex-project-config-policy.js');
-const install = await importDist('cli/install-helpers.js');
-const journal = await importDist('core/migration/migration-transaction-journal.js');
-const skillCard = await importDist('core/skills/core-skill-card.js');
-const skillDeployment = await importDist('core/skills/core-skill-deployment.js');
-const { createRequestedScopeContract } = await importDist('core/safety/requested-scope-contract.js');
-function mkTmp(prefix) {
-    return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-}
-function rmTmp(dir) {
-    try {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-    catch {
-        // best-effort cleanup; never fail the gate on teardown
-    }
-}
-const tmpDirs = [];
-const savedCodexHome = process.env.CODEX_HOME;
-const savedHome = process.env.HOME;
-const summary = { states: {}, generated_at: new Date().toISOString() };
-try {
-    // ---------------------------------------------------------------------------
-    // State 6 — corrupted config (machine-local key absorbed into a TOML table).
-    // The pre-fix mover appended top-level machine-local keys after the last
-    // [table], so TOML absorbed them into that table. repairCodexConfigStructure
-    // hoists them back above the first table header.
-    // ---------------------------------------------------------------------------
-    {
-        const dir = mkTmp('sks-legacy-corrupt-');
-        tmpDirs.push(dir);
-        const configPath = path.join(dir, 'config.toml');
-        const corrupted = 'model = "gpt-5.5"\nservice_tier = "fast"\n\n[mcp_servers.xai-grok.env]\nXAI_API_KEY = "x"\nmodel_provider = "codex-lb"\nnotify = ["a","b"]\n';
-        fs.writeFileSync(configPath, corrupted, 'utf8');
-        const result = await policy.repairCodexConfigStructure(configPath, { apply: true });
-        const okStatuses = ['structure_repaired', 'structure_repair_available', 'structure_ok'];
-        assertGate(okStatuses.includes(result.status), 'corrupted_config: repair status not recognized', { status: result.status, expected: okStatuses });
-        // If it hoisted, a backup must exist on disk.
-        if (result.status === 'structure_repaired') {
-            assertGate(Boolean(result.backup_path) && fs.existsSync(result.backup_path), 'corrupted_config: repaired but no backup file on disk', { backup_path: result.backup_path });
-        }
-        // Tolerant structural check: either the keys were hoisted ABOVE the first
-        // table header, or the structure was already ok.
-        const repaired = fs.readFileSync(configPath, 'utf8');
-        const firstTableIdx = repaired.indexOf('\n[');
-        const headRegion = firstTableIdx === -1 ? repaired : repaired.slice(0, firstTableIdx);
-        const hoisted = /^\s*model_provider\s*=/m.test(headRegion) && /^\s*notify\s*=/m.test(headRegion);
-        assertGate(hoisted || result.status === 'structure_ok', 'corrupted_config: machine-local keys were not hoisted above the first table', { status: result.status, head_region: headRegion });
-        summary.states.corrupted_config = {
-            status: result.status,
-            hoisted_keys: result.hoisted_keys || [],
-            backup_present: Boolean(result.backup_path)
-        };
-    }
-    // ---------------------------------------------------------------------------
-    // States 1-4 — user global config preserved + user-disabled flags not
-    // re-enabled. ensureGlobalCodexFastModeDuringInstall reads the Codex home
-    // config (HOME/.codex/config.toml; honors opts.home). It is set-if-absent and
-    // backs up the prior good config before any mutation.
-    // ---------------------------------------------------------------------------
-    {
-        const tmpHome = mkTmp('sks-legacy-home-');
-        tmpDirs.push(tmpHome);
-        const codexDir = path.join(tmpHome, '.codex');
-        fs.mkdirSync(codexDir, { recursive: true });
-        const configPath = path.join(codexDir, 'config.toml');
-        const userConfig = 'model = "o3"\nservice_tier = "flex"\nmodel_reasoning_effort = "high"\n\n[features]\nbrowser_use = false\n\n# user comment\n';
-        fs.writeFileSync(configPath, userConfig, 'utf8');
-        process.env.CODEX_HOME = tmpHome;
-        process.env.HOME = tmpHome;
-        const result = await install.ensureGlobalCodexFastModeDuringInstall({ home: tmpHome });
-        const after = fs.readFileSync(configPath, 'utf8');
-        assertGate(after.includes('model = "o3"'), 'user_config_preserved: user model was overwritten', { status: result.status });
-        assertGate(after.includes('service_tier = "flex"'), 'user_config_preserved: user service_tier was overwritten', { status: result.status });
-        assertGate(after.includes('model_reasoning_effort = "high"'), 'user_config_preserved: user model_reasoning_effort was overwritten', { status: result.status });
-        // User-disabled feature must NOT be re-enabled (set-if-absent only).
-        assertGate(after.includes('browser_use = false'), 'flags_not_reenabled: user-disabled browser_use was re-enabled', { status: result.status });
-        // When the managed defaults were applied, the prior good config must be
-        // backed up to a sibling config.toml.*bak file.
-        if (result.status === 'updated') {
-            const siblings = fs.readdirSync(codexDir);
-            const backup = siblings.find((name) => /config\.toml\..*bak/.test(name));
-            assertGate(Boolean(backup), 'user_config_preserved: status=updated but no backup file written', { siblings });
-            summary.states.user_config_preserved = { status: result.status, backup: backup };
-        }
-        else {
-            summary.states.user_config_preserved = { status: result.status };
-        }
-        summary.states.flags_not_reenabled = { browser_use_preserved: true };
-        // Restore env immediately after this state to avoid leaking into spawns.
-        if (savedCodexHome === undefined)
-            delete process.env.CODEX_HOME;
-        else
-            process.env.CODEX_HOME = savedCodexHome;
-        if (savedHome === undefined)
-            delete process.env.HOME;
-        else
-            process.env.HOME = savedHome;
-    }
-    // ---------------------------------------------------------------------------
-    // State 6b — splitter preserves project keys. The project config keeps its
-    // own [profiles.*] table; only machine-local top-level keys are moved out.
-    // ---------------------------------------------------------------------------
-    {
-        const projectRoot = mkTmp('sks-legacy-project-');
-        const tmpHome2 = mkTmp('sks-legacy-home2-');
-        tmpDirs.push(projectRoot, tmpHome2);
-        const projectCodexDir = path.join(projectRoot, '.codex');
-        fs.mkdirSync(projectCodexDir, { recursive: true });
-        const projectConfigPath = path.join(projectCodexDir, 'config.toml');
-        // Machine-local keys/tables (model_provider, [profiles.*]) move out to CODEX_HOME;
-        // project-scoped settings (sandbox_mode, [features]) must be PRESERVED in place.
-        fs.writeFileSync(projectConfigPath, 'model_provider = "codex-lb"\nsandbox_mode = "workspace-write"\n\n[features]\nhooks = true\n', 'utf8');
-        const result = await policy.splitCodexProjectConfigPolicy(projectRoot, {
-            apply: true,
-            codexHome: tmpHome2,
-            writeReport: false
-        });
-        const projectAfter = fs.readFileSync(projectConfigPath, 'utf8');
-        assertGate(projectAfter.includes('sandbox_mode = "workspace-write"'), 'splitter_preserves_project: project-scoped sandbox_mode was removed', { status: result.status, project_after: projectAfter });
-        assertGate(projectAfter.includes('[features]'), 'splitter_preserves_project: project-scoped [features] table was removed', { status: result.status, project_after: projectAfter });
-        assertGate(!/^\s*model_provider\s*=/m.test(projectAfter), 'splitter_preserves_project: machine-local model_provider was not moved out of the project config', { status: result.status, project_after: projectAfter });
-        summary.states.splitter_preserves_project = {
-            status: result.status,
-            moved_keys: result.moved_keys || [],
-            moved_tables: result.moved_tables || []
-        };
-    }
-    // ---------------------------------------------------------------------------
-    // State 7/10 — tmux is a removed runtime; zellij status is informational.
-    // Spawn the built CLI from the repo root.
-    // ---------------------------------------------------------------------------
-    {
-        const tmux = spawnSync(process.execPath, ['dist/bin/sks.js', 'tmux', '--json'], {
-            cwd: root,
-            encoding: 'utf8'
-        });
-        let tmuxJson;
-        try {
-            tmuxJson = JSON.parse(tmux.stdout);
-        }
-        catch (err) {
-            assertGate(false, 'tmux_removed_runtime: stdout is not valid JSON', {
-                stdout: tmux.stdout,
-                stderr: tmux.stderr,
-                error: String(err)
-            });
-        }
-        assertGate(tmuxJson.status === 'removed_runtime' && tmuxJson.replacement === 'zellij', 'tmux_removed_runtime: tmux did not report removed_runtime -> zellij', { json: tmuxJson });
-        assertGate(tmux.status === 2, 'tmux_removed_runtime: tmux exit code must be 2', { exit: tmux.status });
-        summary.states.tmux_removed_runtime = {
-            status: tmuxJson.status,
-            replacement: tmuxJson.replacement,
-            exit: tmux.status
-        };
-        const zj = spawnSync(process.execPath, ['dist/bin/sks.js', 'zellij', 'status', '--json'], {
-            cwd: root,
-            encoding: 'utf8'
-        });
-        let zjJson;
-        try {
-            zjJson = JSON.parse(zj.stdout);
-        }
-        catch (err) {
-            assertGate(false, 'zellij_status_informational: stdout is not valid JSON', {
-                stdout: zj.stdout,
-                stderr: zj.stderr,
-                error: String(err)
-            });
-        }
-        assertGate(Object.prototype.hasOwnProperty.call(zjJson, 'status'), 'zellij_status_informational: missing status field', { json: zjJson });
-        // Informational status must not hard-fail when zellij is missing.
-        assertGate(zjJson.ok === true, 'zellij_status_informational: informational status hard-failed (ok !== true)', { json: zjJson });
-        summary.states.zellij_status_informational = { status: zjJson.status, ok: zjJson.ok };
-    }
-    // ---------------------------------------------------------------------------
-    // Migration journal contract — before/after hash, change + rollback flags.
-    // ---------------------------------------------------------------------------
-    {
-        const ev = journal.buildMigrationEvent({
-            step: 't',
-            target: '/x/config.toml',
-            before: 'a',
-            after: 'b',
-            backupPath: '/x/config.toml.bak'
-        });
-        assertGate(Boolean(ev.before_hash) &&
-            Boolean(ev.after_hash) &&
-            ev.before_hash !== ev.after_hash &&
-            ev.changed === true &&
-            ev.rollback_available === true &&
-            ev.backup_path === '/x/config.toml.bak', 'migration_journal: mutated event contract failed', { event: ev });
-        const ev2 = journal.buildMigrationEvent({ step: 't', target: '/x', before: 'a', after: 'a' });
-        assertGate(ev2.changed === false && ev2.rollback_available === false, 'migration_journal: no-op event contract failed', { event: ev2 });
-        summary.states.migration_journal = { mutated: true, noop: true };
-    }
-    // ---------------------------------------------------------------------------
-    // State 1.19.x_zellij_project_noop — a clean 1.19.x config (no machine-local
-    // issues) is a no-op for the upgrade. repairCodexConfigStructure returns
-    // 'structure_ok' and the file is byte-identical afterwards.
-    // ---------------------------------------------------------------------------
-    {
-        const dir = mkTmp('sks-legacy-noop-');
-        tmpDirs.push(dir);
-        const configPath = path.join(dir, 'config.toml');
-        const clean = 'model = "gpt-5.5"\nservice_tier = "fast"\n\n[features]\nhooks = true\n';
-        fs.writeFileSync(configPath, clean, 'utf8');
-        const before = fs.readFileSync(configPath, 'utf8');
-        const result = await policy.repairCodexConfigStructure(configPath, { apply: true });
-        assertGate(result.status === 'structure_ok', '1.19.x_zellij_project_noop: clean config did not report structure_ok', { status: result.status });
-        const after = fs.readFileSync(configPath, 'utf8');
-        assertGate(after === before, '1.19.x_zellij_project_noop: clean config was modified by a no-op upgrade', { before, after });
-        assertGate(result.changed === false && result.applied === false && !result.backup_path, '1.19.x_zellij_project_noop: no-op upgrade reported a change/backup', { changed: result.changed, applied: result.applied, backup_path: result.backup_path });
-        summary.states['1.19.x_zellij_project_noop'] = {
-            status: result.status,
-            changed: result.changed,
-            byte_identical: true
-        };
-    }
-    // ---------------------------------------------------------------------------
-    // State existing_skill_cards_preserved — an upgrade never clobbers existing
-    // deployed skill cards. Deploy an accepted card, then read it back twice and
-    // assert the deployed snapshot's body_hash is byte-preserved across the
-    // simulated "upgrade read".
-    // ---------------------------------------------------------------------------
-    {
-        const skillRootDir = mkTmp('sks-legacy-skill-');
-        tmpDirs.push(skillRootDir);
-        const candidate = skillCard.createCandidateCard({
-            skillId: 'legacy-skill',
-            route: 'DFix',
-            baseVersion: 0,
-            body: '## Goal\nx\n'
-        });
-        const accepted = { ...candidate, status: 'accepted' };
-        const promotionContract = createRequestedScopeContract({
-            route: 'legacy-upgrade-zero-break',
-            userRequest: 'release gate fixture skill promotion',
-            projectRoot: skillRootDir,
-            overrides: { skill_snapshot_promotion: true }
-        });
-        const promote = await skillDeployment.promoteToDeployedWithLedger(skillRootDir, accepted, { contract: promotionContract, context: 'release' });
-        assertGate(promote.ok === true && promote.snapshot, 'existing_skill_cards_preserved: accepted card failed to promote to a deployed snapshot', { blockers: promote.blockers });
-        const deployed = await skillCard.loadDeployedSnapshot(skillRootDir, 'DFix', 'legacy-skill');
-        assertGate(Boolean(deployed) && deployed.status === 'deployed' && deployed.deployment_snapshot === true, 'existing_skill_cards_preserved: deployed snapshot did not load back', { deployed });
-        // Simulate an "upgrade read": loading the snapshot again must not clobber it.
-        const reread = await skillCard.loadDeployedSnapshot(skillRootDir, 'DFix', 'legacy-skill');
-        assertGate(Boolean(reread) && reread.body_hash === deployed.body_hash, 'existing_skill_cards_preserved: skill card body_hash changed across an upgrade read', { before_hash: deployed.body_hash, after_hash: reread && reread.body_hash });
-        summary.states.existing_skill_cards_preserved = {
-            promoted: true,
-            body_hash: deployed.body_hash,
-            byte_preserved: true
-        };
-    }
-    // ---------------------------------------------------------------------------
-    // Write the report and emit the gate.
-    // ---------------------------------------------------------------------------
-    const reportDir = path.join(root, '.sneakoscope', 'reports');
-    fs.mkdirSync(reportDir, { recursive: true });
-    const reportPath = path.join(reportDir, 'legacy-upgrade-matrix.json');
-    fs.writeFileSync(reportPath, `${JSON.stringify({ schema: 'sks.legacy-upgrade-matrix.v1', ok: true, ...summary }, null, 2)}\n`, 'utf8');
-    emitGate('legacy:upgrade-zero-break', {
-        report_path: reportPath,
-        states_checked: [
-            'corrupted_config',
-            'user_config_preserved',
-            'flags_not_reenabled',
-            'splitter_preserves_project',
-            'tmux_removed_runtime',
-            'zellij_status_informational',
-            'migration_journal',
-            '1.19.x_zellij_project_noop',
-            'existing_skill_cards_preserved'
-        ]
-    });
-}
-finally {
-    for (const dir of tmpDirs)
-        rmTmp(dir);
-    if (savedCodexHome === undefined)
-        delete process.env.CODEX_HOME;
-    else
-        process.env.CODEX_HOME = savedCodexHome;
-    if (savedHome === undefined)
-        delete process.env.HOME;
-    else
-        process.env.HOME = savedHome;
-}
-//# sourceMappingURL=legacy-upgrade-matrix-check.js.map

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

@@ -1,21 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
-const finalizer = await importDist('core/pipeline/finalize-pipeline-result.js');
-const blocked = await finalizer.finalizePipelineResult({
-    route: '$Team',
-    missionId: 'M-local-final-gpt',
-    localParticipated: true,
-    candidateResults: [{ backend: 'local-llm', summary: 'draft' }],
-    candidatePatchEnvelopes: [],
-    verificationResults: [],
-    sideEffectReport: {},
-    mutationLedger: {},
-    rollbackPlan: {},
-    applyPatches: true,
-    forceGptFinalUnavailable: true
-});
-assertGate(blocked.ok === false, 'local participation without GPT final must block finalization');
-assertGate(blocked.blockers.includes('gpt_final_arbiter_required_not_passed'), 'missing GPT final blocker required');
-emitGate('local-collab:all-pipelines-final-gpt', { final_status: blocked.final_status, blockers: blocked.blockers.length });
-//# sourceMappingURL=local-collab-all-pipelines-final-gpt-check.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-all-pipelines-check.js

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, readText } from './lib/codex-sdk-gate-lib.js';
-const router = readText('src/core/agents/native-worker-backend-router.ts');
-const control = readText('src/core/codex-control/codex-task-runner.ts');
-const policy = readText('src/core/local-llm/local-worker-eligibility.ts');
-assertGate(router.includes("backend === 'local-llm'"), 'native worker router must support local-llm backend');
-assertGate(control.includes('runLocalLlmTask'), 'Codex Control Plane must call local LLM task adapter');
-assertGate(policy.includes('requires_gpt_final'), 'local worker eligibility must require GPT final');
-emitGate('local-llm:all-pipelines', { local_backend: 'local-llm', requires_gpt_final: true });
-//# sourceMappingURL=local-llm-all-pipelines-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,23 +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' });
-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 || [] });
-    emitGate('local-llm:smoke', { status: 'real_verified', latency_ms: smoke.latency_ms, tokens_per_second: smoke.tokens_per_second, retry_count: shouldRetry ? 1 : 0 });
-}
-//# 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

package/dist/scripts/local-llm-tool-call-repair-check.js

@@ -1,10 +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-json-repair.js');
-const repaired = mod.parseOrRepairLocalLlmJson('Here is JSON: {"status":"ok","summary":"done"} thanks');
-const failed = mod.parseOrRepairLocalLlmJson('not json at all');
-assertGate(repaired.ok === true && repaired.repaired === true && repaired.attempts === 1, 'bounded JSON repair should recover one object');
-assertGate(failed.ok === false && failed.attempts === 1, 'invalid local JSON must fail after one repair attempt');
-emitGate('local-llm:tool-call-repair', { repaired: repaired.ok, failed: failed.ok });
-//# sourceMappingURL=local-llm-tool-call-repair-check.js.map

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

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import { assertGate, emitGate, importDist } from './lib/codex-sdk-gate-lib.js';
-const cfg = await importDist('core/agents/ollama-worker-config.js');
-const warmup = await importDist('core/local-llm/local-llm-warmup.js');
-const state = warmup.buildLocalLlmWarmupState(cfg.normalizeLocalModelConfig({ enabled: true, status: 'enabled_unverified' }), { ok: true, ttlMs: 1000 });
-assertGate(state.explicit_only === true, 'local warmup must be explicit only');
-assertGate(state.postinstall_allowed === false, 'postinstall must not run local warmup');
-assertGate(state.release_check_real_warmup_allowed === false, 'release:check must not run real warmup');
-emitGate('local-llm:warmup', { explicit_only: state.explicit_only, expires_at: state.expires_at });
-//# sourceMappingURL=local-llm-warmup-check.js.map

package/dist/scripts/loop-blocker-check.js

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-// @ts-nocheck
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-const root = process.cwd();
-const mod = await import(pathToFileURL(path.join(root, 'dist/core/loop-blocker.js')));
-const report = mod.detectRepeatedBlocker([
-    { reason: 'imagegen_capability_missing', detail: 'Codex App tool unavailable' },
-    { reason: 'imagegen_capability_missing', detail: 'Codex App tool unavailable' }
-], 2);
-assert.equal(report.stop_required, true);
-assert.equal(report.repeated[0].count, 2);
-console.log(JSON.stringify({ schema: 'sks.loop-blocker-check.v1', ok: true, report }, null, 2));
-//# sourceMappingURL=loop-blocker-check.js.map