sneakoscope 4.8.6 → 5.1.2

package/dist/core/zellij/zellij-viewport-binder.js

@@ -0,0 +1,59 @@
+const ACTIVE = new Set(['running', 'verifying', 'launching']);
+const ATTENTION = new Set(['failed', 'blocked', 'timed_out']);
+function scoreSlot(s, now) {
+    const ts = Date.parse(String(s.latest_ts || '')) || 0;
+    const age = Math.max(0, now - ts);
+    const st = String(s.status || '').toLowerCase();
+    if (ATTENTION.has(st) && age < 3 * 60_000)
+        return 4_000_000 - age / 1000;
+    if (st === 'running')
+        return 3_000_000 - age / 1000;
+    if (st === 'verifying')
+        return 2_000_000 - age / 1000;
+    if (st === 'queued' || st === 'launching')
+        return 1_000_000 - age / 1000;
+    return -1;
+}
+export function bindViewports(input) {
+    const count = Math.max(0, Math.floor(Number(input.viewportCount) || 0));
+    const now = Date.now();
+    const slots = Object.entries(input.snapshot?.slots || {})
+        .map(([key, s]) => ({ key, s, score: scoreSlot(s, now) }))
+        .filter((row) => row.score >= 0)
+        .sort((a, b) => b.score - a.score || a.key.localeCompare(b.key));
+    const taken = new Set();
+    const out = Array.from({ length: count }, () => ({ slotKey: null, reason: 'idle' }));
+    for (const pin of input.pins || []) {
+        const i = Math.floor(Number(pin.viewport) || 0) - 1;
+        if (i < 0 || i >= count)
+            continue;
+        if (!input.snapshot?.slots?.[pin.slot_key])
+            continue;
+        out[i] = { slotKey: pin.slot_key, reason: 'pinned' };
+        taken.add(pin.slot_key);
+    }
+    for (let i = 0; i < count; i += 1) {
+        if (out[i]?.slotKey)
+            continue;
+        const prev = input.previous[i];
+        if (!prev || taken.has(prev))
+            continue;
+        const st = String(input.snapshot?.slots?.[prev]?.status || '').toLowerCase();
+        if (ACTIVE.has(st)) {
+            out[i] = { slotKey: prev, reason: 'kept' };
+            taken.add(prev);
+        }
+    }
+    const rest = slots.filter((row) => !taken.has(row.key));
+    for (let i = 0; i < count; i += 1) {
+        if (out[i]?.slotKey)
+            continue;
+        const next = rest.shift();
+        if (!next)
+            break;
+        out[i] = { slotKey: next.key, reason: 'assigned' };
+        taken.add(next.key);
+    }
+    return out;
+}
+//# sourceMappingURL=zellij-viewport-binder.js.map

package/dist/core/zellij/zellij-worker-pane-manager.js

@@ -78,7 +78,7 @@ export function buildWorkerPaneArtifact(input) {
         schema: ZELLIJ_WORKER_PANE_SCHEMA,
         generated_at: now,
         updated_at: now,
-        ok: blockers.length === 0 && (paneIdSource === 'zellij_worker_headless_overflow' || (isRealZellijWorkerPaneIdSource(paneIdSource) && Boolean(input.paneId))),
+        ok: blockers.length === 0 && (paneIdSource === 'zellij_worker_headless_overflow' || paneIdSource === 'headless_by_design_viewport_ui' || paneIdSource === 'preallocated_layout_pane' || (isRealZellijWorkerPaneIdSource(paneIdSource) && Boolean(input.paneId))),
         status: input.status || 'launching',
         mission_id: input.missionId,
         session_name: input.sessionName,
@@ -129,6 +129,43 @@ export function buildWorkerPaneArtifact(input) {
         blockers
     };
 }
