sneakoscope 6.0.0 → 6.0.2

package/dist/core/agents/agent-roster.js

@@ -3,18 +3,9 @@ import { DEFAULT_AGENT_CONCURRENCY, DEFAULT_AGENT_COUNT, DEFAULT_NARUTO_CLONES,
 import { defaultAgentPersonas, validatePersonaUniqueness } from './agent-persona.js';
 import { buildAgentEffortPolicy, decideAgentEffort, decideNarutoCloneEffort } from './agent-effort-policy.js';
 import { mapNarutoRoleToAgentRole, narutoRoleAllowsWrite } from '../naruto/naruto-role-policy.js';
-// $Naruto must never blindly spawn the full clone count at once, but the live
-// CONCURRENCY ceiling is NOT a function of CPU cores. Each clone is a separate CLI
-// worker process that spends ~all of its wall-clock awaiting the Codex API
-// (network-bound, mostly idle), so the local CPU is never the bottleneck —
-// oversubscribing cores is exactly the point. The real local limit is MEMORY
-// (resident set of N node+codex child processes) plus an absolute clone ceiling
-// (MAX_NARUTO_AGENT_COUNT = 100); the provider rate limit is handled separately by
-// the responses retry/backoff policy. So a capable host can run up to 100 in
-// parallel regardless of core count. Tunables:
-//   SKS_NARUTO_MAX_CONCURRENCY   hard cap (1..100), wins over everything
-//   SKS_NARUTO_GB_PER_WORKER     memory budget per heavy worker (default 0.25 GB)
-//   SKS_NARUTO_MIN_CONCURRENCY   floor so low-free-memory hosts still parallelize
+// The roster may contain many queued clones, but active Codex workers are real
+// Node/Codex processes. Reserve interactive CPU and memory so the desktop stays
+// responsive; environment overrides can lower this cap, never raise it.
 export function systemSafeNarutoConcurrency(opts = {}) {
     const cores = Math.max(1, Number(opts.cores ?? os.cpus()?.length) || 4);
     let freeBytes = 2 * 1024 * 1024 * 1024;
@@ -31,40 +22,28 @@ export function systemSafeNarutoConcurrency(opts = {}) {
     const totalGb = totalBytes / (1024 * 1024 * 1024);
     const backend = String(opts.backend || 'codex-sdk');
     const heavy = backend === 'codex-sdk' || backend === 'zellij' || backend === 'process' || backend === 'ollama';
-    const ceiling = MAX_NARUTO_AGENT_COUNT;
-    // macOS reports very low freemem while reclaimable memory is still available, so
-    // budget against a total-memory-derived floor rather than the instantaneous free.
-    const reclaimableFloorGb = totalGb >= 32 ? 16 : totalGb >= 16 ? 8 : totalGb >= 8 ? 4 : totalGb >= 4 ? 2 : Math.max(freeGb, 1);
-    const budgetGb = Math.max(freeGb, reclaimableFloorGb);
-    let cap;
-    if (heavy) {
-        // Memory-bound, NOT core-bound. ~0.25 GB per mostly-idle Codex SDK worker.
-        const gbPerWorker = positiveEnvNumber('SKS_NARUTO_GB_PER_WORKER', 0.25);
-        const byMem = Math.max(1, Math.floor(budgetGb / gbPerWorker));
-        const minParallelDefault = totalGb >= 16 ? 16 : totalGb >= 8 ? 8 : totalGb >= 4 ? 4 : 2;
-        const minParallel = Math.floor(positiveEnvNumber('SKS_NARUTO_MIN_CONCURRENCY', minParallelDefault));
-        cap = Math.min(Math.max(byMem, minParallel), ceiling);
-    }
-    else {
-        // In-process / light workers are even cheaper; pack toward the ceiling, and never
-        // throttle tighter than the heavy backend (invariant: heavy.cap <= fake.cap).
-        const gbPerWorker = positiveEnvNumber('SKS_NARUTO_LIGHT_GB_PER_WORKER', 0.1);
-        const byMem = Math.max(2, Math.floor(budgetGb / gbPerWorker));
-        cap = Math.min(byMem, ceiling);
-    }
+    const reserveGb = Math.max(2, totalGb * 0.2);
+    const budgetGb = Math.max(0.5, freeGb - reserveGb);
+    const gbPerWorker = positiveEnvNumber(heavy ? 'SKS_NARUTO_GB_PER_WORKER' : 'SKS_NARUTO_LIGHT_GB_PER_WORKER', heavy ? 1.5 : 0.5);
+    const byMem = Math.max(1, Math.floor(budgetGb / gbPerWorker));
+    const byCpu = Math.max(1, Math.min(4, Math.floor(cores * (heavy ? 0.4 : 0.5))));
+    const load = Math.max(0, Number(opts.loadAverage ?? os.loadavg()[0]) || 0);
+    const byLoad = load >= cores ? 1 : load >= cores * 0.75 ? Math.min(2, byCpu) : byCpu;
+    let cap = Math.min(byMem, byCpu, byLoad, 4);
     const override = Number(process.env.SKS_NARUTO_MAX_CONCURRENCY);
     if (Number.isFinite(override) && override >= 1)
-        cap = Math.min(Math.floor(override), MAX_NARUTO_AGENT_COUNT);
-    cap = Math.max(1, Math.min(cap, MAX_NARUTO_AGENT_COUNT));
+        cap = Math.min(cap, Math.floor(override));
+    cap = Math.max(1, Math.min(cap, 4));
     return {
         cap,
         cores,
         free_gb: Math.round(freeGb * 10) / 10,
         total_gb: Math.round(totalGb * 10) / 10,
+        load_average: Math.round(load * 100) / 100,
         backend,
         heavy,
         override_applied: Number.isFinite(override) && override >= 1,
-        memory_model: heavy ? 'memory_budget_network_bound' : 'light_worker_memory_bound'
+        memory_model: heavy ? 'reserved_interactive_memory_heavy_worker' : 'reserved_interactive_memory_light_worker'
     };
 }
 function positiveEnvNumber(name, fallback) {
@@ -87,12 +66,13 @@ export function normalizeAgentCount(value, fallback = DEFAULT_AGENT_COUNT, maxAg
     return count;
 }
 export function normalizeAgentConcurrency(value, agents, maxAgentCount = MAX_AGENT_COUNT) {
-    const parsed = Number(value ?? Math.min(agents, DEFAULT_AGENT_CONCURRENCY));
+    const desktopSafeCap = Math.max(1, Math.min(agents, maxAgentCount, DEFAULT_AGENT_CONCURRENCY));
+    const parsed = Number(value ?? desktopSafeCap);
     if (!Number.isFinite(parsed) || parsed < 1)
-        return Math.min(agents, DEFAULT_AGENT_CONCURRENCY);
+        return desktopSafeCap;
     if (parsed > maxAgentCount)
         throw new Error('Agent concurrency ' + parsed + ' exceeds max ' + maxAgentCount);
-    return Math.min(Math.floor(parsed), agents);
+    return Math.min(Math.floor(parsed), desktopSafeCap);
 }
 export function buildAgentRoster(opts = {}) {
     const maxAgentCount = resolveMaxAgentCount(opts.maxAgentCount);

package/dist/core/agents/agent-scheduler.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { appendJsonl, appendJsonlMany, nowIso, writeJsonAtomic } from '../fsx.js';
-import { MAX_AGENT_COUNT } from './agent-schema.js';
+import { DEFAULT_AGENT_CONCURRENCY, MAX_AGENT_COUNT } from './agent-schema.js';
 import { appendAgentWorkQueueEvent, completeWorkItem, createAgentWorkQueue, enqueueFollowUpWorkItems, leaseNextWorkItem, pendingWorkItems, writeAgentWorkQueue } from './agent-work-queue.js';
 import { closeWorkerSlotsAfterDrain, createAgentWorkerSlots, markWorkerSlotGenerationClosed, openWorkerSlotGeneration, writeAgentWorkerSlots } from './agent-worker-slot.js';
 import { closeAgentSessionGeneration, createAgentSessionGeneration, writeAgentSessionGeneration } from './agent-session-generation.js';
@@ -9,7 +9,7 @@ export const AGENT_SCHEDULER_SCHEMA = 'sks.agent-scheduler.v1';
 export const AGENT_SCHEDULER_EVENT_SCHEMA = 'sks.agent-scheduler-event.v1';
 export async function runAgentScheduler(input) {
     const maxActiveSlots = Number.isFinite(Number(input.maxActiveSlots)) && Number(input.maxActiveSlots) >= 1 ? Math.floor(Number(input.maxActiveSlots)) : MAX_AGENT_COUNT;
-    const targetActiveSlots = normalizeTargetActiveSlots(input.targetActiveSlots ?? input.roster?.agent_count ?? input.roster?.concurrency ?? 5, maxActiveSlots);
+    const targetActiveSlots = normalizeTargetActiveSlots(input.targetActiveSlots ?? input.roster?.concurrency ?? input.roster?.agent_count ?? DEFAULT_AGENT_CONCURRENCY, maxActiveSlots);
     let slots = createAgentWorkerSlots(input.roster, targetActiveSlots);
     const queue = createAgentWorkQueue({
         slices: input.partition?.slices || [],
@@ -344,10 +344,11 @@ export async function runAgentScheduler(input) {
     }
 }
 export function normalizeTargetActiveSlots(value, maxActiveSlots = MAX_AGENT_COUNT) {
-    const cap = Number.isFinite(Number(maxActiveSlots)) && Number(maxActiveSlots) >= 1 ? Math.floor(Number(maxActiveSlots)) : MAX_AGENT_COUNT;
-    const parsed = Number(value ?? 5);
+    const configuredCap = Number.isFinite(Number(maxActiveSlots)) && Number(maxActiveSlots) >= 1 ? Math.floor(Number(maxActiveSlots)) : MAX_AGENT_COUNT;
+    const cap = Math.max(1, Math.min(configuredCap, DEFAULT_AGENT_CONCURRENCY));
+    const parsed = Number(value ?? DEFAULT_AGENT_CONCURRENCY);
     if (!Number.isFinite(parsed) || parsed < 1)
-        return Math.min(cap, 5);
+        return cap;
     return Math.min(cap, Math.floor(parsed));
 }
 function buildState(missionId, targetActiveSlots, queue, slots, active, opts) {

package/dist/core/agents/agent-schema.js

@@ -8,12 +8,11 @@ export const DEFAULT_AGENT_COUNT = 5;
 export const AGENT_COUNT = DEFAULT_AGENT_COUNT;
 export const AGENT_INTAKE_STAGE_ID = 'native_agent_intake';
 export const MAX_AGENT_COUNT = 20;
-export const DEFAULT_AGENT_CONCURRENCY = 5;
-// $Naruto "Shadow Clone" swarm: a high-scale mode that lifts the standard 20-agent
-// ceiling to up to 100 concurrent clone sessions. Only the naruto path opts into this
-// cap; every other roster/scheduler caller keeps MAX_AGENT_COUNT as the default.
+export const DEFAULT_AGENT_CONCURRENCY = 4;
+// Naruto may queue a large roster, but active workers are governed separately and
+// remain bounded by live CPU, memory, load, and I/O pressure.
 export const MAX_NARUTO_AGENT_COUNT = 100;
-export const DEFAULT_NARUTO_CLONES = 32;
+export const DEFAULT_NARUTO_CLONES = 8;
 export const AGENT_BACKENDS = ['fake', 'process', 'codex-sdk', 'zellij', 'ollama', 'local-llm'];
 export function normalizeAgentBackend(input) {
     const value = String(input || 'codex-sdk');

package/dist/core/agents/agent-task-graph.js

@@ -3,7 +3,7 @@ import { nowIso, sha256, writeJsonAtomic } from '../fsx.js';
 export const AGENT_TASK_GRAPH_SCHEMA = 'sks.agent-task-graph.v1';
 export function buildAgentTaskGraph(input) {
     const routeType = normalizeRouteType(input.routeType || '$Agent');
-    const targetActiveSlots = Math.max(1, Math.floor(Number(input.targetActiveSlots || 5)));
+    const targetActiveSlots = Math.max(1, Math.min(4, Math.floor(Number(input.targetActiveSlots || 4))));
     const minimumWorkItems = Math.max(1, Math.floor(Number(input.minimumWorkItems || targetActiveSlots)));
     const desiredWorkItems = Math.max(minimumWorkItems, Math.floor(Number(input.desiredWorkItems || minimumWorkItems)));
     const domainTemplates = routeTemplates(routeType);

package/dist/core/agents/agent-work-partition.js

@@ -7,12 +7,13 @@ import { detectAgentLeaseConflicts } from './work-partition/conflict-detector.js
 import { buildNoOverlapProof } from './work-partition/no-overlap-proof.js';
 import { buildAgentTaskGraph } from './agent-task-graph.js';
 import { buildIntelligentWorkGraph, enhanceTaskGraphWithIntelligence } from './intelligent-work-graph.js';
+import { DEFAULT_AGENT_CONCURRENCY } from './agent-schema.js';
 export async function buildAgentWorkPartition(root, roster, prompt = '', opts = {}) {
     const inventory = await collectRepoInventory(root);
     const dependency_graph = buildDependencyGraph(inventory);
     const semantic_domain_graph = buildSemanticDomainGraph(inventory);
     const sessions = Object.fromEntries((roster.roster || []).map((agent) => [agent.id, agent.session_id]));
-    const targetActiveSlots = Number(opts.targetActiveSlots || roster.agent_count || roster.concurrency || 5);
+    const targetActiveSlots = Math.max(1, Math.min(DEFAULT_AGENT_CONCURRENCY, Number(opts.targetActiveSlots || roster.concurrency || roster.agent_count || DEFAULT_AGENT_CONCURRENCY)));
     const intelligent_work_graph = await buildIntelligentWorkGraph({
         root,
         inventory,

package/dist/core/agents/native-worker-backend-router.js

@@ -274,7 +274,7 @@ async function resolveWorkerModelRouting(input) {
             reasoning: explicitReasoning || normalizeModelReasoning(input.agent?.model_reasoning_effort) || 'medium',
             serviceTier: explicitTier || input.fastModePolicy.service_tier || 'fast'
         }
-        : await routeModel(category, { lbHealth });
+        : await routeModel(category, { lbHealth, model: input.agent?.model || null });
     return {
         category,
         choice: routed,

package/dist/core/agents/route-collaboration-ledger.js

@@ -38,7 +38,7 @@ export async function writeRouteCollaborationArtifacts(root, opts) {
         route: opts.route,
         prompt: opts.prompt || routeKey + ' native collaboration fixture',
         agents: opts.agents || 5,
-        concurrency: opts.concurrency || 5,
+        concurrency: opts.concurrency || 4,
         backend,
         mock: backend === 'fake',
         readonly: true
@@ -64,7 +64,7 @@ export async function writeRouteCollaborationArtifacts(root, opts) {
         fake_backend_fixture: backend === 'fake',
         real_mode_codex_sdk_backend: {
             supported: true,
-            command_pattern: 'sks agent run "<task>" --backend codex-sdk --real --agents <1-20> --concurrency <1-20> --json',
+            command_pattern: 'sks agent run "<task>" --backend codex-sdk --real --agents <1-20> --concurrency <1-4> --json',
             requires_user_runtime: true
         },
         route_specific_personas: ROUTE_PERSONAS[routeKey] || [],

package/dist/core/auto-review.js

@@ -2,7 +2,6 @@ import os from 'node:os';
 import path from 'node:path';
 import { ensureDir, exists, readText, writeTextAtomic } from './fsx.js';
 import { writeCodexConfigGuarded } from './codex/codex-config-guard.js';
-import { REQUIRED_CODEX_MODEL } from './codex-model-guard.js';
 export const AUTO_REVIEW_REVIEWER = 'auto_review';
 export const LEGACY_AUTO_REVIEW_REVIEWER = 'guardian_subagent';
 export const AUTO_REVIEW_PROFILE = 'sks-auto-review';
@@ -36,7 +35,7 @@ export const REVIEW_NATIVE_AGENT_PLAN = Object.freeze({
         }
     ],
     safety_personas_read_only_by_default: true,
-    manual_agent_count_syntax: 'sks auto-review fixture --json and sks agent run "<review task>" --route $Review --agents 5 --concurrency 5 --mock --json',
+    manual_agent_count_syntax: 'sks auto-review fixture --json and sks agent run "<review task>" --route $Review --agents 5 --concurrency 4 --mock --json',
     dynamic_effort: 'parent assigns high effort to safety/integrator lanes and medium or higher to verification lanes when proof risk is present'
 });
 export function codexHome(env = process.env) {
@@ -119,7 +118,6 @@ export const SKS_CONFIG_PROFILES = [
 ];
 function sksProfileFileBlock(opts = {}) {
     return [
-        `model = "${REQUIRED_CODEX_MODEL}"`,
         `service_tier = "${opts.serviceTier || 'fast'}"`,
         `approval_policy = "${opts.approvalPolicy || 'on-request'}"`,
         ...(opts.reviewer ? [`approvals_reviewer = "${opts.reviewer}"`] : []),
@@ -315,7 +313,6 @@ function profileConfigBlock(opts = {}) {
     const approvalPolicy = opts.approvalPolicy || 'on-request';
     const sandboxMode = opts.sandboxMode || 'workspace-write';
     return [
-        `model = "${REQUIRED_CODEX_MODEL}"`,
         'service_tier = "fast"',
         `approval_policy = "${approvalPolicy}"`,
         `approvals_reviewer = "${reviewer}"`,

package/dist/core/codex/codex-config-guard.js

@@ -2,7 +2,6 @@ import path from 'node:path';
 import { appendJsonl, ensureDir, nowIso, readText, sha256, writeTextAtomic } from '../fsx.js';
 import { diffCodexAppUiSnapshots, snapshotCodexAppUiState } from '../codex-app/codex-app-ui-state-snapshot.js';
 import { cleanupCodexConfigBackups, validateCodexConfigRoundTrip } from './codex-config-toml.js';
-import { GPT55_CODEX_MODEL, REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
 // fast_mode_ui was removed from the [features] schema in the 2026-07 renewal.
 const FAST_FEATURE_KEYS = ['fast_mode'];
 export async function writeCodexConfigGuarded(input) {
@@ -154,21 +153,24 @@ export function isUnmanagedProjectCodexConfig(root, configPath, text) {
         && !hasSksManagedCodexConfigMarker(text);
 }
 export function removeLegacyTopLevelCodexModeLocks(text = '') {
-    const lines = String(text || '').split('\n');
+    const lines = String(ensureTrailingNewline(text) || '').split('\n');
     const firstTable = lines.findIndex((x) => /^\s*\[.+\]\s*$/.test(x));
     const end = firstTable === -1 ? lines.length : firstTable;
-    const topLevelModel = topLevelTomlString(text, 'model');
-    // Current default stamp OR the legacy gpt-5.5 stamp older SKS versions wrote,
-    // so upgrades keep cleaning locks written before the 5.6-terra default bump.
-    const removeSksOwnedModeLock = topLevelModel === REQUIRED_CODEX_MODEL || topLevelModel === GPT55_CODEX_MODEL;
     return ensureTrailingNewline(lines.filter((line, index) => {
         if (index >= end)
             return true;
-        if (!removeSksOwnedModeLock)
+        if (!/^\s*(?:model|model_reasoning_effort)\s*=/.test(line))
             return true;
-        return !/^\s*(?:model|model_reasoning_effort)\s*=/.test(line);
+        return !isSksProvenanceLine(line, lines[index - 1] || '');
     }).join('\n').replace(/^\n+/, '').replace(/\n{3,}/g, '\n\n'));
 }
+function isSksProvenanceLine(...lines) {
+    return lines.some((line) => {
+        const trimmed = String(line || '').trim();
+        const comment = trimmed.startsWith('#') ? trimmed : trimmed.includes('#') ? trimmed.slice(trimmed.indexOf('#')) : '';
+        return /(?:SKS|Sneakoscope|codex-lb|sks fast)/i.test(comment);
+    });
+}
 function mergeLostFastUiKeys(before, nextInput) {
     let next = String(nextInput || '');
     const keys = [];
@@ -189,7 +191,7 @@ function mergeLostFastUiKeys(before, nextInput) {
     return { text: ensureTrailingNewline(next), keys };
 }
 function topLevelModeLocks(text) {
-    return ['model', 'model_reasoning_effort'].filter((key) => hasTopLevelTomlKey(text, key));
+    return ['model_reasoning_effort'].filter((key) => hasTopLevelTomlKey(text, key));
 }
 function topLevelTomlKeyLine(text, key) {
     const lines = String(text || '').split('\n');

package/dist/core/codex-adapter.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { runProcess } from './fsx.js';
-import { forceRequiredCodexModelArgs } from './codex-model-guard.js';
+import { preserveCodexModelArgs } from './codex-model-guard.js';
 import { managedProxyEnvForChild } from './codex/managed-proxy-env.js';
 import { resolveCodexRuntime } from './codex-runtime/resolve-codex-runtime.js';
 export async function findCodexBinary() {
@@ -35,7 +35,7 @@ export function buildCodexExecArgs({ root, prompt, outputFile, json = true, prof
         args.push('--json');
     if (outputFile)
         args.push('--output-last-message', outputFile);
-    args.push(...forceRequiredCodexModelArgs(extraArgs));
+    args.push(...preserveCodexModelArgs(extraArgs));
     args.push(prompt);
     return args;
 }

package/dist/core/codex-app/codex-agent-role-sync.js

@@ -87,7 +87,6 @@ function roleToml(role, payload) {
     return [
         `name = "${role}"`,
         `description = "SKS managed ${PACKAGE_VERSION} directive role: ${role}"`,
-        'model_reasoning_effort = "medium"',
         role.includes('implementer') ? 'sandbox_mode = "workspace-write"' : 'sandbox_mode = "read-only"',
         'approval_policy = "never"',
         'developer_instructions = """',

package/dist/core/codex-app/codex-app-fast-ui-repair.js

@@ -6,7 +6,6 @@ import { assertCodexAppUiMutationAllowed } from './codex-app-ui-clobber-guard.js
 import { codexProviderModelUiStatus } from '../codex-app.js';
 export const CODEX_APP_FAST_UI_REPAIR_SCHEMA = 'sks.codex-app-fast-ui-repair.v1';
 const FAST_UI_TOP_LEVEL_RE = /^\s*(?:model|model_reasoning_effort|service_tier)\s*=/;
-const CODEX_APP_MODE_LOCK_TOP_LEVEL_RE = /^\s*(?:model|model_reasoning_effort)\s*=/;
 const FAST_UI_FEATURE_LINE_RE = /^\s*fast_mode\s*=/;
 const FAST_UI_LEGACY_TABLES = new Set(['user.fast_mode', 'profiles.sks-fast-high']);
 const SKS_CAUSED_RE = /(?:SKS|Sneakoscope|codex-lb|sks-mad|sks fast)/i;
@@ -135,14 +134,18 @@ function stripProjectLocalForbiddenKeys(text) {
     });
 }
 function stripSksCausedHostOwnedLines(text) {
-    return stripMatchingLines(text, (line, table, previous, next) => {
-        const isCodexAppModeLock = !table && CODEX_APP_MODE_LOCK_TOP_LEVEL_RE.test(line);
+    const topLevel = String(text || '').split(/\n\s*\[/)[0] || '';
+    const sksManagedTopLevel = SKS_CAUSED_RE.test(topLevel);
+    const sksManagedDocument = SKS_CAUSED_RE.test(String(text || ''));
+    const stripped = stripMatchingLines(text, (line, table, previous, next) => {
         const isLegacyFastTable = table ? FAST_UI_LEGACY_TABLES.has(table) : false;
         const isFastUiLine = FAST_UI_TOP_LEVEL_RE.test(line)
             || (table === 'features' && FAST_UI_FEATURE_LINE_RE.test(line))
             || isLegacyFastTable;
-        return isCodexAppModeLock || (isFastUiLine && (SKS_CAUSED_RE.test(line) || SKS_CAUSED_RE.test(previous) || SKS_CAUSED_RE.test(next)));
+        const sksMarked = (!table && sksManagedTopLevel) || (isLegacyFastTable && sksManagedDocument) || SKS_CAUSED_RE.test(line) || SKS_CAUSED_RE.test(previous) || SKS_CAUSED_RE.test(next);
+        return isFastUiLine && sksMarked;
     });
+    return stripped;
 }
 function stripMatchingLines(text, shouldRemove) {
     const lines = text.split(/\r?\n/);

package/dist/core/codex-app/codex-app-ui-state-snapshot.js

@@ -4,16 +4,10 @@ import path from 'node:path';
 import { exists, nowIso, readText, sha256, writeJsonAtomic } from '../fsx.js';
 export const CODEX_APP_UI_STATE_SNAPSHOT_SCHEMA = 'sks.codex-app-ui-state-snapshot.v1';
 export const PROJECT_LOCAL_FORBIDDEN_CODEX_KEYS = [
-    'model',
-    'model_reasoning_effort',
     'openai_base_url',
     'chatgpt_base_url',
     'apps_mcp_product_sku',
-    'model_provider',
-    'model_providers',
     'notify',
-    'profile',
-    'profiles',
     'experimental_realtime_ws_base_url',
     'otel'
 ];
@@ -45,7 +39,7 @@ export async function snapshotCodexAppUiState(root = process.cwd(), input = {})
             return true;
         if (signal.key_path.startsWith('user.fast_mode') && /hidden|fixed|disabled|false/i.test(signal.value_preview))
             return true;
-        if (signal.key_path === 'model' || signal.key_path === 'model_reasoning_effort')
+        if ((signal.key_path === 'model' || signal.key_path === 'model_reasoning_effort') && signal.sks_related)
             return true;
         if (signal.key_path === 'service_tier' && signal.sks_related)
             return true;

package/dist/core/codex-app.js

@@ -858,8 +858,6 @@ async function codexFastModeConfigStatus(opts = {}) {
         if (!config.text)
             continue;
         const topLevel = topLevelToml(config.text);
-        if (/(^|\n)\s*model\s*=/.test(topLevel))
-            blockers.push(`${config.scope}:top_level_model`);
         if (/(^|\n)\s*model_reasoning_effort\s*=/.test(topLevel))
             blockers.push(`${config.scope}:top_level_model_reasoning_effort`);
         if (/(^|\n)\s*fast_default_opt_out\s*=\s*true\s*(?:#.*)?(?=\n|$)/.test(tomlTable(config.text, 'notice')))

package/dist/core/codex-control/codex-model-capabilities.js

@@ -1,7 +1,6 @@
 import path from 'node:path';
 import { writeJsonAtomic } from '../fsx.js';
 import { collectCodexModelMetadata } from './codex-model-metadata.js';
-import { REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
 export const SKS_FALLBACK_EFFORT_ORDER = ['minimal', 'low', 'medium', 'high', 'xhigh'];
 export function codexModelEffortCapability(input = {}) {
     const metadataIsFallback = input.metadata?.source === 'fallback';
@@ -10,7 +9,7 @@ export function codexModelEffortCapability(input = {}) {
     const requestedDefault = input.metadata?.default_effort || input.defaultEffort;
     const defaultEffort = order.includes(String(requestedDefault || '')) ? String(requestedDefault) : order.includes('medium') ? 'medium' : order[0] || 'medium';
     return {
-        model: String(input.metadata?.model || input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || REQUIRED_CODEX_MODEL),
+        model: String(input.metadata?.model || input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || ''),
         advertised_efforts: order,
         default_effort: defaultEffort,
         order_source: advertised.length ? 'model-advertised' : 'sks-fallback',

package/dist/core/codex-control/codex-model-metadata.js

@@ -1,13 +1,12 @@
 import { findCodexBinary } from '../codex-adapter.js';
 import { runProcess } from '../fsx.js';
-import { REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
 const FALLBACK_EFFORT_ORDER = ['minimal', 'low', 'medium', 'high', 'xhigh'];
 export async function collectCodexModelMetadata(input = {}) {
     if (process.env.SKS_CODEX_MODEL_METADATA_FAKE === '1') {
         const advertised = normalizeAdvertisedEfforts(process.env.SKS_CODEX_MODEL_EFFORTS || 'low,medium,high,xhigh');
-        return metadata(String(input.model || process.env.SKS_CODEX_MODEL || REQUIRED_CODEX_MODEL), advertised, 'medium', 'app-server', []);
+        return metadata(String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || ''), advertised, 'medium', 'app-server', []);
     }
-    const model = String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || REQUIRED_CODEX_MODEL);
+    const model = String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || '').trim();
     const appServer = await readAppServerMetadata(model);
     if (appServer)
         return appServer;
@@ -58,11 +57,19 @@ async function readCodexCliMetadata(model) {
     return null;
 }
 function normalizePayload(payload, fallbackModel, source) {
-    const row = Array.isArray(payload?.models)
-        ? payload.models.find((candidate) => String(candidate?.id || candidate?.model || candidate?.name || '') === fallbackModel) || payload.models[0]
+    const catalog = Array.isArray(payload?.models) ? payload.models : null;
+    const reportedSelection = String(payload?.selected_model || payload?.current_model || payload?.active_model || '').trim();
+    const requestedModel = String(fallbackModel || reportedSelection).trim();
+    const row = catalog
+        ? requestedModel
+            ? catalog.find((candidate) => String(candidate?.id || candidate?.model || candidate?.name || '') === requestedModel) || null
+            : null
         : payload?.model_metadata || payload?.metadata || payload;
+    if (!row) {
+        return metadata(requestedModel, [], 'medium', source, [requestedModel ? 'codex_model_not_found_in_advertised_catalog' : 'codex_model_selection_unknown']);
+    }
     const efforts = normalizeAdvertisedEfforts(row?.advertised_efforts || row?.advertisedEfforts || row?.reasoning_efforts || row?.reasoningEfforts || payload?.advertised_efforts);
-    return metadata(String(row?.model || row?.id || row?.name || fallbackModel), efforts, row?.default_effort || row?.defaultEffort || payload?.default_effort || 'medium', source, efforts.length ? [] : ['codex_model_metadata_efforts_missing']);
+    return metadata(String(row?.model || row?.id || row?.name || requestedModel), efforts, row?.default_effort || row?.defaultEffort || payload?.default_effort || 'medium', source, efforts.length ? [] : ['codex_model_metadata_efforts_missing']);
 }
 function metadata(model, efforts, defaultEffort, source, blockers) {
     const advertised = normalizeAdvertisedEfforts(efforts);

package/dist/core/codex-control/codex-sdk-config-policy.js

@@ -1,9 +1,7 @@
-import { REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
 export function buildCodexSdkConfig(input) {
-    const model = String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || REQUIRED_CODEX_MODEL);
+    const model = String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || '').trim();
     const serviceTier = String(input.serviceTier || process.env.SKS_SERVICE_TIER || 'fast');
     const config = {
-        model,
         service_tier: serviceTier === 'standard' ? 'standard' : 'fast',
         model_reasoning_effort: String(input.modelReasoningEffort || input.reasoningEffort || process.env.SKS_CODEX_REASONING || process.env.CODEX_MODEL_REASONING_EFFORT || 'medium'),
         mcp_servers: {},
@@ -15,6 +13,8 @@ export function buildCodexSdkConfig(input) {
             generation_index: Number(input.generationIndex || 0)
         }
     };
+    if (model)
+        config.model = model;
     if (input.requestedScopeContract?.no_mcp === true) {
         config.mcp_servers = {};
         config.sks = { ...config.sks, no_mcp: true };

package/dist/core/codex-control/codex-task-runner.js

@@ -18,7 +18,6 @@ import { readLocalModelConfig } from '../agents/ollama-worker-config.js';
 import { runLocalLlmTask } from '../local-llm/local-llm-control-adapter.js';
 import { detectPythonCodexSdkCapability, runPythonCodexSdkTask } from './python-codex-sdk-adapter.js';
 import { defaultModelCallBudget, withModelCallSlot } from './model-call-concurrency.js';
-import { REQUIRED_CODEX_MODEL } from '../codex-model-guard.js';
 export async function runCodexTask(input) {
     const root = path.resolve(input.mutationLedgerRoot);
     await ensureDir(root);
@@ -486,9 +485,9 @@ async function ensurePythonCodexLbConfig(env, config) {
     const lbBaseUrl = normalizeCodexLbBaseUrl(env.CODEX_LB_BASE_URL);
     if (!codexHome || !lbBaseUrl || !env.CODEX_LB_API_KEY)
         return;
-    const model = String(config.model || env.SKS_CODEX_MODEL || env.CODEX_MODEL || REQUIRED_CODEX_MODEL);
+    const model = String(config.model || env.SKS_CODEX_MODEL || env.CODEX_MODEL || '').trim();
     const text = [
-        `model = ${tomlQuote(model)}`,
+        ...(model ? [`model = ${tomlQuote(model)}`] : []),
         'model_provider = "codex-lb"',
         'service_tier = "fast"',
         `model_reasoning_effort = ${tomlQuote(String(config.model_reasoning_effort || env.SKS_CODEX_REASONING || env.CODEX_MODEL_REASONING_EFFORT || 'minimal'))}`,

package/dist/core/codex-model-guard.js

@@ -1,96 +1,31 @@
-// Default model/effort for every SKS-managed Codex surface. gpt-5.6-terra is
-// served by the patched codex-lb (v1.20.1-r3, upstream PR #1173 port) with a
-// 6-level low~ultra reasoning range. Keys still LB-pinned to enforced_model=
-// gpt-5.5 will have the model rewritten server-side; unpin a key in the LB
-// dashboard (:1455) to actually receive 5.6 responses on it.
-export const REQUIRED_CODEX_MODEL = 'gpt-5.6-terra';
+/**
+ * Codex owns the model catalog. SKS must never maintain a finite allowlist or
+ * silently replace a model selected by the user, workspace, or Codex client.
+ *
+ * Reasoning effort remains an SKS scheduling hint because it is independent of
+ * the model identifier and can be ignored by clients that do not advertise it.
+ */
 export const DEFAULT_CODEX_REASONING_EFFORT = 'high';
-export const GPT55_CODEX_MODEL = 'gpt-5.5';
-export const GPT54_MINI_CODEX_MODEL = 'gpt-5.4-mini';
-export const GPT56_CODEX_ALIAS_MODEL = 'gpt-5.6';
-export const GPT56_CODEX_MODELS = ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna'];
-export const SUPPORTED_CODEX_MODELS = [REQUIRED_CODEX_MODEL, GPT56_CODEX_ALIAS_MODEL, GPT55_CODEX_MODEL, GPT54_MINI_CODEX_MODEL, 'gpt-5.6-sol', 'gpt-5.6-luna'];
-const MODEL_VALUE_FLAGS = new Set(['--model', '-m']);
-const CONFIG_VALUE_FLAGS = new Set(['-c', '--config']);
-function isModelConfigOverride(value = '') {
-    return /^model\s*=/.test(String(value || '').trim());
-}
-function stripCodexModelOverrides(args = []) {
-    const out = [];
-    const input = Array.isArray(args) ? args : [];
-    for (let i = 0; i < input.length; i += 1) {
-        const arg = String(input[i]);
-        if (MODEL_VALUE_FLAGS.has(arg)) {
-            i += 1;
-            continue;
-        }
-        if (arg.startsWith('--model=') || arg.startsWith('-m='))
-            continue;
-        if (CONFIG_VALUE_FLAGS.has(arg)) {
-            const value = i + 1 < input.length ? String(input[i + 1]) : '';
-            if (isModelConfigOverride(value)) {
-                i += 1;
-                continue;
-            }
-            out.push(arg);
-            if (i + 1 < input.length)
-                out.push(String(input[++i]));
-            continue;
-        }
-        if (arg.startsWith('-c=') || arg.startsWith('--config=')) {
-            const value = arg.slice(arg.indexOf('=') + 1);
-            if (isModelConfigOverride(value))
-                continue;
-        }
-        out.push(arg);
-    }
-    return out;
-}
-function isSupportedCodexModel(value = '') {
-    return SUPPORTED_CODEX_MODELS.includes(String(value || '').trim().toLowerCase());
-}
-// The forced model is REQUIRED_CODEX_MODEL unless the caller explicitly
-// requested another SUPPORTED model (via --model/-m/-c model=... args, or
-// SKS_CODEX_MODEL when no arg is present). Unsupported/forbidden requests are
-// stripped and rewritten to the required default.
-function resolveForcedCodexModel(args = []) {
-    const requested = requestedCodexModelFromArgs(args);
-    if (isSupportedCodexModel(requested))
-        return String(requested).trim().toLowerCase();
-    const envModel = String(process.env.SKS_CODEX_MODEL || '').trim().toLowerCase();
-    if (!requested && isSupportedCodexModel(envModel))
-        return envModel;
-    return REQUIRED_CODEX_MODEL;
-}
-function requestedCodexModelFromArgs(args = []) {
-    const input = Array.isArray(args) ? args : [];
-    for (let i = 0; i < input.length; i += 1) {
-        const arg = String(input[i]);
-        if (MODEL_VALUE_FLAGS.has(arg))
-            return i + 1 < input.length ? String(input[i + 1]) : '';
-        if (arg.startsWith('--model=') || arg.startsWith('-m='))
-            return arg.slice(arg.indexOf('=') + 1);
-        if (CONFIG_VALUE_FLAGS.has(arg)) {
-            const value = i + 1 < input.length ? String(input[i + 1]) : '';
-            if (isModelConfigOverride(value))
-                return value.slice(value.indexOf('=') + 1).trim().replace(/^"|"$/g, '');
-        }
-        if (arg.startsWith('-c=') || arg.startsWith('--config=')) {
-            const value = arg.slice(arg.indexOf('=') + 1);
-            if (isModelConfigOverride(value))
-                return value.slice(value.indexOf('=') + 1).trim().replace(/^"|"$/g, '');
-        }
-    }
-    return '';
-}
+function copyArgs(args = []) {
+    return Array.isArray(args) ? args.map((value) => String(value)) : [];
+}
+/** Return Codex arguments exactly as supplied, including future model IDs. */
+export function preserveCodexModelArgs(args = []) {
+    return copyArgs(args);
+}
+/**
+ * Backward-compatible aliases for callers compiled against older SKS builds.
+ * Despite the historical name, these functions intentionally do not force a
+ * model anymore.
+ */
 export function forceRequiredCodexModelArgs(args = []) {
-    return ['--model', resolveForcedCodexModel(args), ...stripCodexModelOverrides(args)];
+    return preserveCodexModelArgs(args);
 }
 export function forceRequiredCodexModelConfigArgs(args = []) {
-    return ['-c', `model="${resolveForcedCodexModel(args)}"`, ...stripCodexModelOverrides(args)];
+    return preserveCodexModelArgs(args);
 }
-export function isForbiddenCodexModel(value = '') {
-    const model = String(value || '').trim().toLowerCase();
-    return /^gpt-5\./.test(model) && !SUPPORTED_CODEX_MODELS.includes(model);
+/** No model is forbidden by SKS; availability is decided by Codex itself. */
+export function isForbiddenCodexModel(_value = '') {
+    return false;
 }
 //# sourceMappingURL=codex-model-guard.js.map

package/dist/core/commands/basic-cli.js

@@ -187,6 +187,8 @@ export async function updateCommand(sub = 'now', args = []) {
         process.exitCode = 1;
 }
 export async function setupCommand(args = []) {
+    if (flag(args, '--help') || flag(args, '-h'))
+        return usageCommand(['setup']);
     const root = await projectRoot();
     const installScope = installScopeFromArgs(args);
     let res = null;
@@ -221,9 +223,13 @@ export async function setupCommand(args = []) {
         console.log(`- ${file}`);
 }
 export async function bootstrapCommand(args = []) {
+    if (flag(args, '--help') || flag(args, '-h'))
+        return usageCommand(['bootstrap']);
     return setupCommand(['--local-only', ...args]);
 }
 export async function initCommand(args = []) {
+    if (flag(args, '--help') || flag(args, '-h'))
+        return usageCommand(['init']);
     return setupCommand(args);
 }
 export async function fixPathCommand(args = []) {