sneakoscope 10.5.2 → 10.5.4

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)

package/dist/core/pipeline-internals/runtime-core.js

@@ -29,6 +29,7 @@ import { classifyTaskProfile, gateProfileForTask } from '../runtime/task-profile
 import { chooseVerificationBudget } from '../runtime/verification-budget.js';
 import { stopFinalizationRitualsEnforced } from '../verification-profile.js';
 import { HARD_NARUTO_MAX_THREADS } from '../subagents/thread-budget.js';
+import { narutoUsesCurrentSession } from '../subagents/naruto-execution-mode.js';
 import { NARUTO_GATE_FILENAME, NARUTO_SUMMARY_FILENAME, SUBAGENT_PLAN_FILENAME, prepareOfficialSubagentMission } from '../subagents/official-subagent-preparation.js';
 import { buildSubagentEvidence, readSubagentEvents, recordSubagentEvent, SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME } from '../subagents/subagent-evidence.js';
 import { effectiveSubagentTarget, normalizeLegacySubagentCountFields, subagentCountContractBlockers } from '../subagents/wave-lifecycle.js';
@@ -601,7 +602,7 @@ export async function prepareRoute(root, prompt, state = {}, opts = {}) {
         ...selectedRoute,
         requiredSkills: managedSkillNamesForPrompt(selectedRoute, cleanPrompt)
     } : null;
-    const codexThreadId = String(process.env.CODEX_THREAD_ID || '').trim();
+    const codexThreadId = narutoUsesCurrentSession() ? String(process.env.CODEX_THREAD_ID || '').trim() : '';
     const sessionKey = opts.sessionKey || codexThreadId || state?._session_key || null;
     const madSksAuthorization = hasMadSksSignal(cleanPrompt);
     const task = stripDollarCommand(stripMadSksSignal(cleanPrompt)) || stripMadSksSignal(stripDollarCommand(cleanPrompt)) || String(cleanPrompt || '').trim();

package/dist/core/routes.js

