sneakoscope 6.0.0 → 6.0.2

package/dist/core/naruto/naruto-concurrency-governor.js

@@ -2,7 +2,7 @@ import { probeHardwareCapacity } from './hardware-capacity-probe.js';
 import { applyNarutoBackpressure } from './naruto-backpressure.js';
 import { monitorNarutoResourcePressure } from './resource-pressure-monitor.js';
 export function decideNarutoConcurrency(input = {}) {
-    const requestedClones = normalizePositiveInt(input.requestedClones, 12);
+    const requestedClones = normalizePositiveInt(input.requestedClones, 8);
     const totalWorkItems = normalizePositiveInt(input.totalWorkItems, requestedClones);
     const pending = normalizeNonNegativeInt(input.pendingWorkQueueSize, totalWorkItems);
     const leaseConflicts = normalizeNonNegativeInt(input.activeLeaseConflicts, 0);
@@ -12,34 +12,37 @@ export function decideNarutoConcurrency(input = {}) {
     const parallelismMode = normalizeParallelismMode(input.parallelismMode);
     const freeGb = hardware.free_memory_bytes / (1024 * 1024 * 1024);
     const totalGb = hardware.total_memory_bytes / (1024 * 1024 * 1024);
-    const reclaimableFloorGb = totalGb >= 32 ? 16 : totalGb >= 16 ? 8 : totalGb >= 8 ? 4 : Math.max(1, freeGb);
-    const memoryBudgetGb = Math.max(freeGb, reclaimableFloorGb);
+    const reservedInteractiveGb = Math.max(2, totalGb * 0.2);
+    const memoryBudgetGb = Math.max(0.5, freeGb - reservedInteractiveGb);
     const heavy = backend === 'codex-sdk' || backend === 'zellij' || backend === 'process' || backend === 'ollama';
-    const gbPerWorker = heavy ? Number(process.env.SKS_NARUTO_GB_PER_WORKER || 0.25) : Number(process.env.SKS_NARUTO_LIGHT_GB_PER_WORKER || 0.1);
-    const memoryCap = Math.max(1, Math.floor(memoryBudgetGb / Math.max(0.05, gbPerWorker)));
+    const gbPerWorker = heavy ? Number(process.env.SKS_NARUTO_GB_PER_WORKER || 1.5) : Number(process.env.SKS_NARUTO_LIGHT_GB_PER_WORKER || 0.5);
+    const memoryCap = Math.max(1, Math.floor(memoryBudgetGb / Math.max(0.25, gbPerWorker)));
     const fdCap = Math.max(1, Math.floor((hardware.file_descriptor_limit - hardware.process_count) / 6));
-    const cpuCap = Math.max(1, hardware.cpu_core_count * (heavy ? 2 : 4));
-    const ioCap = Math.max(2, Math.floor(hardware.cpu_core_count / 2));
-    const processCap = Math.max(1, Number(process.env.SKS_NARUTO_HEADLESS_PROCESS_CAP || cpuCap + ioCap));
+    const cpuCap = Math.max(1, Math.min(4, Math.floor(hardware.cpu_core_count * (heavy ? 0.4 : 0.5))));
+    const ioCap = Math.max(1, Math.min(2, Math.floor(hardware.cpu_core_count / 4)));
+    const configuredProcessCap = Math.max(1, Number(process.env.SKS_NARUTO_HEADLESS_PROCESS_CAP || 4));
+    const processCap = Math.min(configuredProcessCap, cpuCap, 4);
     const gitWorktreeCap = Math.max(1, Number(process.env.SKS_NARUTO_GIT_WORKTREE_CAP || Math.min(requestedClones, processCap)));
     const localLlmParallel = Math.max(1, Math.min(4, hardware.local_llm_max_parallel_requests));
     const remoteCodexParallel = Math.max(1, Math.min(hardware.remote_api_rate_limit_budget, requestedClones));
     const backendBudget = backend === 'ollama' || backend === 'local-llm'
         ? localLlmParallel
         : backend === 'codex-sdk' || backend === 'zellij'
-            ? Math.max(remoteCodexParallel, Math.min(requestedClones, processCap))
+            ? Math.min(remoteCodexParallel, processCap)
             : processCap;
     const queueCap = Math.max(1, Math.min(requestedClones, pending || totalWorkItems));
     const leaseCap = Math.max(1, requestedClones - leaseConflicts);
-    const rawSafe = Math.max(1, Math.min(requestedClones, totalWorkItems, memoryCap, fdCap, cpuCap + ioCap, gitWorktreeCap + processCap, backendBudget, queueCap, leaseCap, 100));
+    const rawSafe = Math.max(1, Math.min(requestedClones, totalWorkItems, memoryCap, fdCap, cpuCap, ioCap + 1, gitWorktreeCap, processCap, backendBudget, queueCap, leaseCap, 4));
     const pressure = monitorNarutoResourcePressure(hardware, { activeWorkers: rawSafe, zellijVisiblePaneCap });
     const backpressure = applyNarutoBackpressure(rawSafe, pressure);
     const currentSafeActiveWorkers = Math.max(1, Math.min(rawSafe, backpressure.adjusted_active_workers));
-    const safeActiveWorkers = parallelismMode === 'extreme'
-        ? rawSafe
+    // Every mode respects live backpressure. Modes only lower the bounded cap.
+    const modeCap = parallelismMode === 'safe'
+        ? Math.max(1, Math.ceil(rawSafe * 0.5))
         : parallelismMode === 'balanced'
-            ? Math.max(1, Math.min(rawSafe, Math.max(16, Math.floor(rawSafe * 0.75))))
-            : currentSafeActiveWorkers;
+            ? Math.max(1, Math.ceil(rawSafe * 0.75))
+            : rawSafe;
+    const safeActiveWorkers = Math.max(1, Math.min(modeCap, currentSafeActiveWorkers));
     const safeVisible = Math.min(safeActiveWorkers, zellijVisiblePaneCap);
     const reasons = [
         ...(memoryCap < requestedClones ? ['memory_cap'] : []),
@@ -65,7 +68,7 @@ export function decideNarutoConcurrency(input = {}) {
         process_parallel: processCap,
         git_worktree_parallel: gitWorktreeCap,
         cpu_io_parallel: cpuCap + ioCap,
-        verification_parallel: Math.max(1, Math.min(hardware.cpu_core_count * 2, safeActiveWorkers, 16)),
+        verification_parallel: Math.max(1, Math.min(2, safeActiveWorkers)),
         parallelism_mode: parallelismMode,
         reasons: [...new Set(reasons)],
         backpressure: backpressure.backpressure,
@@ -73,10 +76,10 @@ export function decideNarutoConcurrency(input = {}) {
     };
 }
 function normalizeParallelismMode(value) {
-    const text = String(value || process.env.SKS_NARUTO_PARALLELISM || 'extreme').toLowerCase();
+    const text = String(value || process.env.SKS_NARUTO_PARALLELISM || 'safe').toLowerCase();
     if (text === 'safe' || text === 'balanced' || text === 'extreme')
         return text;
-    return 'extreme';
+    return 'safe';
 }
 function normalizePositiveInt(value, fallback) {
     const parsed = Number(value);

package/dist/core/naruto/naruto-loop-mesh.js

@@ -27,10 +27,10 @@ export async function runNarutoLoopMesh(input) {
     });
 }
 export function splitActiveWorkerBudget(plan, parallelism) {
-    const cap = parallelism === 'safe' ? 8 : parallelism === 'extreme' ? 32 : 16;
-    const integrationReserved = 2;
+    const cap = parallelism === 'safe' ? 2 : parallelism === 'extreme' ? 4 : 3;
+    const integrationReserved = 1;
     const nonIntegration = plan.graph.nodes.filter((node) => node.route !== '$Integration');
-    const perLoopCap = Math.max(2, Math.floor((cap - integrationReserved) / Math.max(1, nonIntegration.length)));
+    const perLoopCap = Math.max(1, Math.floor((cap - integrationReserved) / Math.max(1, nonIntegration.length)));
     const perLoop = nonIntegration.map((node) => ({
         loop_id: node.loop_id,
         maker_checker_workers: Math.min(perLoopCap, node.maker.worker_count + node.checker.worker_count)

package/dist/core/naruto/resource-pressure-monitor.js

@@ -8,13 +8,16 @@ export function monitorNarutoResourcePressure(probe, input = {}) {
     const fdPressure = Math.min(1, (activeWorkers * 6 + probe.process_count) / Math.max(1, probe.file_descriptor_limit));
     const zellijPressure = Math.min(1, probe.zellij_pane_count / zellijCap);
     const diskIoPressure = Number(probe.disk_io_pressure || 0);
-    const sample = movingAveragePressure({
+    const current = {
         memory: memoryPressure,
         cpu: cpuPressure,
         fd: fdPressure,
         zellij: zellijPressure,
         disk: diskIoPressure
-    });
+    };
+    const average = movingAveragePressure(current);
+    const pressureKeys = Object.keys(current);
+    const sample = Object.fromEntries(pressureKeys.map((key) => [key, Math.max(current[key] || 0, average[key] || 0)]));
     const entries = Object.entries(sample).sort((a, b) => b[1] - a[1]);
     const [dominantMetric = 'unknown', dominantPressure = 0] = entries[0] || [];
     const reasons = entries

package/dist/core/provider/model-router.js

@@ -1,37 +1,16 @@
-import { REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
-const CHAINS = {
-    quick: [
-        { model: 'gpt-5.4-mini', reasoning: 'low', serviceTier: 'fast' },
-        { model: REQUIRED_CODEX_MODEL, reasoning: 'low', serviceTier: 'fast' }
-    ],
-    standard: [
-        { model: REQUIRED_CODEX_MODEL, reasoning: 'medium', serviceTier: 'fast' }
-    ],
-    agentic: [
-        { model: 'gpt-5.3-codex', reasoning: 'high', serviceTier: 'fast' },
-        { model: REQUIRED_CODEX_MODEL, reasoning: 'high', serviceTier: 'fast' }
-    ],
-    ultrabrain: [
-        { model: REQUIRED_CODEX_MODEL, reasoning: 'xhigh', serviceTier: 'standard' }
-    ],
-    verify: [
-        { model: 'gpt-5.4-mini', reasoning: 'medium', serviceTier: 'fast' }
-    ],
-    review: [
-        { model: REQUIRED_CODEX_MODEL, reasoning: 'high', serviceTier: 'fast' }
-    ]
+const CATEGORY_POLICY = {
+    quick: { reasoning: 'low', serviceTier: 'fast' },
+    standard: { reasoning: 'medium', serviceTier: 'fast' },
+    agentic: { reasoning: 'high', serviceTier: 'fast' },
+    ultrabrain: { reasoning: 'xhigh', serviceTier: 'standard' },
+    verify: { reasoning: 'medium', serviceTier: 'fast' },
+    review: { reasoning: 'high', serviceTier: 'fast' }
 };
 export async function routeModel(category, opts = {}) {
-    const chain = CHAINS[category] || CHAINS.standard;
-    const degraded = new Set((opts.lbHealth?.degraded_models || []).map((model) => String(model)));
-    for (const choice of chain) {
-        if (degraded.has(choice.model))
-            continue;
-        if (opts.lbHealth?.quota_low && choice.reasoning === 'xhigh')
-            return { ...choice, reasoning: 'high' };
-        return choice;
-    }
-    return chain[chain.length - 1] ?? CHAINS.standard[0];
+    const policy = CATEGORY_POLICY[category] || CATEGORY_POLICY.standard;
+    const model = String(opts.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || '').trim();
+    const reasoning = opts.lbHealth?.quota_low && policy.reasoning === 'xhigh' ? 'high' : policy.reasoning;
+    return { model, reasoning, serviceTier: policy.serviceTier };
 }
 export function categoryForWorkerRole(role) {
     const text = String(role || '').toLowerCase();
@@ -46,9 +25,10 @@ export function categoryForWorkerRole(role) {
     return 'agentic';
 }
 export function modelRouteReason(category, choice, opts = {}) {
+    const model = choice.model || 'codex-selected';
     if (opts.explicit)
-        return `${category}->${choice.model} (explicit env override)`;
-    const suffix = opts.quotaLow ? 'quota discipline' : opts.degraded?.length ? 'lb degraded fallback' : 'quota discipline';
-    return `${category}->${choice.model} (${suffix})`;
+        return `${category}->${model} (explicit model preserved)`;
+    const suffix = opts.quotaLow ? 'quota discipline' : 'Codex catalog passthrough';
+    return `${category}->${model} (${suffix})`;
 }
 //# sourceMappingURL=model-router.js.map

package/dist/core/release/release-gate-batch-runner.js

@@ -13,7 +13,8 @@ export function isReleaseGateBatchable(gate) {
     return gate.resource.every((resource) => resource === 'cpu-light' || resource === 'fs-read') && !gate.resource.some((resource) => DISALLOWED_BATCH_RESOURCES.has(resource));
 }
 export async function runReleaseGateBatch(root, gates, input = {}) {
-    const concurrency = Math.max(1, Math.floor(Number(input.concurrency || process.env.SKS_RELEASE_BATCH_CONCURRENCY || 4)));
+    const requestedConcurrency = Math.max(1, Math.floor(Number(input.concurrency || process.env.SKS_RELEASE_BATCH_CONCURRENCY || 2)));
+    const concurrency = Math.min(requestedConcurrency, 4);
     const runId = `rgb-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}`;
     const reportRoot = input.reportRoot || path.join(root, '.sneakoscope', 'reports', 'release-gate-batches', runId);
     const nonBatchable = gates.filter((gate) => !isReleaseGateBatchable(gate));

package/dist/core/release/release-gate-resource-governor.js

@@ -3,23 +3,23 @@ const EXCLUSIVE_RESOURCES = new Set(['timing-sensitive']);
 export function defaultReleaseGateBudget() {
     const cores = Math.max(1, os.cpus().length || 1);
     const base = {
-        'cpu-light': Math.min(24, cores * 3),
-        'cpu-heavy': Math.max(1, cores),
-        'io-light': Math.min(96, cores * 10),
-        'io-heavy': Math.min(12, Math.max(1, cores)),
-        git: Math.min(12, Math.max(1, cores)),
-        'git-worktree': Math.min(8, Math.max(1, cores)),
-        python: Math.min(12, Math.max(1, cores)),
-        network: 12,
+        'cpu-light': Math.max(1, Math.min(4, Math.floor(cores / 2))),
+        'cpu-heavy': Math.max(1, Math.min(2, Math.floor(cores / 4))),
+        'io-light': 4,
+        'io-heavy': 2,
+        git: 2,
+        'git-worktree': 1,
+        python: 2,
+        network: 2,
         'zellij-real': 1,
         'browser-real': 1,
         'secret-sensitive': 1,
         'local-llm-real': Math.max(1, Number(process.env.SKS_LOCAL_LLM_MAX_PARALLEL || 1)),
-        'remote-model-real': 6,
+        'remote-model-real': 2,
         'global-config': 1,
         publish: 1,
-        'fs-read': Math.min(96, cores * 10),
-        'fs-write': Math.min(12, Math.max(1, cores)),
+        'fs-read': 4,
+        'fs-write': 2,
         'timing-sensitive': 1
     };
     for (const key of Object.keys(base)) {
@@ -64,7 +64,7 @@ export function pickLaunchableReleaseGates(input) {
 }
 export function defaultReleaseGateMaxTotal() {
     const cores = Math.max(1, os.cpus().length || 1);
-    return Math.max(8, Math.min(32, cores * 3));
+    return Math.max(1, Math.min(4, Math.floor(cores / 2)));
 }
 function envInt(name, fallback, opts = {}) {
     const parsed = Number(process.env[name]);

package/dist/core/release/resource-class-budget.js

@@ -4,11 +4,11 @@ export function computeResourceClassBudget(env = process.env) {
     const cpus = Math.max(2, os.cpus().length || 2);
     return {
         schema: RESOURCE_CLASS_BUDGET_SCHEMA,
-        cpu_light: readEnvInt(env, 'SKS_RESOURCE_CPU_LIGHT', Math.max(2, cpus - 1)),
-        cpu_heavy: readEnvInt(env, 'SKS_RESOURCE_CPU_HEAVY', Math.max(1, Math.floor(cpus / 2))),
-        io_light: readEnvInt(env, 'SKS_RESOURCE_IO_LIGHT', 8),
+        cpu_light: readEnvInt(env, 'SKS_RESOURCE_CPU_LIGHT', Math.max(1, Math.min(4, Math.floor(cpus / 2)))),
+        cpu_heavy: readEnvInt(env, 'SKS_RESOURCE_CPU_HEAVY', Math.max(1, Math.min(2, Math.floor(cpus / 4)))),
+        io_light: readEnvInt(env, 'SKS_RESOURCE_IO_LIGHT', 4),
         io_heavy: readEnvInt(env, 'SKS_RESOURCE_IO_HEAVY', 2),
-        fs_read: readEnvInt(env, 'SKS_RESOURCE_FS_READ', 8),
+        fs_read: readEnvInt(env, 'SKS_RESOURCE_FS_READ', 4),
         network: readEnvInt(env, 'SKS_RESOURCE_NETWORK', 2),
         remote_model_real: readEnvInt(env, 'SKS_RESOURCE_REMOTE_MODEL_REAL', 1),
         zellij_real: readEnvInt(env, 'SKS_RESOURCE_ZELLIJ_REAL', 1),
@@ -18,6 +18,6 @@ export function computeResourceClassBudget(env = process.env) {
 }
 function readEnvInt(env, key, fallback) {
     const value = Number(env[key]);
-    return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+    return Number.isFinite(value) && value > 0 ? Math.min(Math.floor(value), fallback) : fallback;
 }
 //# sourceMappingURL=resource-class-budget.js.map

package/dist/core/routes/constants.js

@@ -44,9 +44,8 @@ export const RECOMMENDED_SKILLS = [
     REFLECTION_SKILL_NAME,
     'honest-mode'
 ];
-// 'ultra' is gpt-5.6's top reasoning level (codex-lb v1.20.1-r3 exposes the
-// 5.6 trio with a 6-level low~ultra range). Whether a given model actually
-// advertises it still comes from runtime metadata (codex-model-metadata.ts);
-// this set only gates what values SKS accepts as user/route input.
+// Route-level effort names are scheduling intents, not model compatibility
+// claims. Actual per-model options come from Codex runtime metadata; SKS never
+// derives them from a model slug.
 export const ALLOWED_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'ultra']);
 //# sourceMappingURL=constants.js.map

package/dist/core/routes.js

@@ -296,7 +296,7 @@ export const ROUTES = [
         reasoningPolicy: 'high',
         stopGate: 'release-readiness-report.json',
         cliEntrypoint: 'sks agent run "release audit" --route "$Release-Review" --agents <n> --concurrency <n> --mock --json',
-        examples: ['$Release-Review agents:10 concurrency:5 release audit', 'sks agent run "wide release audit" --route "$Release-Review" --agents 10 --concurrency 5 --mock --json']
+        examples: ['$Release-Review agents:10 concurrency:4 release audit', 'sks agent run "wide release audit" --route "$Release-Review" --agents 10 --concurrency 4 --mock --json']
     },
     {
         id: 'QALoop',

package/dist/core/structured-output-adapter.js

@@ -29,9 +29,23 @@ export function ensureStrictObjectSchema(schema) {
     return next;
 }
 export async function runOpenAIStructuredOutput(request) {
-    const model = request.model || process.env.OPENAI_STRUCTURED_OUTPUT_MODEL || 'gpt-5.4-mini';
+    const model = String(request.model || process.env.OPENAI_STRUCTURED_OUTPUT_MODEL || '').trim();
     const apiKey = request.apiKey || process.env.OPENAI_API_KEY || null;
     const sourceSha = request.imagePath ? sha256(await fsp.readFile(path.resolve(request.imagePath))) : null;
+    if (!model) {
+        return {
+            schema: 'sks.structured-output-adapter-result.v1',
+            ok: false,
+            status: 'integration_optional',
+            provider: 'openai_responses_text_format',
+            model: '',
+            parsed_json: null,
+            validation: { ok: false, issues: ['openai_structured_output_model_missing'] },
+            blocker: structuredOutputBlocker('openai_structured_output_model_missing', 'Pass request.model or set OPENAI_STRUCTURED_OUTPUT_MODEL; SKS does not invent a model identifier.'),
+            setup_guidance: 'Choose any model available to your OpenAI account and pass it explicitly, or use Codex structured output so the current Codex selection is inherited.',
+            source_sha256: sourceSha
+        };
+    }
     if (!apiKey) {
         return {
             schema: 'sks.structured-output-adapter-result.v1',

package/dist/core/update/update-migration-state.js

@@ -8,7 +8,6 @@ import { COMMANDS } from '../../cli/command-registry.js';
 import { reconcileSkills } from '../init/skills.js';
 import { codexHookTrustDoctor } from '../codex-hooks/codex-hook-trust-doctor.js';
 import { writeCodexConfigGuarded } from '../codex/codex-config-guard.js';
-import { REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
 export const UPDATE_MIGRATION_SCHEMA = 'sks.project-migration-receipt.v2';
 export const INSTALLATION_EPOCH_SCHEMA = 'sks.installation-epoch.v1';
 export function installationEpochPath() {
@@ -528,7 +527,9 @@ function tomlTableString(text, table, key) {
     return match?.[1] || null;
 }
 function topLevelTomlString(text, key) {
-    const top = String(text || '').slice(0, Math.max(0, String(text || '').search(/^\s*\[/m)));
+    const source = String(text || '');
+    const firstTable = source.search(/^\s*\[/m);
+    const top = firstTable < 0 ? source : source.slice(0, firstTable);
     const match = top.match(new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"\\s*$`, 'm'));
     return match?.[1] || null;
 }
@@ -589,20 +590,6 @@ function upsertTomlTableKeyLocal(text, table, line) {
     lines.splice(end, 0, line);
     return `${lines.join('\n')}\n`;
 }
-function upsertTopLevelTomlStringLocal(text, key, value) {
-    const raw = String(text || '').trimEnd();
-    const line = `${key} = ${JSON.stringify(value)}`;
-    const lines = raw ? raw.split(/\r?\n/) : [];
-    const firstTable = lines.findIndex((candidate) => /^\s*\[[^\]]+\]\s*$/.test(candidate || ''));
-    const end = firstTable < 0 ? lines.length : firstTable;
-    for (let index = 0; index < end; index += 1) {
-        if (new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`).test(lines[index] || '')) {
-            lines[index] = line;
-            return `${lines.join('\n')}\n`;
-        }
-    }
-    return insertTopLevelTomlKey(raw, line);
-}
 function tomlTableHasKey(text, table, key) {
     const block = tomlTableBlock(text, table);
     return Boolean(block && new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`, 'm').test(block));

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '6.0.0';
+export const PACKAGE_VERSION = '6.0.2';
 //# sourceMappingURL=version.js.map

package/dist/scripts/agent-backfill-replenishment-check.js

@@ -2,7 +2,7 @@
 // @ts-nocheck
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 import { runDynamicPoolFixture } from './agent-dynamic-pool-fixture.js';
-const fixture = await runDynamicPoolFixture({ target: 5, total: 8 });
+const fixture = await runDynamicPoolFixture({ target: 4, total: 8 });
 const backfills = fixture.events.filter((event) => event.event_type === 'backfill_event');
 const firstSlowCompletionIndex = fixture.events.findIndex((event) => event.event_type === 'session_completed' && /work-00[3-5]/.test(String(event.work_item_id || '')));
 const secondBackfillIndex = fixture.events.findIndex((event, index) => index > fixture.events.findIndex((row) => row.event_type === 'backfill_event') && event.event_type === 'backfill_event');

package/dist/scripts/agent-dynamic-pool-check.js

@@ -2,11 +2,11 @@
 // @ts-nocheck
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 import { runDynamicPoolFixture } from './agent-dynamic-pool-fixture.js';
-const fixture = await runDynamicPoolFixture({ target: 5, total: 8 });
+const fixture = await runDynamicPoolFixture({ target: 4, total: 8 });
 const state = fixture.result.state;
 assertGate(fixture.result.ok === true, 'dynamic pool fixture must drain cleanly', state);
-assertGate(state.target_active_slots === 5, 'target active slots must be 5', state);
-assertGate(state.max_observed_active_slots === 5, 'scheduler must observe 5 active slots', state);
+assertGate(state.target_active_slots === 4, 'target active slots must be desktop-safe (4)', state);
+assertGate(state.max_observed_active_slots === 4, 'scheduler must observe at most 4 active slots', state);
 assertGate(state.pending_queue_drained === true, 'pending queue must drain', state);
 assertGate(state.all_slots_closed_after_drain === true, 'all slots must close after drain', state);
 emitGate('agent:dynamic-pool', { target_active_slots: state.target_active_slots, max_observed_active_slots: state.max_observed_active_slots, total_work_items: state.total_work_items });

package/dist/scripts/agent-dynamic-pool-fixture.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { importDist } from './sks-1-18-gate-lib.js';
 export async function runDynamicPoolFixture(opts = {}) {
-    const target = opts.target || 5;
+    const target = opts.target || 4;
     const total = opts.total || 8;
     const root = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-dynamic-pool-'));
     const scheduler = await importDist('core/agents/agent-scheduler.js');

package/dist/scripts/agent-goal-mode-propagation-check.js

@@ -2,7 +2,7 @@
 // @ts-nocheck
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 import { runDynamicPoolFixture } from './agent-dynamic-pool-fixture.js';
-const fixture = await runDynamicPoolFixture({ target: 5, total: 8 });
+const fixture = await runDynamicPoolFixture({ target: 4, total: 8 });
 const allResultsHaveRefs = fixture.result.results.every((result) => result.goal_mode_ref?.artifact === 'goal-mode-applied.json');
 assertGate(allResultsHaveRefs, 'all dynamic generations must propagate Goal mode refs', fixture.result.results);
 emitGate('agent:goal-mode-propagation', { result_count: fixture.result.results.length });

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

@@ -37,8 +37,8 @@ export async function runPatchSwarmRouteBlackbox({ gate, route, routeCommand, re
         backend: 'fake',
         mock: true,
         agents: 5,
-        concurrency: 5,
-        targetActiveSlots: 5,
+        concurrency: 4,
+        targetActiveSlots: 4,
         desiredWorkItemCount: 10,
         minimumWorkItems: 10,
         writeMode: 'parallel',

package/dist/scripts/agent-role-config-repair-check.js

@@ -5,8 +5,6 @@ import os from 'node:os';
 import path from 'node:path';
 import { assertGate, emitGate, importDist } from './sks-1-18-gate-lib.js';
 const mod = await importDist('core/agents/agent-role-config.js');
-const modelGuard = await importDist('core/codex-model-guard.js');
-const requiredModel = modelGuard.REQUIRED_CODEX_MODEL;
 const root = fs.mkdtempSync(path.join(os.tmpdir(), 'sks-role-repair-'));
 fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
 const plan = await mod.repairAgentRoleConfigs({ root, apply: false, codexHome: path.join(root, 'codex-home') });
@@ -19,19 +17,25 @@ const stalePlan = await mod.repairAgentRoleConfigs({ root: staleRoot, apply: fal
 const staleRepair = await mod.repairAgentRoleConfigs({ root: staleRoot, apply: true, codexHome: path.join(staleRoot, 'codex-home') });
 const repairedText = fs.readFileSync(path.join(staleRoot, '.codex', 'agents', 'analysis-scout.toml'), 'utf8');
 const createdText = fs.readFileSync(analysisScout, 'utf8');
+const globalRole = path.join(root, 'codex-home', 'agents', 'analysis-scout.toml');
+fs.mkdirSync(path.dirname(globalRole), { recursive: true });
+fs.writeFileSync(globalRole, 'name = "analysis_scout"\ndescription = "SKS stale global role"\nmodel = "gpt-5.5"\nmodel_reasoning_effort = "low"\nsandbox_mode = "workspace-write"\ndeveloper_instructions = """\nSKS role\n"""\n');
+const globalRepair = await mod.repairAgentRoleConfigs({ root, apply: true, codexHome: path.join(root, 'codex-home') });
+const globalRepairedText = fs.readFileSync(globalRole, 'utf8');
 const report = {
     schema: 'sks.agent-role-config-repair-check.v1',
     plan_ok: plan.ok === true && plan.missing.includes('analysis-scout.toml'),
     repair_ok: repair.ok === true,
     analysis_scout_created: fs.existsSync(analysisScout),
-    created_matches_model: createdText.includes(`model = "${requiredModel}"`),
+    created_inherits_model: !/^(?:model|model_reasoning_effort)\s*=/m.test(createdText),
     created_write_capable: createdText.includes('sandbox_mode = "workspace-write"') && !createdText.includes('Do not edit files.'),
     stale_detected: stalePlan.stale.includes('analysis-scout.toml'),
-    stale_repaired: staleRepair.repaired.includes('.codex/agents/analysis-scout.toml') && repairedText.includes('name = "analysis_scout"') && repairedText.includes(`model = "${requiredModel}"`) && repairedText.includes('sandbox_mode = "workspace-write"'),
+    stale_repaired: staleRepair.repaired.includes('.codex/agents/analysis-scout.toml') && repairedText.includes('name = "analysis_scout"') && !/^(?:model|model_reasoning_effort)\s*=/m.test(repairedText) && repairedText.includes('sandbox_mode = "workspace-write"'),
+    global_stale_repaired_with_valid_project_copy: globalRepair.repaired.some((file) => file.endsWith('codex-home/agents/analysis-scout.toml')) && !/^(?:model|model_reasoning_effort)\s*=/m.test(globalRepairedText),
     warnings_suppressed: repair.warnings_suppressed === true,
     artifact_written: fs.existsSync(path.join(root, '.sneakoscope', 'reports', 'agent-role-config-repair.json'))
 };
-const ok = report.plan_ok && report.repair_ok && report.analysis_scout_created && report.created_matches_model && report.created_write_capable && report.stale_detected && report.stale_repaired && report.warnings_suppressed && report.artifact_written;
+const ok = report.plan_ok && report.repair_ok && report.analysis_scout_created && report.created_inherits_model && report.created_write_capable && report.stale_detected && report.stale_repaired && report.global_stale_repaired_with_valid_project_copy && report.warnings_suppressed && report.artifact_written;
 assertGate(ok, 'doctor --fix must repair missing SKS-owned agent role configs', report);
 emitGate('agent:role-config-repair', report);
 //# sourceMappingURL=agent-role-config-repair-check.js.map

package/dist/scripts/agent-scheduler-proof-check.js

@@ -2,7 +2,7 @@
 // @ts-nocheck
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 import { runDynamicPoolFixture } from './agent-dynamic-pool-fixture.js';
-const fixture = await runDynamicPoolFixture({ target: 5, total: 8 });
+const fixture = await runDynamicPoolFixture({ target: 4, total: 8 });
 const state = fixture.result.state;
 for (const key of ['target_active_slots', 'max_observed_active_slots', 'pending_queue_drained', 'backfill_count', 'expected_backfill_count', 'slot_count', 'generation_count']) {
     assertGate(Object.prototype.hasOwnProperty.call(state, key) || key === 'slot_count' || key === 'generation_count', `scheduler state/proof missing ${key}`, state);

package/dist/scripts/agent-scheduler-proof-hardening-check.js

@@ -15,7 +15,7 @@ for (const token of [
 ]) {
     assertGate(proofSource.includes(token), `scheduler proof hardening missing ${token}`);
 }
-const fixture = await runDynamicPoolFixture({ target: 5, total: 8 });
+const fixture = await runDynamicPoolFixture({ target: 4, total: 8 });
 assertGate(fixture.result.state.pending_queue_drained === true, 'positive scheduler fixture must drain', fixture.result.state);
 assertGate(fixture.result.state.backfill_count >= fixture.result.state.expected_backfill_count, 'positive scheduler fixture must satisfy backfill invariant', fixture.result.state);
 emitGate('agent:scheduler-proof-hardening', { checked_blockers: 8, backfill_count: fixture.result.state.backfill_count });

package/dist/scripts/agent-source-intelligence-propagation-check.js

@@ -2,7 +2,7 @@
 // @ts-nocheck
 import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
 import { runDynamicPoolFixture } from './agent-dynamic-pool-fixture.js';
-const fixture = await runDynamicPoolFixture({ target: 5, total: 8 });
+const fixture = await runDynamicPoolFixture({ target: 4, total: 8 });
 const allResultsHaveRefs = fixture.result.results.every((result) => result.source_intelligence_refs?.artifact === 'source-intelligence-evidence.json');
 assertGate(allResultsHaveRefs, 'all dynamic generations must propagate source intelligence refs', fixture.result.results);
 emitGate('agent:source-intelligence-propagation', { result_count: fixture.result.results.length });

package/dist/scripts/agent-strategy-to-lease-wiring-check.js

@@ -11,10 +11,10 @@ const tmp = makeTempPatchProject('sks-strategy-lease-');
 const files = Array.from({ length: 10 }, (_, index) => `file-${index + 1}.txt`);
 const prompt = files.map((file) => `\`${file}\``).join(' ');
 const compiled = strategy.compileStrategy({ prompt, route: '$Agent', agentCount: 5 });
-const roster = rosterMod.buildAgentRoster({ agents: 5, concurrency: 5, prompt });
+const roster = rosterMod.buildAgentRoster({ agents: 5, concurrency: 4, prompt });
 const partition = await partitionMod.buildAgentWorkPartition(tmp, roster, prompt, {
     route: '$Agent',
-    targetActiveSlots: 5,
+    targetActiveSlots: 4,
     desiredWorkItemCount: 10,
     minimumWorkItems: 10,
     strategyOwnershipPlan: compiled.file_ownership_plan,

package/dist/scripts/agent-zellij-dynamic-backfill-panes-check.js

@@ -7,7 +7,7 @@ const freshness = ensureDistFresh({ rebuild: true });
 if (!freshness.ok)
     fail('dist_not_fresh', { freshness });
 const proof = await import(pathToFileURL(path.join(root, 'dist', 'core', 'agents', 'agent-slot-pane-binding-proof.js')).href);
-const targetActiveSlots = 5;
+const targetActiveSlots = 4;
 const workItems = 10;
 const records = Array.from({ length: workItems }, (_, index) => {
     const slotIndex = (index % targetActiveSlots) + 1;

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

@@ -17,12 +17,12 @@ const clean = await evaluateCodexAppFastUiPreservation(tmp, { before, after, cod
 const badRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'sks-fast-ui-preservation-bad-'));
 await fs.mkdir(path.join(badRoot, '.codex'), { recursive: true });
 await fs.mkdir(path.join(badRoot, 'home', '.codex'), { recursive: true });
-await fs.writeFile(path.join(badRoot, '.codex', 'config.toml'), 'model_provider = "codex-lb"\n');
+await fs.writeFile(path.join(badRoot, '.codex', 'config.toml'), 'openai_base_url = "https://override.invalid"\n');
 await fs.writeFile(path.join(badRoot, 'home', '.codex', 'config.toml'), '');
 const bad = await evaluateCodexAppFastUiPreservation(badRoot, { codexHome: path.join(badRoot, 'home', '.codex') });
 const serialized = JSON.stringify({ clean, bad });
 const secretSafe = !serialized.includes('secret-should-not-leak');
-const ok = clean.ok && !bad.ok && bad.project_local_forbidden_keys.includes('model_provider') && secretSafe;
+const ok = clean.ok && !bad.ok && bad.project_local_forbidden_keys.includes('openai_base_url') && secretSafe;
 emit({ schema: 'sks.codex-app-fast-ui-preservation-check.v1', ok, clean, bad, secret_safe: secretSafe, blockers: ok ? [] : ['codex_app_fast_ui_preservation_check_failed'] });
 function emit(report) {
     console.log(JSON.stringify(report, null, 2));

package/dist/scripts/codex-app-ui-preservation-check.js

@@ -44,8 +44,8 @@ delete process.env.SKS_MANAGE_CODEX_APP_PLUGINS;
 }
 // 2) Default install must NOT auto-enable any marketplace plugins.
 {
-    const out = normalize('model = "gpt-5.5"\n');
-    results.push({ case: 'no_plugins_by_default', ok: !hasPluginTables(out) });
+    const out = normalize('model = "future-codex-model"\n');
+    results.push({ case: 'no_plugins_by_default', ok: !hasPluginTables(out) && /model = "future-codex-model"/.test(out) });
 }
 // 3) A user's disabled plugin must be left untouched (not reverted to enabled).
 {
@@ -67,16 +67,17 @@ delete process.env.SKS_MANAGE_CODEX_APP_PLUGINS;
         && featureValue(out, 'multi_agent') === 'true'
         && featureValue(out, 'fast_mode') === 'true'
         && !/\[user\.fast_mode\]/.test(out)
-        && !/\[profiles\.sks-fast-high\]/.test(out);
+        && !/\[profiles\.sks-fast-high\]/.test(out)
+        && !/^model\s*=/m.test(out);
     results.push({ case: 'fresh_config_seeds_defaults', ok });
 }
 // 6) Opt-in enables plugins on a fresh config, but still preserves a user-disabled one.
 {
     process.env.SKS_MANAGE_CODEX_APP_PLUGINS = '1';
-    const fresh = normalize('model = "gpt-5.5"\n');
+    const fresh = normalize('model = "future-codex-model"\n');
     const userDisabled = normalize('[plugins."chrome@openai-bundled"]\nenabled = false\n');
     delete process.env.SKS_MANAGE_CODEX_APP_PLUGINS;
-    const ok = hasPluginTables(fresh) && /\[plugins\."chrome@openai-bundled"\][\s\S]*enabled = false/.test(userDisabled);
+    const ok = hasPluginTables(fresh) && /model = "future-codex-model"/.test(fresh) && /\[plugins\."chrome@openai-bundled"\][\s\S]*enabled = false/.test(userDisabled);
     results.push({ case: 'optin_enables_but_preserves_user', ok });
 }
 if (prevEnv === undefined)

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

@@ -17,7 +17,7 @@ const oauthAuth = JSON.stringify({
     account_id: 'acct-fast-ui-fixture'
 }, null, 2);
 await fs.writeFile(configPath, [
-    'model = "gpt-5.5"',
+    'model = "future-codex-model"',
     'model_reasoning_effort = "low"',
     'model_provider = "codex-lb"',
     'service_tier = "fast"',
@@ -79,8 +79,8 @@ function assertConfig(text, label) {
         ...(tableKey(text, 'features', 'fast_mode_ui') ? ['features_fast_mode_ui_legacy_flag_present'] : []),
         ...(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'] : [])
+        ...(topLevelKey(text, 'model') === 'future-codex-model' ? [] : ['user_model_not_preserved']),
+        ...(topLevelKey(text, 'model_reasoning_effort') === 'low' ? [] : ['user_reasoning_effort_not_preserved'])
     ];
     return { label, ok: blockers.length === 0, blockers };
 }
@@ -97,7 +97,7 @@ function tableKey(text, table, key) {
 }
 function topLevelKey(text, key) {
     const top = text.split(/\n\s*\[/)[0] || '';
-    return new RegExp(`(^|\\n)\\s*${escapeRegExp(key)}\\s*=`).test(top);
+    return top.match(new RegExp(`(^|\\n)\\s*${escapeRegExp(key)}\\s*=\\s*([^\\n#]+)`))?.[2]?.trim().replace(/^"|"$/g, '') || '';
 }
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');