sneakoscope 4.0.13 → 4.0.15

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { runLoopDirectiveCheck } from './loop-directive-check-lib.js';
+await runLoopDirectiveCheck('loop:artifact-paths');
+//# sourceMappingURL=loop-artifact-paths-check.js.map

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

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