sneakoscope 10.5.3 → 10.5.4

package/README.md

@@ -17,7 +17,7 @@
 Sneakoscope Codex (`sks`) is an open-source trust layer for Codex CLI and ChatGPT Desktop. It coordinates bounded AI coding agents, records machine-verifiable evidence, preserves project memory, and blocks release claims that are not supported by current tests or artifacts. Search visibility outcomes are measured separately; SKS does not promise rankings or traffic.
 <!-- END SKS SEARCH VISIBILITY MARKETING -->
 
-Current package: **SKS 10.5.3**. Install the latest stable release from npm.
+Current package: **SKS 10.5.4**. Install the latest stable release from npm.
 
 Sneakoscope Codex (`sks`) is a local trust layer for Codex CLI and ChatGPT Desktop. It keeps agent work bounded, preserves project context, records machine-verifiable evidence, and prevents release claims that current tests or artifacts cannot support.
 

package/crates/sks-core/Cargo.lock

@@ -259,7 +259,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "10.5.3"
+version = "10.5.4"
 dependencies = [
  "globset",
  "grep-matcher",

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "10.5.3"
+version = "10.5.4"
 edition = "2021"
 
 [dependencies]

package/dist/commands/bridge.js

@@ -40,7 +40,8 @@ export function usage(command = 'bridge') {
         '',
         'Provider secrets are accepted only through --api-key-stdin. Readiness changes the exit code only with --strict or --require-ready.',
         'OpenRouter Only Mode and Codex-LB authentication priority are mutually exclusive; turning one on turns the other off.',
-        'subagent-models set reads {"subagent_models":[{"model","criteria","reasoning_effort","default"}]} (max 16) from stdin.'
+        'subagent-models set reads {"profile":"codex_lb|openai|openrouter_only","subagent_models":[{"model","criteria","reasoning_effort","default"}]} (max 16) from stdin.',
+        'The profile must match the current connection. Omitting profile preserves the legacy OpenRouter-list staging behavior.'
     ].join('\n');
 }
 export async function run(_command, args = []) {
@@ -152,7 +153,7 @@ async function parseInvocation(args, io) {
                 ...base,
                 request: {
                     operation: 'subagent-models.set',
-                    subagent_models: subagentModelsFromStdin(await io.readStdin()),
+                    ...subagentModelsFromStdin(await io.readStdin()),
                     no_restart: parsed.flags.has('--no-restart')
                 },
                 label: 'Subagent model list update'
@@ -376,7 +377,11 @@ function subagentModelsFromStdin(text) {
         : undefined;
     if (!Array.isArray(models))
         throw new BridgeCliError('bridge_subagent_models_stdin_invalid', 'retry_with_stdin');
-    return models;
+    const profile = parsed.profile;
+    if (profile !== undefined && profile !== 'openrouter_only' && profile !== 'codex_lb' && profile !== 'openai') {
+        throw new BridgeCliError('bridge_subagent_models_profile_invalid', 'retry_with_stdin');
+    }
+    return { subagent_models: models, ...(profile === undefined ? {} : { profile }) };
 }
 function rejectSecretArgv(args) {
     for (const arg of args) {

package/dist/config/skills-manifest.json

@@ -1,6 +1,6 @@
 {
   "schema": "sks.skills-manifest.v1",
-  "package_version": "10.5.3",
+  "package_version": "10.5.4",
   "skills": [
     {
       "canonical_name": "sks",

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

@@ -14,7 +14,7 @@ import { decideSubagentModel } from '../subagents/model-policy.js';
 import { latestTierModelSet } from '../subagents/model-tiers.js';
 import { consultJevTurnModel } from '../decisions/integration.js';
 import { chooseChildModel, fallbackChildModel } from '../decisions/child-model-choice.js';
-import { OPENROUTER_ONLY_SCHEMA, allowlistedChildModel, effectiveChildModelAllowlist, isSubagentModelEffort } from '../subagents/child-model-allowlist.js';
+import { allowlistedChildModel, effectiveChildModelAllowlist, childModelListProfile, listChildModelEffort, isSubagentModelEffort } from '../subagents/child-model-allowlist.js';
 export const NATIVE_WORKER_BACKEND_ROUTER_SCHEMA = 'sks.native-worker-backend-router.v1';
 export async function runNativeWorkerBackendRouter(input) {
     const root = path.resolve(input.agentRoot);
@@ -93,8 +93,10 @@ export async function runNativeWorkerBackendRouter(input) {
                 cwd: String(input.intake.cwd || root),
                 prompt: buildWorkerPrompt(input.slice),
                 model: modelRouting.choice.model,
-                reasoningEffort: modelRouting.choice.reasoning,
-                modelReasoningEffort: modelRouting.choice.reasoning,
+                ...(modelRouting.choice.reasoning ? {
+                    reasoningEffort: modelRouting.choice.reasoning,
+                    modelReasoningEffort: modelRouting.choice.reasoning
+                } : {}),
                 serviceTier: modelRouting.choice.serviceTier,
                 inputFiles: input.intake.input_files || [],
                 inputImages: input.intake.input_images || [],
@@ -232,7 +234,7 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
     const category = categoryForWorkerRole(String(input.agent?.role || 'executor'), taskKindText);
     const env = deps.env || process.env;
     const allowlist = effectiveChildModelAllowlist({ env });
-    if (allowlist.mode === 'openrouter_only') {
+    if (allowlist.mode !== 'tiers') {
         return resolveOpenRouterOnlyWorkerRouting(input, deps, { allowlist, category, env, taskKindText, riskText });
     }
     const lbCatalog = narutoOnly
@@ -306,11 +308,12 @@ export async function resolveWorkerModelRouting(input, deps = {}) {
 }
 async function resolveOpenRouterOnlyWorkerRouting(input, deps, ctx) {
     const { allowlist, category, env } = ctx;
-    const state = { schema: OPENROUTER_ONLY_SCHEMA, enabled: true, subagent_models: allowlist.entries, restore: null, updated_at: null };
+    const state = { subagent_models: allowlist.entries };
     const explicitModel = String(env.SKS_WORKER_MODEL || env.SKS_AGENT_MODEL || '').trim();
-    const explicitReasoning = listReasoning(env.SKS_WORKER_REASONING || env.SKS_WORKER_MODEL_REASONING);
+    const rawEffort = env.SKS_WORKER_REASONING || env.SKS_WORKER_MODEL_REASONING;
+    const explicitReasoning = allowlist.mode === 'openrouter_only' ? listReasoning(rawEffort) : normalizeModelReasoning(rawEffort);
     const explicitTier = normalizeServiceTier(String(env.SKS_WORKER_SERVICE_TIER || env.SKS_SERVICE_TIER || '').trim());
-    const planned = /^openrouter_only_/.test(String(input.agent?.routed_model_policy || ''))
+    const planned = /^(openrouter_only|configured_list)_/.test(String(input.agent?.routed_model_policy || ''))
         ? allowlistedChildModel(input.agent?.routed_model, allowlist)
         : null;
     const requested = String(input.agent?.routed_model || input.agent?.model || '').trim() || null;
@@ -322,18 +325,23 @@ async function resolveOpenRouterOnlyWorkerRouting(input, deps, ctx) {
             ? fallbackChildModel(state, planned, 'planned')
             : deps.consultJev === false || !task
                 ? fallbackChildModel(state, requested, deps.consultJev === false ? 'jev_skipped' : 'empty_task')
-                : await chooseChildModel({ root: deps.root || process.cwd(), task, role: input.agent?.role || null, requestedModel: requested, state, env })
+                : await chooseChildModel({ root: deps.root || process.cwd(), task, role: input.agent?.role || null, requestedModel: requested, state, env, profile: childModelListProfile(allowlist) })
                     .catch(() => fallbackChildModel(state, requested, 'consult_failed'));
     const taskPolicy = decideSubagentModel({ title: ctx.taskKindText, description: ctx.riskText, role: input.agent?.role });
     const choiceModel = choice?.entry.model || '';
     const routed = {
         model: choiceModel,
-        reasoning: explicitReasoning || choice?.entry.reasoning_effort || listReasoning(taskPolicy.modelReasoningEffort) || 'medium',
+        reasoning: allowlist.mode === 'openrouter_only'
+            ? explicitReasoning || choice?.entry.reasoning_effort || listReasoning(taskPolicy.modelReasoningEffort) || 'medium'
+            : explicitReasoning || (choice ? listChildModelEffort(choice.entry, null) : null),
         serviceTier: explicitTier || input.fastModePolicy.service_tier || 'fast'
     };
     const blockers = [
-        ...(!allowlist.entries.length ? ['openrouter_only_subagent_list_empty'] : []),
-        ...(explicitModel && !explicitListed ? ['openrouter_only_subagent_model_not_listed'] : []),
+        ...(!allowlist.entries.length ? [allowlist.mode === 'openrouter_only' ? 'openrouter_only_subagent_list_empty' : 'configured_subagent_list_unavailable'] : []),
+        ...(explicitModel && !explicitListed ? [allowlist.mode === 'openrouter_only' ? 'openrouter_only_subagent_model_not_listed' : 'configured_subagent_model_not_listed'] : []),
+        ...(allowlist.mode === 'configured' && rawEffort
+            && (!explicitReasoning || !choice?.entry.supported_reasoning_efforts?.includes(explicitReasoning))
+            ? ['configured_subagent_effort_unsupported'] : []),
         ...(!choiceModel ? ['naruto_worker_model_unavailable'] : [])
     ];
     const why = choice ? `${choice.source}${choice.reason === 'applied' ? '' : `:${choice.reason}`}` : 'blocked';
@@ -343,7 +351,7 @@ async function resolveOpenRouterOnlyWorkerRouting(input, deps, ctx) {
         explicit: Boolean(explicitModel),
         lb_catalog: null,
         blockers: [...new Set(blockers)],
-        reason: `${category}->${choiceModel || 'blocked'}@${routed.reasoning} (openrouter only list: ${why})`
+        reason: `${category}->${choiceModel || 'blocked'}@${routed.reasoning || 'default'} (${allowlist.mode === 'openrouter_only' ? 'openrouter only' : allowlist.profile} list: ${why})`
     };
 }
 function listReasoning(value) {

package/dist/core/codex-lb/desktop-controller-v3/openrouter-only-commands.js

@@ -2,7 +2,8 @@ import { readTopLevelTomlString } from '../../codex-app/codex-model-catalog.js';
 import { codexRestartBlockers, maybeRestartRunningCodexApp } from '../../codex-app/codex-app-restart-policy.js';
 import { readText } from '../../fsx.js';
 import { isOpenRouterModelId } from '../../imagegen/imagegen-config.js';
-import { MAX_SUBAGENT_MODELS, normalizeSubagentModelList, readOpenRouterOnlyStateSync, writeOpenRouterOnlyState } from '../../subagents/child-model-allowlist.js';
+import { MAX_SUBAGENT_MODELS, normalizeSubagentModelList, readOpenRouterOnlyStateSync, readNativeSubagentModelStore, writeNativeSubagentModels, writeOpenRouterOnlyState } from '../../subagents/child-model-allowlist.js';
+import { selectableChildModels } from '../../subagents/model-tiers.js';
 import { assertDesktopBridgeStatusV3 } from '../bridge-runtime-validation.js';
 import { readActiveCombinedBridgeCatalog } from '../combined-catalog.js';
 import { MAX_SELECTED_OPENROUTER_MODELS, bridgeAvailableModelsPath, readBridgeModelSelectionState, writeBridgeModelSelection } from '../combined-catalog/model-selection.js';
@@ -19,12 +20,43 @@ async function finish(operation, ok, blockers, extra, options) {
     const status = statusFromCore(core, options);
     assertDesktopBridgeStatusV3(status);
     const openRouterOnly = await openRouterOnlyStatusFromCore(core, options);
+    const subagentSettings = operation.startsWith('subagent-models.')
+        ? await subagentModelSettings(core, openRouterOnly)
+        : null;
     return commandResult(operation, ok, status, {
         openrouter_only: openRouterOnly,
         auth_priority: status.auth_priority,
-        ...extra
+        ...extra,
+        ...(subagentSettings ? { subagent_model_settings: subagentSettings, available: subagentSettings.available } : {})
     }, blockers, options);
 }
+async function subagentModelSettings(core, openRouterOnly) {
+    if (openRouterOnly.enabled) {
+        return {
+            schema: 'sks.subagent-model-settings.v1', profile: 'openrouter_only',
+            configured: true, editable: true, error: openRouterOnly.error,
+            subagent_models: openRouterOnly.subagent_models,
+            jev_enabled: openRouterOnly.jev_enabled, warnings: openRouterOnly.warnings,
+            available: (await availableOpenRouterModels(core.paths.home)).map((row) => ({ ...row, reasoning_efforts: ['low', 'medium', 'high', 'xhigh'] }))
+        };
+    }
+    const profile = core.authPriorityEnabled ? 'codex_lb' : 'openai';
+    const location = openRouterOnlyStoreLocation(core.paths);
+    const saved = readNativeSubagentModelStore(location);
+    const available = selectableChildModels(profile, location);
+    const entries = saved.store.profiles[profile];
+    return {
+        schema: 'sks.subagent-model-settings.v1', profile,
+        configured: entries.length > 0, editable: saved.blockers.length === 0,
+        error: saved.blockers[0] ?? (available.length ? null : 'subagent_model_catalog_unavailable'),
+        subagent_models: entries.map((entry) => ({
+            ...entry,
+            routable: available.some((row) => row.public_id === entry.model
+                && (!entry.reasoning_effort || row.reasoning_efforts.includes(entry.reasoning_effort)))
+        })),
+        jev_enabled: openRouterOnly.jev_enabled, warnings: saved.blockers, available
+    };
+}
 function syncBlockers(sync) {
     const activation = sync.activation && typeof sync.activation === 'object' && !Array.isArray(sync.activation)
         ? sync.activation
@@ -237,23 +269,55 @@ async function availableOpenRouterModels(home) {
     }
 }
 export async function listSubagentModels(options) {
-    const available = await availableOpenRouterModels(controllerPaths(options).home);
-    return finish('subagent-models.list', true, [], { available }, options);
+    return finish('subagent-models.list', true, [], {}, options);
 }
-export async function setSubagentModels(raw, noRestart, options) {
+export async function setSubagentModels(raw, noRestart, options, expectedProfile) {
     if (!Array.isArray(raw))
         return finish('subagent-models.set', false, ['subagent_models_payload_invalid'], {}, options);
-    const { entries, issues } = normalizeSubagentModelList(raw);
+    const core = await loadCore(options);
+    const activeProfile = core.openRouterOnlyEnabled ? 'openrouter_only' : core.authPriorityEnabled ? 'codex_lb' : 'openai';
+    if (expectedProfile && activeProfile !== expectedProfile) {
+        return finish('subagent-models.set', false, ['subagent_model_profile_changed'], {}, options);
+    }
+    const profile = expectedProfile ?? 'openrouter_only';
+    const { entries, issues } = normalizeSubagentModelList(raw, profile);
     if (issues.length > 0) {
         return finish('subagent-models.set', false, issues.map((issue) => `${issue.code}:${issue.index}`), {}, options);
     }
     const paths = controllerPaths(options);
     const location = openRouterOnlyStoreLocation(paths);
     const before = readOpenRouterOnlyStateSync(location);
-    if (!before.enabled) {
+    if (!before.enabled && profile === 'openrouter_only') {
         await writeOpenRouterOnlyState({ subagent_models: entries }, location);
         return finish('subagent-models.set', true, [], { catalog_sync: null }, options);
     }
+    if (profile !== 'openrouter_only') {
+        const nativeProfile = core.authPriorityEnabled ? 'codex_lb' : 'openai';
+        const available = selectableChildModels(nativeProfile, location);
+        const blockers = entries.flatMap((entry, index) => {
+            const model = available.find((row) => row.public_id === entry.model);
+            return !model ? [`subagent_model_not_available:${index}`]
+                : entry.reasoning_effort && !model.reasoning_efforts.includes(entry.reasoning_effort)
+                    ? [`subagent_model_effort_unsupported:${index}`] : [];
+        });
+        const saved = readNativeSubagentModelStore(location);
+        if (saved.blockers.length || blockers.length) {
+            return finish('subagent-models.set', false, [...saved.blockers, ...blockers], {}, options);
+        }
+        const role = entries.length ? await ensureUserReadOnlyListRole(paths.home) : 'unchanged';
+        if (role === 'preserved_user_file') {
+            return finish('subagent-models.set', false, ['subagent_model_read_only_role_unavailable'], {}, options);
+        }
+        await writeNativeSubagentModels(nativeProfile, entries, location);
+        const changed = JSON.stringify(saved.store.profiles[nativeProfile]) !== JSON.stringify(entries);
+        const roleChanged = role === 'created' || role === 'updated';
+        const restart = await restartCodex(roleChanged, noRestart, options);
+        const relaunchPending = roleChanged && !restart.attempted && restart.reason !== 'codex_not_running';
+        return finish('subagent-models.set', true, codexRestartBlockers(restart), {
+            changed, catalog_sync: null, read_only_role: role, codex_restart: restart,
+            warnings: relaunchPending ? [CODEX_RELAUNCH_FOR_SUBAGENT_MODELS_WARNING] : []
+        }, options);
+    }
     const exposedBefore = await exposedModelIds(paths);
     const sync = await syncCatalogInternal(options, {
         openRouterOnly: { ...before, subagent_models: entries },

package/dist/core/codex-lb/desktop-controller-v3.js

@@ -73,7 +73,7 @@ export async function executeDesktopBridgeCommandV3(request, options = {}) {
                 return setOpenRouterOnly(request.enabled, request.no_restart === true, options);
             }
             if (request.operation === 'subagent-models.set') {
-                return setSubagentModels(request.subagent_models, request.no_restart === true, options);
+                return setSubagentModels(request.subagent_models, request.no_restart === true, options, request.profile);
             }
             if (request.operation === 'route.official-models')
                 return setOfficialModelsMode(request.mode, options);

package/dist/core/decisions/child-model-choice.js

@@ -72,7 +72,7 @@ export async function chooseChildModels(input) {
             workflowId: input.workflowId,
             goal: input.goal,
             questions,
-            facts: { openrouter_only: true, subagent_models: entries.map((entry) => canonicalChildModelId(entry.model)) },
+            facts: { openrouter_only: (input.profile ?? 'openrouter_only') === 'openrouter_only', subagent_model_profile: input.profile ?? 'openrouter_only', subagent_models: entries.map((entry) => canonicalChildModelId(entry.model)) },
             ...(input.env ? { env: input.env } : {}),
             ...(input.deadlineMs === undefined ? {} : { deadlineMs: input.deadlineMs })
         })
@@ -100,6 +100,7 @@ export async function chooseChildModel(input) {
         goal: input.task || 'Spawn a child agent.',
         lanes: [{ id: 'spawn', task: input.task, role: input.role ?? null, requestedModel: input.requestedModel ?? null }],
         state: input.state,
+        ...(input.profile ? { profile: input.profile } : {}),
         ...(input.env ? { env: input.env } : {}),
         ...(input.deadlineMs === undefined ? {} : { deadlineMs: input.deadlineMs })
     });

package/dist/core/decisions/cli.js

@@ -145,9 +145,10 @@ export async function statusReport(env) {
             : 'ready';
     const childModels = effectiveChildModelAllowlist({ env });
     const openRouterOnly = childModels.mode === 'openrouter_only';
+    const listMode = childModels.mode !== 'tiers';
     const childTierPoints = new Set(['spawn_tier', 'worker_tier', 'role_tiers', 'role_omission']);
     const decisionPoints = ['turn_route', 'turn_tier', 'spawn_tier', 'worker_tier', 'role_tiers', 'role_omission', 'plan', 'context', 'parent_edit_delegation', 'image_need', 'image_parameters', 'qa_effort_escalation']
-        .filter((point) => !openRouterOnly || !childTierPoints.has(point));
+        .filter((point) => !listMode || !childTierPoints.has(point));
     return {
         schema: 'sks.jev-decision-status.v1',
         ok: true,
@@ -167,8 +168,14 @@ export async function statusReport(env) {
             recovery: config.capabilities.recovery
         },
         decision_points: jevEnabled(config)
-            ? [...decisionPoints, ...(openRouterOnly ? ['child_model'] : [])]
+            ? [...decisionPoints, ...(listMode ? ['child_model'] : [])]
             : [],
+        subagent_model_list: {
+            active: listMode,
+            profile: childModels.mode === 'configured' ? childModels.profile : openRouterOnly ? 'openrouter_only' : null,
+            models: listMode ? childModels.models : [],
+            default_model: childModels.default_model
+        },
         openrouter_only: {
             enabled: openRouterOnly,
             subagent_model_count: openRouterOnly ? childModels.models.length : 0,

package/dist/core/hooks-runtime/hook-context.js

@@ -9,7 +9,7 @@ import { renderAuthoritativeSksSkillContext } from '../codex-native/sks-skill-pa
 import { resolveManagedSkillSourcesForAdmission } from './managed-skill-admission.js';
 import { managedSkillDigestBlocksEnforced } from '../verification-profile.js';
 import { looksLikeActiveContinuationPrompt } from './naruto-decision-gate.js';
-import { effectiveChildModelAllowlist } from '../subagents/child-model-allowlist.js';
+import { effectiveChildModelAllowlist, childModelListLabel } from '../subagents/child-model-allowlist.js';
 import { EXCLUSIVE_SURFACE_SPAWN_LINE } from '../subagents/exclusive-surface-rule.js';
 import { renderChildModelCriteria, SUBAGENT_MODELS_SETTINGS_HINT } from './subagent-spawn-policy.js';
 import { extractUserPrompt, looksLikeCodexGitAction, looksLikeCodexUiSettingsEvent } from './payload-signals.js';
@@ -31,12 +31,12 @@ const OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT = [
 ].join('\n');
 function openRouterOnlyChildModelLine(allowlist) {
     if (!allowlist.models.length) {
-        return `- SKS OpenRouter Only mode is on and the subagent model list is empty: every spawn_agent call is denied until the user adds models in ${SUBAGENT_MODELS_SETTINGS_HINT}.`;
+        return `- SKS ${childModelListLabel(allowlist)} mode is on and the subagent model list is empty: every spawn_agent call is denied until the user adds models in ${SUBAGENT_MODELS_SETTINGS_HINT}.`;
     }
-    return `- SKS OpenRouter Only mode is on: every child runs a model from the user's subagent list, and the SKS PreToolUse hook denies any other model. The list, with the user's rule for each model: ${renderChildModelCriteria(allowlist)}. The hook routes each spawn_agent call to a list model (Jev picks by these rules when Jev mode is on; otherwise a listed requested model, else the default), so pass \`fork_turns="none"\` or a positive bounded turn count and do not tune model or effort yourself.`;
+    return `- SKS ${childModelListLabel(allowlist)} mode is on: every child runs a model from the user's subagent list, and the SKS PreToolUse hook denies any other model. The list, with the user's rule for each model: ${renderChildModelCriteria(allowlist)}. The hook routes each spawn_agent call to a list model (Jev picks by these rules when Jev mode is on; otherwise a listed requested model, else the default), so pass \`fork_turns="none"\` or a positive bounded turn count and do not tune model or effort yourself.`;
 }
 export function officialSubagentSpawnCompatibilityContext(allowlist = effectiveChildModelAllowlist()) {
-    if (allowlist.mode !== 'openrouter_only')
+    if (allowlist.mode === 'tiers')
         return OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT;
     return [...OFFICIAL_SUBAGENT_SPAWN_CONTRACT_HEAD, openRouterOnlyChildModelLine(allowlist)].join('\n');
 }

package/dist/core/hooks-runtime/jev-spawn-routing.js

@@ -1,7 +1,7 @@
 import { consultJevTurnModel } from '../decisions/integration.js';
 import { chooseChildModel, fallbackChildModel } from '../decisions/child-model-choice.js';
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
-import { OPENROUTER_ONLY_SCHEMA, effectiveChildModelAllowlist, isSubagentModelEffort } from '../subagents/child-model-allowlist.js';
+import { effectiveChildModelAllowlist, childModelListLabel, childModelListProfile, listChildModelEffort } from '../subagents/child-model-allowlist.js';
 import { subagentModelProfile } from '../subagents/model-policy.js';
 import { effortForTier, latestModelForTier, latestTierModelSet } from '../subagents/model-tiers.js';
 import { readRoleModelPreferences } from '../subagents/role-model-preferences.js';
@@ -52,12 +52,12 @@ export async function jevSpawnRouting(root, state, payload) {
     if (!input)
         return { input: null, route: null };
     const allowlist = effectiveChildModelAllowlist();
-    if (allowlist.mode === 'openrouter_only')
+    if (allowlist.mode !== 'tiers')
         return openRouterOnlySpawnRouting(root, state, input, allowlist);
     return { input: await tierSpawnRewrite(root, state, input), route: null };
 }
 function listState(allowlist) {
-    return { schema: OPENROUTER_ONLY_SCHEMA, enabled: true, subagent_models: allowlist.entries, restore: null, updated_at: null };
+    return { subagent_models: allowlist.entries };
 }
 async function openRouterOnlySpawnRouting(root, parentState, input, allowlist) {
     if (fullHistoryForkContext(input))
@@ -70,13 +70,14 @@ async function openRouterOnlySpawnRouting(root, parentState, input, allowlist) {
     const agent = String(input.agent_type || input.agentType || '').trim() || null;
     const task = spawnTask(input, { items: true });
     const choice = task
-        ? await chooseChildModel({ root, task, role: agent, requestedModel: requested, state })
+        ? await chooseChildModel({ root, task, role: agent, requestedModel: requested, state, profile: childModelListProfile(allowlist) })
             .catch(() => fallbackChildModel(state, requested, 'consult_failed'))
         : fallbackChildModel(state, requested, 'empty_task');
     if (!choice)
         return { input: null, route: null };
     const route = {
-        mode: 'openrouter_only',
+        mode: allowlist.mode,
+        ...(allowlist.mode === 'configured' ? { profile: allowlist.profile } : {}),
         model: choice.entry.model,
         source: choice.source,
         reason: choice.reason
@@ -90,8 +91,7 @@ async function openRouterOnlySpawnRouting(root, parentState, input, allowlist) {
         else
             delete next.agent_type;
     }
-    const effort = choice.entry.reasoning_effort
-        || (isSubagentModelEffort(input.reasoning_effort) ? input.reasoning_effort : null);
+    const effort = listChildModelEffort(choice.entry, input.reasoning_effort);
     if (effort)
         next.reasoning_effort = effort;
     else
@@ -149,5 +149,5 @@ export function openRouterOnlyJevTurnLine(allowlist, effort, orchestrationRequir
     const list = allowlist.entries.length
         ? `every spawn_agent child runs a model from the user's subagent list (${renderChildModelList(allowlist)}); Jev picks the list model for each spawn from the user's criteria, and any other model is denied.`
         : `the subagent model list is empty, so spawn_agent is denied until the user adds models in ${SUBAGENT_MODELS_SETTINGS_HINT}.`;
-    return `${hint}SKS OpenRouter Only mode: ${list}`;
+    return `${hint}SKS ${childModelListLabel(allowlist)} mode: ${list}`;
 }

package/dist/core/hooks-runtime/spawn-role-pin-heal.js

@@ -8,7 +8,7 @@ export async function healStaleRolePinForSpawn(payload, root) {
     const agent = String(input.agent_type || input.agentType || '').trim();
     if (!agent || !stalePinForAgentType(agent, { root }))
         return false;
-    if (effectiveChildModelAllowlist().mode === 'openrouter_only')
+    if (effectiveChildModelAllowlist().mode !== 'tiers')
         return false;
     await refreshStaleManagedRolePins({ root });
     return true;

package/dist/core/hooks-runtime/subagent-context.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import { readJson } from '../fsx.js';
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
 import { latestModelForTier } from '../subagents/model-tiers.js';
-import { effectiveChildModelAllowlist } from '../subagents/child-model-allowlist.js';
+import { effectiveChildModelAllowlist, childModelListLabel } from '../subagents/child-model-allowlist.js';
 import { jevEnabled, readDecisionConfig } from '../decisions/config.js';
 import { renderChildModelList } from './subagent-spawn-policy.js';
 export async function sealedSubagentRoutingContext(artifactDir, payload = {}) {
@@ -16,11 +16,11 @@ export async function sealedSubagentRoutingContext(artifactDir, payload = {}) {
     if (!agentName)
         return '';
     const allowlist = effectiveChildModelAllowlist();
-    if (allowlist.mode === 'openrouter_only') {
+    if (allowlist.mode !== 'tiers') {
         return [
             'SKS sealed child routing:',
             `- custom agent: ${agentName}`,
-            `- model and model_reasoning_effort: sealed on the spawn call from the OpenRouter Only subagent list (${renderChildModelList(allowlist) || 'empty'})`,
+            `- model and model_reasoning_effort: sealed on the spawn call from the ${childModelListLabel(allowlist)} subagent list (${renderChildModelList(allowlist) || 'empty'})`,
             '- keep this sealed profile; do not retarget model/effort or spawn nested agents'
         ].join('\n');
     }

package/dist/core/hooks-runtime/subagent-spawn-policy.js

@@ -1,29 +1,30 @@
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
-import { READ_ONLY_LIST_ROLE } from '../subagents/read-only-list-role.js';
+import { READ_ONLY_LIST_ROLE, readOnlyListRoleInstalled } from '../subagents/read-only-list-role.js';
 import { stalePinBlockReason, stalePinForAgentType } from '../subagents/role-model-pins.js';
 import { isSpawnAgentToolName, spawnPayloadToolName } from './spawn-tool-name.js';
-import { effectiveChildModelAllowlist, isAllowedChildModel } from '../subagents/child-model-allowlist.js';
+import { effectiveChildModelAllowlist, childModelListLabel, isAllowedChildModel } from '../subagents/child-model-allowlist.js';
 export const SUBAGENT_MODELS_SETTINGS_HINT = 'SKS Control Center > Subagent Models';
 export function renderChildModelList(allowlist) {
-    if (allowlist.mode !== 'openrouter_only')
+    if (allowlist.mode === 'tiers')
         return allowlist.models.join(', ');
     return allowlist.entries.map((entry) => `${entry.model}${entry.default ? ' (default)' : ''}`).join(', ');
 }
 export function renderChildModelCriteria(allowlist) {
-    if (allowlist.mode !== 'openrouter_only')
+    if (allowlist.mode === 'tiers')
         return allowlist.models.join(', ');
     return allowlist.entries
         .map((entry) => `${entry.model}${entry.default ? ' (default)' : ''}: ${entry.criteria || 'general work'}`)
         .join('; ');
 }
 function openRouterOnlyBlockReason(allowlist) {
-    if (!allowlist.models.length && allowlist.mode === 'openrouter_only' && allowlist.unroutable?.length) {
-        return `SKS OpenRouter Only mode: no model on the subagent list has an OpenRouter route right now (${allowlist.unroutable.join(', ')}), so no child may be spawned. Ask the user to replace them in ${SUBAGENT_MODELS_SETTINGS_HINT}, then retry spawn_agent. Do not implement the slice in the parent instead.`;
+    const label = childModelListLabel(allowlist);
+    if (!allowlist.models.length && allowlist.unroutable?.length) {
+        return `SKS ${label} mode: no model on the subagent list is available with its saved effort right now (${allowlist.unroutable.join(', ')}), so no child may be spawned. Ask the user to replace them in ${SUBAGENT_MODELS_SETTINGS_HINT}, then retry spawn_agent. Do not implement the slice in the parent instead.`;
     }
     if (!allowlist.models.length) {
-        return `SKS OpenRouter Only mode is on but the subagent model list is empty, so no child may be spawned. Ask the user to add models in ${SUBAGENT_MODELS_SETTINGS_HINT} (or to turn OpenRouter Only off), then retry spawn_agent. Do not implement the slice in the parent instead.`;
+        return `SKS ${label} mode: the subagent model list is empty or unavailable, so no child may be spawned. Ask the user to review the list in ${SUBAGENT_MODELS_SETTINGS_HINT}, then retry spawn_agent. Do not implement the slice in the parent instead.`;
     }
-    return `SKS OpenRouter Only mode: children may run only a model on the user's subagent list: ${renderChildModelList(allowlist)}. Every other model is denied. Retry spawn_agent with one of them (the SKS hook routes each spawn to a list model, by Jev when Jev mode is on) and fork_turns="none" or a positive bounded turn count. Include the complete slice contract in message; do not inherit the parent model. The user adds models in ${SUBAGENT_MODELS_SETTINGS_HINT}.`;
+    return `SKS ${label} mode: children may run only a model on the user's subagent list: ${renderChildModelList(allowlist)}. Every other model is denied. Retry spawn_agent with one of them (the SKS hook routes each spawn to a list model, by Jev when Jev mode is on) and fork_turns="none" or a positive bounded turn count. Include the complete slice contract in message; do not inherit the parent model. The user adds models in ${SUBAGENT_MODELS_SETTINGS_HINT}.`;
 }
 export function fullHistoryForkContext(input) {
     return input.fork_context === true || String(input.fork_context ?? '').trim().toLowerCase() === 'true';
@@ -37,16 +38,22 @@ export function subagentSpawnPolicyBlockReason(payload = {}, opts = {}) {
         return null;
     const input = payload.tool_input || payload.toolInput || payload.tool?.input || {};
     const allowlist = effectiveChildModelAllowlist();
-    if (allowlist.mode !== 'openrouter_only' && opts.narutoParent === false)
+    if (allowlist.mode === 'tiers' && opts.narutoParent === false)
         return null;
-    if (allowlist.mode === 'openrouter_only') {
+    if (allowlist.mode !== 'tiers') {
         if (!isAllowedChildModel(input.model, allowlist))
             return openRouterOnlyBlockReason(allowlist);
         if (fullHistoryForkContext(input))
             return `${FORK_BLOCK_REASON} Omit fork_context (fork_context=true is a full-history fork).`;
         const agent = String(input.agent_type || input.agentType || '').trim();
+        if (allowlist.mode === 'configured' && agent && agent !== READ_ONLY_LIST_ROLE.codex_name) {
+            return `SKS ${childModelListLabel(allowlist)} subagent list: agent_type "${agent}" may pin its own model or effort, which Codex uses instead of the spawn values. Omit agent_type and include the role brief in message; read-only slices must use agent_type="${READ_ONLY_LIST_ROLE.codex_name}".`;
+        }
+        if (allowlist.mode === 'configured' && agent === READ_ONLY_LIST_ROLE.codex_name && opts.root && !readOnlyListRoleInstalled(opts.root)) {
+            return `SKS could not verify the model-less read-only role for this project. A missing role or custom role/config override must be resolved before retrying ${READ_ONLY_LIST_ROLE.codex_name}; do not remove the role to bypass its read-only sandbox.`;
+        }
         if (agent && managedOfficialSubagentRoleByName(agent)) {
-            return `SKS OpenRouter Only mode: agent_type "${agent}" pins a tier model, so it cannot run a list model. Omit agent_type and put the role brief in message; read-only slices pass agent_type="${READ_ONLY_LIST_ROLE.codex_name}".`;
+            return `SKS ${childModelListLabel(allowlist)} mode: agent_type "${agent}" pins a tier model, so it cannot run a list model. Omit agent_type and put the role brief in message; read-only slices pass agent_type="${READ_ONLY_LIST_ROLE.codex_name}".`;
         }
     }
     else {

package/dist/core/hooks-runtime.js

@@ -310,7 +310,7 @@ async function attachJevTurnRouting(root, payload, result, orchestrationRequired
             : `Jev rated this turn as ${decision.effort}-effort work (${decision.model} tier). Treat it as this turn's reasoning hint; the parent model, effort, and service tier stay as the user set them.`
         : '';
     const allowlist = effectiveChildModelAllowlist();
-    const line = allowlist.mode === 'openrouter_only'
+    const line = allowlist.mode !== 'tiers'
         ? openRouterOnlyJevTurnLine(allowlist, decision.effort, orchestrationRequired)
         : tierLine;
     if (!line)