+export async function openHeadlessByDesignViewportWorker(input) {
+    const root = path.resolve(input.root);
+    const providerInput = { root, route: '$Agent' };
+    const serviceTier = input.serviceTier || process.env.SKS_SERVICE_TIER;
+    if (serviceTier != null)
+        providerInput.serviceTier = serviceTier;
+    const providerContext = input.providerContext || await resolveProviderContext(providerInput);
+    await ensureDir(path.join(root, input.workerArtifactDir));
+    const record = buildWorkerPaneArtifact({
+        ...input,
+        paneId: null,
+        paneIdSource: 'headless_by_design_viewport_ui',
+        createSession: null,
+        launch: null,
+        paneReconciliation: null,
+        directionRequested: 'down',
+        directionApplied: 'not_applied',
+        columnCreationDirectionRequested: null,
+        columnCreationDirectionApplied: 'not_applied',
+        workerDirectionRequested: 'down',
+        workerDirectionApplied: 'not_applied',
+        status: 'running',
+        providerContext,
+        serviceTier: input.serviceTier || providerContext.service_tier,
+        paneKind: 'slot_status_renderer',
+        scalingPrimitive: 'native_cli_process_headless_with_slot_dashboard',
+        workerCommand: '<headless-by-design-viewport-ui>',
+        blockers: []
+    });
+    await writeWorkerPaneArtifact(root, record);
+    await appendWorkerPaneEvent(root, 'worker_headless_by_design_viewport_ui', input, {
+        slot_id: input.slotId,
+        generation_index: input.generationIndex,
+        reason: 'monitor_plus_viewports'
+    });
+    return record;
+}
 export async function openWorkerPane(input) {
     const root = path.resolve(input.root);
     const cwd = input.cwd || packageRoot();
@@ -146,6 +183,9 @@ export async function openWorkerPane(input) {
         optional: false
     });
     const createSession = normalizeExistingZellijSession(input.sessionName, createSessionRaw);
+    const requestedCap = nonNegativeInt(input.visiblePaneCap, 0);
+    const envCap = nonNegativeInt(Number(process.env.SKS_ZELLIJ_VISIBLE_PANES || 0), 0);
+    const visiblePaneCap = Math.max(1, requestedCap || envCap || 1);
     const rightColumn = input.rightColumnMode === 'spawn-on-first-worker'
         ? await prepareWorkerInRightColumn({
             root,
@@ -154,13 +194,13 @@ export async function openWorkerPane(input) {
             sessionName: input.sessionName,
             cwd,
             worker: { slotId: input.slotId, generationIndex: input.generationIndex },
-            visiblePaneCap: input.visiblePaneCap || 1,
+            visiblePaneCap,
             uiMode: input.uiMode || 'compact-slots',
             dashboardSnapshot: {
                 ...(input.dashboardSnapshot || {}),
                 mode: String(input.dashboardSnapshot?.mode || 'naruto'),
-                active_workers: Number(input.dashboardSnapshot?.active_workers || input.visiblePaneCap || 1),
-                visible_panes: Number(input.dashboardSnapshot?.visible_panes || input.visiblePaneCap || 1)
+                active_workers: Number(input.dashboardSnapshot?.active_workers || visiblePaneCap),
+                visible_panes: Number(input.dashboardSnapshot?.visible_panes || visiblePaneCap)
             }
         })
         : null;
@@ -195,7 +235,7 @@ export async function openWorkerPane(input) {
         await appendWorkerPaneEvent(root, 'worker_headless_overflow', input, {
             slot_id: input.slotId,
             generation_index: input.generationIndex,
-            reason: `visible_pane_cap:${input.visiblePaneCap || 1}`
+            reason: `visible_pane_cap:${visiblePaneCap}`
         });
         return record;
     }
@@ -876,4 +916,12 @@ function normalizeExistingZellijSession(sessionName, result) {
     }
     return result;
 }