@@ -206,7 +206,7 @@ export const ROUTES = [
         reasoningPolicy: 'high',
         stopGate: 'naruto-gate.json',
         coverage_required: true,
-        cliEntrypoint: 'sks naruto run "task" [--agents N] [--max-threads N] [--trusted-project] | sks naruto status|subagents|proof | sks naruto parent-summary --mission M-... --stdin',
+        cliEntrypoint: 'sks naruto run "task" [--agents N] [--max-threads N] [--trusted-project] | sks naruto status|subagents|proof | sks naruto execution status | sks naruto execution set --mode auto|current-session|standalone [--restart] | sks naruto parent-summary --mission M-... --stdin',
         examples: ['$Naruto run review twelve independent packages with --agents 12', '$Work']
     },
     {

package/dist/core/safety/command-contract/contracts.js

@@ -4,12 +4,22 @@ const ARGUMENT_BUILDERS = {
     none: () => [],
     'json-only': jsonFlag,
     naruto: (input) => {
+        const action = stringValue(input.action, input.prompt || input.task ? 'run' : 'help');
+        if (action === 'execution') {
+            const executionCommand = stringValue(input.execution_command, 'status');
+            return [
+                'execution',
+                ...(executionCommand === 'status' ? [] : [executionCommand]),
+                ...valueFlag(input, 'mode', '--mode'),
+                ...booleanFlag(input, 'restart', '--restart'),
+                ...jsonFlag(input)
+            ];
+        }
         const task = typeof input.prompt === 'string'
             ? input.prompt
             : typeof input.task === 'string'
                 ? input.task
                 : '';
-        const action = stringValue(input.action, task ? 'run' : 'help');
         return [
             action,
             ...(task ? [task] : []),

package/dist/core/safety/command-contract/types.js

@@ -1 +1 @@
-export const NARUTO_ACTIONS = ['run', 'status', 'subagents', 'proof', 'parent-summary', 'help'];
+export const NARUTO_ACTIONS = ['run', 'status', 'subagents', 'proof', 'parent-summary', 'execution', 'help'];

package/dist/core/subagents/child-model-allowlist.js

@@ -1,14 +1,20 @@
 import fs from 'node:fs';
+import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { isOpenRouterModelId } from '../imagegen/imagegen-config.js';
-import { latestTierModelSet } from './model-tiers.js';
+import { latestTierModelSet, selectableChildModels } from './model-tiers.js';
+import { normalizeCodexModelId } from '../codex-app/codex-model-catalog.js';
+import { withFileLock } from '../locks/file-lock.js';
+import { ensureConfinedDirectory, inspectConfinedPath } from '../managed-path-safety.js';
 export const OPENROUTER_ONLY_SCHEMA = 'sks.openrouter-only.v1';
 export const OPENROUTER_ONLY_FILENAME = 'sks-openrouter-only.json';
 export const MAX_SUBAGENT_MODELS = 16;
 export const MAX_SUBAGENT_CRITERIA_CHARS = 240;
 export const SUBAGENT_MODEL_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
+export const NATIVE_SUBAGENT_MODEL_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+export const SUBAGENT_MODEL_LISTS_SCHEMA = 'sks.subagent-model-lists.v1';
 export function openRouterOnlyStatePath(input = {}) {
     const env = input.env || process.env;
     return path.join(input.home || env.HOME || os.homedir(), '.codex', 'sks', OPENROUTER_ONLY_FILENAME);
@@ -19,8 +25,9 @@ export function defaultOpenRouterOnlyState() {
 export function canonicalChildModelId(value) {
     return String(value ?? '').trim().toLowerCase();
 }
-export function isSubagentModelEffort(value) {
-    return typeof value === 'string' && SUBAGENT_MODEL_EFFORTS.includes(value);
+export function isSubagentModelEffort(value, profile = 'openrouter_only') {
+    const efforts = profile === 'openrouter_only' ? SUBAGENT_MODEL_EFFORTS : NATIVE_SUBAGENT_MODEL_EFFORTS;
+    return typeof value === 'string' && efforts.includes(value);
 }
 function cleanCriteria(value) {
     return String(value ?? '')
@@ -29,7 +36,7 @@ function cleanCriteria(value) {
         .trim()
         .slice(0, MAX_SUBAGENT_CRITERIA_CHARS);
 }
-export function normalizeSubagentModelList(raw) {
+export function normalizeSubagentModelList(raw, profile = 'openrouter_only') {
     const rows = Array.isArray(raw) ? raw : [];
     const issues = [];
     const entries = [];
@@ -37,7 +44,7 @@ export function normalizeSubagentModelList(raw) {
     rows.forEach((row, index) => {
         const record = row && typeof row === 'object' ? row : {};
         const model = String(record.model ?? '').trim();
-        if (!isOpenRouterModelId(model)) {
+        if (!(profile === 'openrouter_only' ? isOpenRouterModelId(model) : normalizeCodexModelId(model))) {
             issues.push({ index, code: 'subagent_model_id_invalid' });
             return;
         }
@@ -47,7 +54,7 @@ export function normalizeSubagentModelList(raw) {
             return;
         }
         const effort = record.reasoning_effort ?? null;
-        if (effort !== null && effort !== '' && !isSubagentModelEffort(effort)) {
+        if (effort !== null && effort !== '' && !isSubagentModelEffort(effort, profile)) {
             issues.push({ index, code: 'subagent_model_effort_invalid' });
             return;
         }
@@ -57,9 +64,9 @@ export function normalizeSubagentModelList(raw) {
         }
         seen.add(key);
         entries.push({
-            model: key,
+            model: profile === 'openrouter_only' ? key : model,
             criteria: cleanCriteria(record.criteria),
-            reasoning_effort: isSubagentModelEffort(effort) ? effort : null,
+            reasoning_effort: isSubagentModelEffort(effort, profile) ? effort : null,
             default: record.default === true
         });
     });
@@ -116,6 +123,78 @@ export function subagentEntryForModel(state, model) {
         return null;
     return state.subagent_models.find((entry) => canonicalChildModelId(entry.model) === key) || null;
 }
+export function childModelListProfile(list) {
+    return list.mode === 'openrouter_only' ? 'openrouter_only' : list.profile;
+}
+export function childModelListLabel(list) {
+    return list.mode === 'openrouter_only' ? 'OpenRouter Only' : list.profile === 'codex_lb' ? 'Codex-LB' : 'OpenAI OAuth';
+}
+export function listChildModelEffort(entry, requested) {
+    const supported = entry.supported_reasoning_efforts ?? SUBAGENT_MODEL_EFFORTS;
+    const effort = entry.reasoning_effort || String(requested || '');
+    return supported.includes(effort) && isSubagentModelEffort(effort, 'openai') ? effort : null;
+}
+export function subagentModelListsPath(input = {}) {
+    return path.join(path.dirname(openRouterOnlyStatePath(input)), 'sks-subagent-model-lists.json');
+}
+export function nativeSubagentModelProfile(input = {}) {
+    if (input.nativeProfile)
+        return input.nativeProfile;
+    const file = path.join(path.dirname(openRouterOnlyStatePath(input)), 'desktop-bridge-settings.json');
+    try {
+        if (fs.statSync(file).size > 4 * 1024 * 1024)
+            return 'openai';
+        return JSON.parse(fs.readFileSync(file, 'utf8'))?.auth_priority_enabled === true ? 'codex_lb' : 'openai';
+    }
+    catch {
+        return 'openai';
+    }
+}
+export function readNativeSubagentModelStore(input = {}) {
+    const file = subagentModelListsPath(input);
+    const empty = { schema: SUBAGENT_MODEL_LISTS_SCHEMA, profiles: { codex_lb: [], openai: [] }, updated_at: null };
+    try {
+        if (fs.statSync(file).size > 256 * 1024)
+            throw new Error('oversized');
+        const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (raw?.schema !== SUBAGENT_MODEL_LISTS_SCHEMA || !raw.profiles || Array.isArray(raw.profiles))
+            throw new Error('schema');
+        for (const profile of ['codex_lb', 'openai']) {
+            if (!Array.isArray(raw.profiles[profile]))
+                throw new Error('profile');
+            const normalized = normalizeSubagentModelList(raw.profiles[profile], profile);
+            if (normalized.issues.length)
+                throw new Error('entries');
+            empty.profiles[profile] = normalized.entries;
+        }
+        empty.updated_at = typeof raw.updated_at === 'string' ? raw.updated_at : null;
+        return { path: file, store: empty, blockers: [] };
+    }
+    catch (error) {
+        return { path: file, store: empty, blockers: error?.code === 'ENOENT' ? [] : ['subagent_model_lists_unreadable'] };
+    }
+}
+export async function writeNativeSubagentModels(profile, raw, input = {}) {
+    const { entries, issues } = normalizeSubagentModelList(raw, profile);
+    if (!Array.isArray(raw) || issues.length)
+        throw new Error('subagent_models_payload_invalid');
+    const file = subagentModelListsPath(input);
+    const root = path.dirname(path.dirname(file));
+    await fsp.mkdir(root, { recursive: true });
+    await ensureConfinedDirectory(root, path.dirname(file));
+    await withFileLock({ lockPath: `${file}.lock`, timeoutMs: 5_000, staleMs: 30_000 }, async () => {
+        if ((await inspectConfinedPath(root, file)).leafSymlink)
+            throw new Error('subagent_model_lists_unsafe_path');
+        const current = readNativeSubagentModelStore(input);
+        if (current.blockers.length)
+            throw new Error(current.blockers[0]);
+        await writeJsonAtomic(file, {
+            ...current.store,
+            profiles: { ...current.store.profiles, [profile]: entries },
+            updated_at: nowIso()
+        }, { mode: 0o600 });
+    });
+}
 function openRouterRoutedModels(input) {
     const env = input.env || process.env;
     const file = path.join(input.home || env.HOME || os.homedir(), '.codex', 'sks', 'sks-bridge-route-policy.json');
@@ -158,6 +237,26 @@ export function effectiveChildModelAllowlist(input = {}) {
             unroutable
         };
     }
+    const profile = nativeSubagentModelProfile(input);
+    const saved = readNativeSubagentModelStore(input);
+    const selected = saved.blockers.length ? [] : saved.store.profiles[profile];
+    if (selected.length || saved.blockers.length) {
+        const available = selectableChildModels(profile, input);
+        const entries = selected.flatMap((entry) => {
+            const model = available.find((row) => canonicalChildModelId(row.public_id) === canonicalChildModelId(entry.model));
+            return model && (!entry.reasoning_effort || model.reasoning_efforts.includes(entry.reasoning_effort))
+                ? [{ ...entry, model: model.public_id, supported_reasoning_efforts: model.reasoning_efforts }]
+                : [];
+        });
+        const preferred = entries.findIndex((entry) => entry.default);
+        entries.forEach((entry, index) => { entry.default = index === (preferred < 0 ? 0 : preferred); });
+        return {
+            mode: 'configured', profile, models: entries.map((entry) => entry.model), entries,
+            default_model: defaultSubagentEntry({ subagent_models: entries })?.model ?? null,
+            unroutable: selected.filter((row) => !entries.some((entry) => canonicalChildModelId(entry.model) === canonicalChildModelId(row.model))).map((row) => row.model),
+            blockers: saved.blockers
+        };
+    }
     return { mode: 'tiers', models: [...latestTierModelSet(input)], entries: [], default_model: null };
 }
 export function isAllowedChildModel(model, allowlist) {

package/dist/core/subagents/child-model-plan.js

@@ -1,40 +1,29 @@
 import { chooseChildModels } from '../decisions/child-model-choice.js';
 import { MAX_JEV_ROUTING_ROLES } from '../decisions/routing.js';
-import { SUBAGENT_MODEL_EFFORTS, defaultSubagentEntry, readOpenRouterOnlyStateSync, routableSubagentState } from './child-model-allowlist.js';
-import { latestTierModelSet } from './model-tiers.js';
+import { defaultSubagentEntry, effectiveChildModelAllowlist, childModelListProfile, listChildModelEffort } from './child-model-allowlist.js';
 import { readCodexMainModel } from './naruto-host-credentials.js';
 import { READ_ONLY_LIST_ROLE } from './read-only-list-role.js';
 export function readChildModelPlanContext(location = {}) {
-    const stored = readOpenRouterOnlyStateSync(location);
-    if (!stored.enabled) {
-        return { allowlist: { mode: 'tiers', models: [...latestTierModelSet(location)], entries: [], default_model: null }, list: null };
-    }
-    const { state, unroutable } = routableSubagentState(stored, location);
-    const allowlist = {
-        mode: 'openrouter_only',
-        models: state.subagent_models.map((entry) => entry.model),
-        entries: state.subagent_models,
-        default_model: defaultSubagentEntry(state)?.model ?? null,
-        unroutable
-    };
+    const allowlist = effectiveChildModelAllowlist(location);
+    if (allowlist.mode === 'tiers')
+        return { allowlist, list: null };
+    const state = { subagent_models: allowlist.entries };
     return { allowlist, list: { state, allowlist, mainModel: readCodexMainModel(location) } };
 }
 export function listEntryEffort(entry, roleEffort) {
-    if (entry.reasoning_effort)
-        return entry.reasoning_effort;
-    const effort = String(roleEffort || '');
-    return SUBAGENT_MODEL_EFFORTS.includes(effort) ? effort : null;
+    return listChildModelEffort(entry, roleEffort);
 }
-function routedRow(row, choice) {
+function routedRow(row, choice, list) {
+    const prefix = list.mode === 'openrouter_only' ? 'openrouter_only' : 'configured_list';
     return {
         ...row,
-        routed_provider: 'openrouter',
+        routed_provider: list.mode === 'openrouter_only' ? 'openrouter' : list.profile === 'codex_lb' ? 'codex-lb' : 'openai',
         routed_model: choice?.entry.model ?? null,
         routed_model_reasoning_effort: choice ? listEntryEffort(choice.entry, row.model_reasoning_effort) : null,
-        routed_model_policy: choice?.source === 'jev' ? 'openrouter_only_jev' : 'openrouter_only_default',
+        routed_model_policy: `${prefix}_${choice?.source === 'jev' ? 'jev' : 'default'}`,
         routing_dynamic: true,
-        role_model_preference_source: 'ignored_openrouter_only',
-        openrouter_only_choice: choice
+        role_model_preference_source: `ignored_${prefix}`,
+        [list.mode === 'openrouter_only' ? 'openrouter_only_choice' : 'subagent_list_choice']: choice
             ? { model: choice.entry.model, source: choice.source, reason: choice.reason, default_entry: choice.entry.default }
             : { model: null, source: 'default', reason: 'subagent_list_empty', default_entry: false }
     };
@@ -42,7 +31,7 @@ function routedRow(row, choice) {
 export function listBaselineAgentRouting(agentRouting, list) {
     const fallback = defaultSubagentEntry(list.state);
     const choice = fallback ? { entry: fallback, source: 'default', reason: 'baseline' } : null;
-    return Object.fromEntries(Object.entries(agentRouting).map(([name, row]) => [name, routedRow(row, choice)]));
+    return Object.fromEntries(Object.entries(agentRouting).map(([name, row]) => [name, routedRow(row, choice, list.allowlist)]));
 }
 export function childModelLanes(input) {
     const assigned = new Set(input.slices.map((slice) => String(slice.agent || '')).filter(Boolean));
@@ -65,6 +54,7 @@ export async function chooseListRoleModels(input) {
             goal: input.goal || 'Plan official subagent roles.',
             lanes,
             state: input.list.state,
+            profile: childModelListProfile(input.list.allowlist),
             ...(input.env ? { env: input.env } : {})
         });
         return { lanes: lanes.map((lane) => lane.id), choices };
@@ -94,8 +84,8 @@ export function applyListRoleModels(agents, chosen, list, readOnlyRoleInstalled
     for (const [name, row] of Object.entries(agents)) {
         const choice = chosen?.choices[name]
             ?? (fallback ? { entry: fallback, source: 'default', reason: routed.has(name) ? 'keep_baseline' : capped } : null);
-        next[name] = routedRow(row, choice);
-        roles[name] = next[name].openrouter_only_choice;
+        next[name] = routedRow(row, choice, list.allowlist);
+        roles[name] = next[name].openrouter_only_choice ?? next[name].subagent_list_choice;
         if (choice?.source === 'jev')
             jevModels[name] = choice.entry.model;
     }
@@ -104,6 +94,7 @@ export function applyListRoleModels(agents, chosen, list, readOnlyRoleInstalled
         jevModels,
         evidence: {
             enabled: true,
+            ...(list.allowlist.mode === 'configured' ? { profile: list.allowlist.profile } : {}),
             main_model: list.mainModel,
             default_subagent_model: fallback?.model ?? null,
             subagent_models: list.state.subagent_models.map((entry) => ({ ...entry })),
@@ -111,7 +102,7 @@ export function applyListRoleModels(agents, chosen, list, readOnlyRoleInstalled
             jev_decided_roles: Object.keys(jevModels),
             roles,
             read_only_role: { name: READ_ONLY_LIST_ROLE.codex_name, installed: readOnlyRoleInstalled },
-            warnings: readOnlyRoleInstalled === false ? ['openrouter_only_read_only_role_missing'] : []
+            warnings: readOnlyRoleInstalled === false ? [`${list.allowlist.mode === 'openrouter_only' ? 'openrouter_only' : 'subagent_list'}_read_only_role_missing`] : []
         }
     };
 }

package/dist/core/subagents/model-tiers.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { codexHomePath, readTopLevelTomlString } from '../codex-app/codex-model-catalog.js';
+import { codexHomePath, inferProviderFromModel, normalizeCodexModelId, readTopLevelTomlString } from '../codex-app/codex-model-catalog.js';
 const MODELS_CACHE_FILENAME = 'models_cache.json';
 function modelsCachePath(input) {
     return path.join(codexHomePath(input), MODELS_CACHE_FILENAME);
@@ -150,19 +150,30 @@ export function effortForTier(tier, resolved = resolveLatestModelTiers()) {
     const byDistance = [...order].sort((a, b) => Math.abs(order.indexOf(a) - index) - Math.abs(order.indexOf(b) - index));
     return byDistance.find((effort) => supported.includes(effort)) || wanted;
 }
-function readCandidateRows(file) {
+function readModelRows(file) {
     let parsed;
     try {
+        const stat = fs.statSync(file);
+        if (!stat.isFile() || stat.size > 16 * 1024 * 1024)
+            return [];
         parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
     }
     catch {
         return [];
     }
     const models = Array.isArray(parsed?.models) ? parsed.models : Array.isArray(parsed) ? parsed : [];
+    return models.slice(0, 1024).filter((row) => row && typeof row === 'object' && !Array.isArray(row));
+}
+function modelEfforts(row) {
+    return Array.isArray(row.supported_reasoning_levels)
+        ? [...new Set(row.supported_reasoning_levels
+                .map((level) => String(typeof level === 'string' ? level : level?.effort || '').trim().toLowerCase())
+                .filter(Boolean))]
+        : [];
+}
+function readCandidateRows(file) {
     const rows = [];
-    for (const row of models.slice(0, 1024)) {
-        if (!row || typeof row !== 'object')
-            continue;
+    for (const row of readModelRows(file)) {
         const slug = String(row.slug || row.model || row.id || '').trim();
         const id = parseGptModelId(slug);
         if (!id)
@@ -170,15 +181,39 @@ function readCandidateRows(file) {
         const visibility = String(row.visibility || 'list').toLowerCase();
         if (visibility === 'hide' || visibility === 'hidden')
             continue;
-        const efforts = Array.isArray(row.supported_reasoning_levels)
-            ? row.supported_reasoning_levels
-                .map((level) => String(typeof level === 'string' ? level : level?.effort || '').trim().toLowerCase())
-                .filter(Boolean)
-            : [];
+        const efforts = modelEfforts(row);
         rows.push({ slug, version: id.version, family: id.family, efforts });
     }
     return rows;
 }
+export function selectableChildModels(profile, input = {}) {
+    const file = profile === 'codex_lb' ? configuredCatalogPath(input) : modelsCachePath(input);
+    if (!file)
+        return [];
+    const models = [];
+    const seen = new Set();
+    for (const row of readModelRows(file)) {
+        const model = normalizeCodexModelId(row.slug || row.public_id || row.model || row.id);
+        const provider = String(row.provider_id || row.provider || inferProviderFromModel(model));
+        if (!model || seen.has(model.toLowerCase()) || ['hide', 'hidden'].includes(String(row.visibility).toLowerCase())
+            || row.multi_agent_version === 'disabled'
+            || (profile === 'openai' && model.includes('/'))
+            || provider !== (profile === 'codex_lb' ? 'codex-lb' : 'openai'))
+            continue;
+        seen.add(model.toLowerCase());
+        models.push({ public_id: model, display_name: String(row.display_name || model), reasoning_efforts: modelEfforts(row) });
+    }
+    const newest = new Map();
+    for (const row of models) {
+        const id = parseGptModelId(row.public_id);
+        if (id && (!newest.has(id.family) || compareModelVersions(id.version, newest.get(id.family)) > 0))
+            newest.set(id.family, id.version);
+    }
+    return models.filter((row) => {
+        const id = parseGptModelId(row.public_id);
+        return !id || compareModelVersions(id.version, newest.get(id.family)) === 0;
+    });
+}
 export function compareModelVersions(a, b) {
     const length = Math.max(a.length, b.length);
     for (let index = 0; index < length; index += 1) {