+function nonNegativeInt(value, fallback) {
+    const n = Math.floor(Number(value));
+    return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function slotIndexNumber(slotId) {
+    const match = /(\d+)$/.exec(String(slotId || ''));
+    return match ? Math.max(1, Number(match[1])) : 1;
+}
 //# sourceMappingURL=zellij-worker-pane-manager.js.map

package/dist/scripts/agent-patch-swarm-gate-lib.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 // @ts-nocheck
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
+import { tmpdir } from '../core/fsx.js';
 import { assertGate, emitGate, importDist, root } from './sks-1-18-gate-lib.js';
 export function writeReport(name, report) {
     const out = path.join(root, '.sneakoscope', 'reports', `${name}.json`);
@@ -14,7 +14,7 @@ export function readJson(file) {
     return JSON.parse(fs.readFileSync(file, 'utf8'));
 }
 export function makeTempPatchProject(prefix = 'sks-patch-swarm-') {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    const dir = tmpdir(prefix);
     for (let index = 1; index <= 10; index += 1) {
         fs.writeFileSync(path.join(dir, `file-${index}.txt`), `before-${index}\n`);
     }

package/dist/scripts/build-dist.js

@@ -10,6 +10,7 @@ const distRoot = path.join(root, 'dist');
 await fsp.mkdir(distRoot, { recursive: true });
 await removeDistMjs(distRoot);
 await copyRuntimeConfigFiles();
+await writeSkillsManifest();
 await removeDistNonRuntimeArtifacts(distRoot);
 await import('./write-build-manifest.js');
 async function removeDistMjs(dir) {
@@ -47,6 +48,13 @@ async function copyRuntimeConfigFiles() {
     }
     await copyDirIfPresent(path.join(srcRoot, 'vendor', 'openai-codex'), path.join(distRoot, 'vendor', 'openai-codex'));
 }
+async function writeSkillsManifest() {
+    const { generatePackagedSkillsManifest } = await import('../core/init/skills.js');
+    const manifest = await generatePackagedSkillsManifest();
+    const out = path.join(distRoot, 'config', 'skills-manifest.json');
+    await fsp.mkdir(path.dirname(out), { recursive: true });
+    await fsp.writeFile(out, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+}
 async function copyDirIfPresent(from, to) {
     if (!fs.existsSync(from))
         return;

package/dist/scripts/check-feature-quality.js

@@ -40,8 +40,8 @@ function releaseQualityBlockers(counts = {}) {
     const blockers = [];
     if (Number(counts.runtime_verified || 0) < 22)
         blockers.push(`runtime_verified_below_release_target:${counts.runtime_verified || 0}<22`);
-    if (Number(counts.runtime_mock_verified || 0) < 45)
-        blockers.push(`runtime_mock_verified_below_release_target:${counts.runtime_mock_verified || 0}<45`);
+    if (Number(counts.wiring_only || 0) > 30)
+        blockers.push(`wiring_only_above_release_target:${counts.wiring_only || 0}>30`);
     if (Number(counts.integration_optional || 0) > 6)
         blockers.push(`integration_optional_above_release_target:${counts.integration_optional || 0}>6`);
     if (Number(counts.static_contract || 0) > 45)

package/dist/scripts/cli-output-consistency-check.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { assertGate, emitGate, root } from './sks-1-18-gate-lib.js';
+import { PACKAGE_VERSION } from '../core/version.js';
+const executed = [
+    ['ui', '--once'],
+    ['review'],
+    ['fast-mode', 'status'],
+    ['menubar', 'status'],
+    ['uninstall', '--dry-run', '--yes'],
+    ['naruto', 'help']
+];
+const staticFiles = [
+    'src/commands/doctor.ts',
+    'src/core/commands/basic-cli.ts',
+    'src/core/commands/naruto-command.ts',
+    'src/core/commands/review-command.ts',
+    'src/core/commands/ui-command.ts',
+    'src/core/commands/fast-mode-command.ts',
+    'src/core/commands/menubar-command.ts',
+    'src/core/commands/uninstall-command.ts'
+];
+const runs = executed.map((args) => run(args));
+const staticMissing = staticFiles.filter((file) => !fs.readFileSync(file, 'utf8').includes('.banner('));
+const badFirstLines = runs.filter((row) => !row.first_line.startsWith(`SKS ${PACKAGE_VERSION} ·`));
+const missingVocabulary = runs.filter((row) => !/[✔▲✖]/.test(row.stdout));
+const report = {
+    schema: 'sks.cli-output-consistency.v1',
+    ok: badFirstLines.length === 0 && missingVocabulary.length === 0 && staticMissing.length === 0,
+    executed: runs,
+    static_files_checked: staticFiles,
+    bad_first_lines: badFirstLines,
+    missing_status_vocabulary: missingVocabulary,
+    static_missing_banner: staticMissing
+};
+assertGate(report.ok, 'CLI output consistency check failed', report);
+emitGate('cli:output-consistency', report);
+function run(args) {
+    const result = spawnSync(process.execPath, ['./dist/bin/sks.js', ...args], {
+        cwd: root,
+        encoding: 'utf8',
+        env: { ...process.env, NO_COLOR: '1', SKS_UNINSTALL_SKIP_TMP_SWEEP: '1' },
+        timeout: 120000,
+        maxBuffer: 1024 * 1024
+    });
+    const stdout = String(result.stdout || '');
+    const stderr = String(result.stderr || '');
+    return {
+        args,
+        code: result.status,
+        first_line: stdout.split(/\r?\n/).find(Boolean) || '',
+        stdout: stdout.slice(0, 4000),
+        stderr: stderr.slice(0, 1000)
+    };
+}
+//# sourceMappingURL=cli-output-consistency-check.js.map

package/dist/scripts/codex-lb-fast-ui-preservation-check.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { codexLbConfigPath, codexLbEnvPath, ensureGlobalCodexFastModeDuringInstall, releaseCodexLbAuthHold, repairCodexLbAuth } from '../cli/install-helpers.js';
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-lb-fast-ui-'));
+const home = path.join(tmp, 'home');
+const codexHome = path.join(home, '.codex');
+const configPath = codexLbConfigPath(home);
+const envPath = codexLbEnvPath(home);
+const authPath = path.join(codexHome, 'auth.json');
+const oauthBackupPath = path.join(codexHome, 'auth.chatgpt-backup.json');
+await fs.mkdir(codexHome, { recursive: true });
+const oauthAuth = JSON.stringify({
+    auth_mode: 'chatgpt',
+    tokens: { id_token: 'oauth-id', access_token: 'oauth-access', refresh_token: 'oauth-refresh' },
+    account_id: 'acct-fast-ui-fixture'
+}, null, 2);
+await fs.writeFile(configPath, [
+    'model = "gpt-5.5"',
+    'model_reasoning_effort = "low"',
+    'model_provider = "codex-lb"',
+    'service_tier = "fast"',
+    '',
+    '[features]',
+    'fast_mode = true',
+    'fast_mode_ui = true',
+    '',
+    '[user.fast_mode]',
+    'visible = true',
+    'enabled = true',
+    '',
+    '[model_providers.codex-lb]',
+    'name = "openai"',
+    'base_url = "https://lb.example.test/backend-api/codex"',
+    'wire_api = "responses"',
+    'env_key = "CODEX_LB_API_KEY"',
+    'supports_websockets = true',
+    'requires_openai_auth = false',
+    ''
+].join('\n'));
+await fs.writeFile(envPath, 'export CODEX_LB_BASE_URL="https://lb.example.test/backend-api/codex"\nexport CODEX_LB_API_KEY="sk-test-fast-ui"\n');
+await fs.writeFile(authPath, `${oauthAuth}\n`);
+const install = await ensureGlobalCodexFastModeDuringInstall({ home, configPath, forceFastMode: true });
+const firstRepair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb' });
+const firstConfig = await fs.readFile(configPath, 'utf8');
+const firstAssert = assertConfig(firstConfig, 'first_use_codex_lb');
+const release = await releaseCodexLbAuthHold({ home, configPath, authPath, backupPath: oauthBackupPath });
+const releasedConfig = await fs.readFile(configPath, 'utf8');
+const releaseAssert = {
+    label: 'use_oauth',
+    ok: !topLevelKey(releasedConfig, 'model_provider') && hasUserFastMode(releasedConfig),
+    blockers: [
+        ...(topLevelKey(releasedConfig, 'model_provider') ? ['model_provider_still_selected_after_use_oauth'] : []),
+        ...(hasUserFastMode(releasedConfig) ? [] : ['user_fast_mode_missing_after_use_oauth'])
+    ]
+};
+const secondRepair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb' });
+const secondConfig = await fs.readFile(configPath, 'utf8');
+const secondAssert = assertConfig(secondConfig, 'second_use_codex_lb');
+const report = {
+    schema: 'sks.codex-lb-fast-ui-preservation-check.v1',
+    ok: firstAssert.ok && releaseAssert.ok && secondAssert.ok,
+    install_status: install.status,
+    first_repair_status: firstRepair.status,
+    release_status: release.status,
+    second_repair_status: secondRepair.status,
+    assertions: [firstAssert, releaseAssert, secondAssert],
+    config_path: configPath,
+    blockers: [...firstAssert.blockers, ...releaseAssert.blockers, ...secondAssert.blockers]
+};
+console.log(JSON.stringify(report, null, 2));
+if (!report.ok)
+    process.exitCode = 1;
+function assertConfig(text, label) {
+    const blockers = [
+        ...(hasUserFastMode(text) ? [] : ['user_fast_mode_visible_enabled_missing']),
+        ...(tableKey(text, 'features', 'fast_mode') === 'true' ? [] : ['features_fast_mode_not_true']),
+        ...(tableKey(text, 'features', 'fast_mode_ui') === 'true' ? [] : ['features_fast_mode_ui_not_true']),
+        ...(hasTable(text, 'model_providers.codex-lb') ? [] : ['codex_lb_provider_table_missing']),
+        ...(tableKey(text, 'model_providers.codex-lb', 'requires_openai_auth') === 'true' ? [] : ['requires_openai_auth_not_true']),
+        ...(topLevelKey(text, 'model') ? ['top_level_model_forbidden'] : []),
+        ...(topLevelKey(text, 'model_reasoning_effort') ? ['top_level_model_reasoning_effort_forbidden'] : [])
+    ];
+    return { label, ok: blockers.length === 0, blockers };
+}
+function hasUserFastMode(text) {
+    return tableKey(text, 'user.fast_mode', 'visible') === 'true'
+        && tableKey(text, 'user.fast_mode', 'enabled') === 'true';
+}
+function hasTable(text, table) {
+    return new RegExp(`(^|\\n)\\[${escapeRegExp(table)}\\](?=\\n|$)`).test(text);
+}
+function tableKey(text, table, key) {
+    const match = text.match(new RegExp(`(^|\\n)\\[${escapeRegExp(table)}\\]([\\s\\S]*?)(?=\\n\\[[^\\]]+\\]|\\s*$)`));
+    const block = match?.[2] || '';
+    return block.match(new RegExp(`(^|\\n)\\s*${escapeRegExp(key)}\\s*=\\s*([^\\n#]+)`))?.[2]?.trim().replace(/^"|"$/g, '') || '';
+}
+function topLevelKey(text, key) {
+    const top = text.split(/\n\s*\[/)[0] || '';
+    return new RegExp(`(^|\\n)\\s*${escapeRegExp(key)}\\s*=`).test(top);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=codex-lb-fast-ui-preservation-check.js.map

package/dist/scripts/codex-lb-gpt55-fast-profile-check.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { codexFastModeDesktopStatus, codexLbConfigPath, configureCodexLb, ensureGlobalCodexFastModeDuringInstall, releaseCodexLbAuthHold, repairCodexLbAuth } from '../cli/install-helpers.js';
+import { repairCodexConfigStructure, splitCodexProjectConfigPolicy } from '../core/codex/codex-project-config-policy.js';
+import { parseCodexConfigToml, validateCodexConfigRoundTrip } from '../core/codex/codex-config-toml.js';
+const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-lb-gpt55-fast-'));
+const home = path.join(tmp, 'home');
+const root = path.join(tmp, 'project');
+const codexHome = path.join(home, '.codex');
+const configPath = codexLbConfigPath(home);
+const envPath = path.join(codexHome, 'sks-codex-lb.env');
+const authPath = path.join(codexHome, 'auth.json');
+const oauthBackupPath = path.join(codexHome, 'auth.chatgpt-backup.json');
+const projectConfig = path.join(root, '.codex', 'config.toml');
+await fs.mkdir(path.dirname(projectConfig), { recursive: true });
+await fs.mkdir(codexHome, { recursive: true });
+await fs.writeFile(authPath, `${JSON.stringify({ auth_mode: 'chatgpt', tokens: { access_token: 'oauth-access' } }, null, 2)}\n`);
+const setup = await configureCodexLb({
+    home,
+    configPath,
+    envPath,
+    host: 'https://lb.example.test/backend-api/codex',
+    apiKey: 'sk-codex-lb-fast-fixture',
+    writeEnvFile: true,
+    useDefaultProvider: true,
+    forceFastMode: true,
+    forceCodexLbApiKeyAuth: true,
+    authMode: 'codex-lb',
+    shellProfile: 'skip'
+});
+const fastOn = await ensureGlobalCodexFastModeDuringInstall({ home, configPath, forceFastMode: true });
+const first = assertFastProfile(await fs.readFile(configPath, 'utf8'), 'setup_fast_on');
+const release = await releaseCodexLbAuthHold({ home, configPath, authPath, backupPath: oauthBackupPath });
+const afterOauth = assertFastProfile(await fs.readFile(configPath, 'utf8'), 'use_oauth_roundtrip');
+const repair = await repairCodexLbAuth({ home, configPath, envPath, forceCodexLbApiKeyAuth: true, forceFastMode: true, authMode: 'codex-lb' });
+await fs.writeFile(projectConfig, [
+    'default_profile = "sks-fast-high"',
+    'service_tier = "fast"',
+    '',
+    '[user.fast_mode]',
+    'visible = true',
+    'enabled = true',
+    '',
+    '[profiles.sks-fast-high]',
+    'model = "gpt-5.5"',
+    'service_tier = "fast"',
+    ''
+].join('\n'));
+const split = await splitCodexProjectConfigPolicy(root, { apply: true, codexHome, configPath: projectConfig, writeReport: false });
+const structure = await repairCodexConfigStructure(configPath, { apply: true });
+const final = assertFastProfile(await fs.readFile(configPath, 'utf8'), 'after_rewriters');
+const ok = setup.ok !== false
+    && !['failed', 'skipped_unsafe_rewrite', 'unparseable_config_preserved'].includes(String(fastOn.status))
+    && release.status !== 'failed'
+    && repair.ok !== false
+    && split.ok === true
+    && structure.ok === true
+    && first.ok
+    && afterOauth.ok
+    && final.ok;
+const report = {
+    schema: 'sks.codex-lb-gpt55-fast-profile-check.v1',
+    ok,
+    setup_status: setup.status,
+    fast_on_status: fastOn.status,
+    release_status: release.status,
+    repair_status: repair.status,
+    split_status: split.status || null,
+    structure_status: structure.status,
+    assertions: [first, afterOauth, final],
+    blockers: [first, afterOauth, final].flatMap((item) => item.blockers)
+};
+console.log(JSON.stringify(report, null, 2));
+if (!report.ok)
+    process.exitCode = 1;
+function assertFastProfile(text, label) {
+    const validation = validateCodexConfigRoundTrip(text);
+    const parsed = validation.ok ? parseCodexConfigToml(text) : {};
+    const profile = parsed.profiles?.['sks-fast-high'] || {};
+    const provider = parsed.model_providers?.['codex-lb'] || {};
+    const desktop = codexFastModeDesktopStatus(text);
+    const blockers = [
+        ...validation.blockers,
+        ...(parsed.default_profile === 'sks-fast-high' ? [] : ['default_profile_not_sks_fast_high']),
+        ...(parsed.user?.fast_mode?.default_profile === undefined ? [] : ['default_profile_inside_user_fast_mode']),
+        ...(profile.model === 'gpt-5.5' ? [] : ['sks_fast_high_model_not_gpt55']),
+        ...(profile.service_tier === 'fast' ? [] : ['sks_fast_high_service_tier_not_fast']),
+        ...(provider.requires_openai_auth === true ? [] : ['codex_lb_requires_openai_auth_not_true']),
+        ...(provider.wire_api === 'responses' ? [] : ['codex_lb_wire_api_not_responses']),
+        ...(desktop.on ? [] : ['desktop_fast_status_off'])
+    ];
+    return {
+        label,
+        ok: blockers.length === 0,
+        default_profile: parsed.default_profile || null,
+        profile_model: profile.model || null,
+        profile_service_tier: profile.service_tier || null,
+        provider_wire_api: provider.wire_api || null,
+        provider_requires_openai_auth: provider.requires_openai_auth ?? null,
+        blockers
+    };
+}
+//# sourceMappingURL=codex-lb-gpt55-fast-profile-check.js.map

package/dist/scripts/codex-lb-missing-env-regression.js

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 // @ts-nocheck
 import fs from 'node:fs/promises';
-import os from 'node:os';
 import path from 'node:path';
-import { runProcess } from '../core/fsx.js';
+import { runProcess, tmpdir } from '../core/fsx.js';
 const rawPattern = new RegExp(['Missing environment variable:', '\\s*`?CODEX_LB_API_KEY`?'].join(''), 'i');
-const home = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-codex-lb-missing-env-'));
+const home = tmpdir('sks-codex-lb-missing-env-');
 const entry = path.resolve('dist/bin/sks.js');
 const scenarios = [
     ['status', ['codex-lb', 'status', '--json']],

package/dist/scripts/codex-project-config-policy-merge-regression.js

@@ -6,9 +6,9 @@
 //     trailing table (the `invalid type: sequence, expected a string` corruption).
 //  2. Splitting the global CODEX_HOME config against itself must be a no-op.
 import fs from 'node:fs/promises';
-import os from 'node:os';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
+import { tmpdir } from '../core/fsx.js';
 import { ensureDistFresh, root as repoRoot } from './lib/ensure-dist-fresh.js';
 const freshness = ensureDistFresh({ rebuild: true });
 if (!freshness.ok)
@@ -17,7 +17,7 @@ const mod = await import(pathToFileURL(path.join(repoRoot, 'dist', 'core', 'code
 const results = [];
 // --- Case 1: trailing table in user config must not capture moved top-level keys ---
 {
-    const fixture = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-config-merge-'));
+    const fixture = tmpdir('sks-config-merge-');
     const codexHome = path.join(fixture, 'home', '.codex');
     await fs.mkdir(codexHome, { recursive: true });
     // Pre-existing user config whose last block is an env table requiring string values.
@@ -56,7 +56,7 @@ const results = [];
 }
 // --- Case 2: splitting CODEX_HOME config against itself is a no-op ---
 {
-    const fixture = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-config-home-'));
+    const fixture = tmpdir('sks-config-home-');
     const codexHome = path.join(fixture, '.codex');
     await fs.mkdir(codexHome, { recursive: true });
     const homeConfig = path.join(codexHome, 'config.toml');

package/dist/scripts/coding-bench-check.js

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureDir, nowIso, readJson, runProcess, writeJsonAtomic } from '../core/fsx.js';
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const tasksRoot = path.join(root, 'bench', 'tasks');
+const reportPath = path.join(root, '.sneakoscope', 'reports', 'bench-report.json');
+const baselinePath = path.join(root, 'config', 'bench-baseline.json');
+const baseline = await readJson(baselinePath, { schema: 'sks.coding-bench-baseline.v1', pass_rate: 0, min_pass_rate: 0 });
+const tasks = await loadTasks();
+const backend = backendAvailable();
+const perTask = [];
+for (const task of tasks) {
+    if (!backend.ok) {
+        perTask.push({
+            id: task.id,
+            kind: task.kind,
+            ok: true,
+            status: 'skipped',
+            skipped_reason: backend.reason
+        });
+        continue;
+    }
+    perTask.push(await runTask(task));
+}
+const executed = perTask.filter((task) => task.status !== 'skipped');
+const pass = executed.filter((task) => task.ok).length;
+const fail = executed.filter((task) => !task.ok).length;
+const skipped = perTask.length - executed.length;
+const passRate = executed.length ? pass / executed.length : 0;
+const baselineRate = Number(baseline.pass_rate ?? baseline.min_pass_rate ?? 0);
+const ok = fail === 0 && passRate >= baselineRate;
+const report = {
+    schema: 'sks.coding-bench-report.v1',
+    generated_at: nowIso(),
+    ok,
+    pass,
+    fail,
+    skipped,
+    total: perTask.length,
+    pass_rate: passRate,
+    baseline: {
+        path: path.relative(root, baselinePath),
+        pass_rate: baselineRate,
+        baseline_version: baseline.baseline_version || null
+    },
+    backend,
+    per_task: perTask
+};
+await ensureDir(path.dirname(reportPath));
+await writeJsonAtomic(reportPath, report);
+console.log(JSON.stringify(report, null, 2));
+if (!ok)
+    process.exit(1);
+async function loadTasks() {
+    const dirs = (await fs.readdir(tasksRoot, { withFileTypes: true }).catch(() => []))
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort();
+    const rows = [];
+    for (const dir of dirs) {
+        const taskPath = path.join(tasksRoot, dir, 'task.json');
+        const task = await readJson(taskPath, null);
+        if (task?.schema === 'sks.bench-task.v1')
+            rows.push({ ...task, dir, task_path: taskPath, repo_path: path.join(tasksRoot, dir, 'repo') });
+    }
+    return rows;
+}
+function backendAvailable() {
+    if (process.env.SKS_RUN_CODING_BENCH_REAL !== '1')
+        return { ok: false, reason: 'no_backend' };
+    if (process.env.OPENAI_API_KEY || process.env.SKS_CODEX_LB_READY === '1' || process.env.SKS_CODING_BENCH_ALLOW_NO_KEY === '1')
+        return { ok: true, reason: null };
+    return { ok: false, reason: 'no_backend' };
+}
+async function runTask(task) {
+    const scratch = await fs.mkdtemp(path.join(os.tmpdir(), `sks-coding-bench-${task.id}-`));
+    await fs.cp(task.repo_path, scratch, { recursive: true });
+    await initGit(scratch);
+    const sks = path.join(root, 'dist', 'bin', 'sks.js');
+    const run = await runProcess(process.execPath, [sks, 'naruto', 'run', task.prompt, '--json', '--no-open-zellij', '--apply-patches', '--tournament', task.kind === 'refactor' ? '3' : '0'], {
+        cwd: scratch,
+        timeoutMs: 10 * 60_000,
+        maxOutputBytes: 512 * 1024,
+        env: { ...process.env, SKS_CODING_BENCH_TASK_ID: task.id }
+    });
+    const grade = await gradeTask(task, scratch);
+    return {
+        id: task.id,
+        kind: task.kind,
+        ok: run.code === 0 && grade.ok,
+        status: run.code === 0 && grade.ok ? 'passed' : 'failed',
+        command_exit: run.code,
+        grade,
+        scratch
+    };
+}
+async function initGit(cwd) {
+    await runProcess('git', ['init'], { cwd, timeoutMs: 15_000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+    await runProcess('git', ['config', 'user.email', 'bench@sneakoscope.local'], { cwd, timeoutMs: 15_000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+    await runProcess('git', ['config', 'user.name', 'Sneakoscope Bench'], { cwd, timeoutMs: 15_000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+    await runProcess('git', ['add', '.'], { cwd, timeoutMs: 15_000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+    await runProcess('git', ['commit', '-m', 'bench baseline'], { cwd, timeoutMs: 15_000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+}
+async function gradeTask(task, cwd) {
+    const success = task.success || {};
+    const test = success.command ? await runProcess('sh', ['-lc', String(success.command)], { cwd, timeoutMs: 120_000, maxOutputBytes: 256 * 1024 }) : { code: 0, stdout: '', stderr: '' };
+    const diff = await runProcess('git', ['diff', '--numstat', 'HEAD'], { cwd, timeoutMs: 15_000, maxOutputBytes: 128 * 1024 }).catch(() => ({ stdout: '' }));
+    const changed = await runProcess('git', ['diff', '--name-only', 'HEAD'], { cwd, timeoutMs: 15_000, maxOutputBytes: 128 * 1024 }).catch(() => ({ stdout: '' }));
+    const patch = await runProcess('git', ['diff', 'HEAD'], { cwd, timeoutMs: 15_000, maxOutputBytes: 512 * 1024 }).catch(() => ({ stdout: '' }));
+    const diffLines = String(diff.stdout || '').split(/\r?\n/).filter(Boolean).reduce((sum, line) => {
+        const parts = line.split(/\s+/).map((value) => Number(value));
+        const added = parts[0] ?? 0;
+        const removed = parts[1] ?? 0;
+        return sum + (Number.isFinite(added) ? added : 0) + (Number.isFinite(removed) ? removed : 0);
+    }, 0);
+    const changedFiles = String(changed.stdout || '').split(/\r?\n/).filter(Boolean);
+    const forbidden = (success.forbidden_patterns || []).filter((pattern) => new RegExp(pattern, 'm').test(String(patch.stdout || '')));
+    const missingNewTest = success.must_contain_new_test === true && !changedFiles.some((file) => /\.(test|spec)\.[cm]?[jt]s$|test\.[cm]?js$|__tests__\//.test(file));
+    const tooLarge = Number(success.max_diff_lines || Infinity) < diffLines;
+    const ok = (success.must_pass !== true || test.code === 0) && !missingNewTest && !tooLarge && forbidden.length === 0;
+    return {
+        ok,
+        test_exit: test.code,
+        diff_lines: diffLines,
+        changed_files: changedFiles,
+        forbidden_patterns: forbidden,
+        missing_new_test: missingNewTest,
+        max_diff_lines_exceeded: tooLarge,
+        stdout_tail: String(test.stdout || '').slice(-4000),
+        stderr_tail: String(test.stderr || '').slice(-4000)
+    };
+}
+//# sourceMappingURL=coding-bench-check.js.map