sneakoscope 10.5.2 → 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.2**. 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.2"
+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.2"
+version = "10.5.4"
 edition = "2021"
 
 [dependencies]

package/dist/cli/command-manifest-lite.js

@@ -377,7 +377,7 @@ const COMMAND_HELP_LITE = {
         description: 'Project TriWiki context-pack memory into managed AGENTS.md blocks or run bounded memory cleanup.'
     },
     naruto: {
-        usage: 'sks naruto run "task" [--agents N] [--max-threads N] [--trusted-project] [--json] | sks naruto status|subagents|proof [latest|M-...] [--json] | sks naruto parent-summary --mission M-... --stdin [--json]',
+        usage: 'sks naruto run "task" [--agents N] [--max-threads N] [--trusted-project] [--json] | sks naruto status|subagents|proof [latest|M-...] [--json] | sks naruto execution status [--json] | sks naruto execution set --mode auto|current-session|standalone [--restart] [--json] | sks naruto parent-summary --mission M-... --stdin [--json]',
         description: 'Run or inspect the Codex official subagent workflow: an orchestrating parent (latest deep-tier standalone default), children on the newest model of their tier (Jev picks the tier on spawn when Jev mode is on), max_depth=1, and structured parent-thread completion evidence.'
     },
     reasoning: {

package/dist/cli/router.js

@@ -5,6 +5,7 @@ import { ui as cliUi } from './cli-theme.js';
 import { helpResult, isHelpRequest, renderManifestHelp } from './help.js';
 import { findRetiredGlobalExecutionArgumentErrors } from './global-mode-router.js';
 import { normalizeIntentCommand, } from '../core/commands/intent-normalization/normalizer.js';
+import { narutoUsesCurrentSession } from '../core/subagents/naruto-execution-mode.js';
 const routerIntentStorage = new AsyncLocalStorage();
 export function prepareRouterExecutionIntent(argv, inheritance = {}) {
     const effectiveArgv = argv.length ? [...argv] : ['doctor'];
@@ -241,9 +242,9 @@ async function ensureActiveRouteCommandGate(command, args) {
         import('../core/mission.js')
     ]);
     const root = await projectRoot(process.cwd()).catch(() => process.cwd());
-    const appSessionKey = process.env.SKS_NARUTO_STANDALONE_CLI === '1'
-        ? ''
-        : String(process.env.CODEX_THREAD_ID || '').trim();
+    const appSessionKey = narutoUsesCurrentSession()
+        ? String(process.env.CODEX_THREAD_ID || '').trim()
+        : '';
     const state = await loadOwnedRouteState(root, appSessionKey);
     if (safeActiveRouteContinuation(command, args, state))
         return { ok: true, status: 'allowed_active_route_continuation' };
@@ -296,6 +297,9 @@ export function safeReadOnlySubcommand(command, args) {
     if (command === 'naruto' && ['status', 'subagents', 'proof'].includes(sub)) {
         return !args.some((arg) => ['--fix', '--yes', '-y', '--write', '--apply', '--execute', '--force', '--real'].includes(String(arg)));
     }
+    if (command === 'naruto' && sub === 'execution' && nested === 'status') {
+        return !args.some((arg) => ['--fix', '--yes', '-y', '--write', '--apply', '--execute', '--force', '--real'].includes(String(arg)));
+    }
     if (command === 'mcp' && sub === 'config' && ['list', 'test', 'backups', 'show'].includes(nested)) {
         return !args.some((arg) => ['--fix', '--yes', '-y', '--write', '--apply', '--execute', '--force', '--real'].includes(String(arg)));
     }
@@ -316,6 +320,8 @@ export function safeActiveRouteContinuation(command, args, state = {}) {
     const subcommand = String(args[0] || '').toLowerCase();
     const activeRoute = String(state.route || state.route_command || state.mode || '').replace(/^\$/, '').replace(/[-_]/g, '').toUpperCase();
     if (command === 'naruto') {
+        if (subcommand === 'execution' && String(args[1] || '').toLowerCase() === 'set')
+            return true;
         if (subcommand === 'parent-summary') {
             const explicitParentSummaryMission = optionValue(args, ['--mission']);
             return Boolean(state.mission_id)

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.2",
+  "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-app/codex-app-restart-policy.js

@@ -1,5 +1,9 @@
 import { isCodexAppRunningByBundleId } from './menubar/config.js';
 import { restartCodexApp } from './codex-app-restart.js';
+export const CODEX_RESTART_FAILED_BLOCKER = 'codex_restart_failed_manual_restart_required';
+export function codexRestartBlockers(restart) {
+    return restart?.attempted && !restart.ok ? [CODEX_RESTART_FAILED_BLOCKER] : [];
+}
 export async function maybeRestartRunningCodexApp(input) {
     const skipped = (reason) => ({ attempted: false, running: null, status: 'skipped', reason, ok: true, blockers: [] });
     if (input.noRestart)

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

@@ -1,5 +1,6 @@
 import { readText, writeJsonAtomic } from '../../fsx.js';
 import { readTopLevelTomlString } from '../../codex-app/codex-model-catalog.js';
+import { codexRestartBlockers, maybeRestartRunningCodexApp } from '../../codex-app/codex-app-restart-policy.js';
 import { BRIDGE_MODEL_SELECTION_SCHEMA, MAX_SELECTED_OPENROUTER_MODELS, bridgeAvailableModelsPath, pruneSelection, readBridgeModelSelectionState, writeBridgeModelSelection } from '../combined-catalog/model-selection.js';
 import { listOpenRouterModels } from '../../providers/openrouter/openrouter-account.js';
 import { buildCombinedBridgeCatalog, readActiveCombinedBridgeCatalog, stageCombinedBridgeCatalog } from '../combined-catalog.js';
@@ -338,6 +339,7 @@ export async function listSelectableModels(options) {
 }
 export async function selectExposedModels(publicIds, options) {
     const paths = controllerPaths(options);
+    const before = await readBridgeModelSelectionState(paths.home, nowIso(options));
     const requested = [...new Set(publicIds.map((id) => String(id || '').trim()).filter(Boolean))].sort();
     if (requested.length > MAX_SELECTED_OPENROUTER_MODELS) {
         throw new Error('bridge_model_selection_limit_exceeded');
@@ -352,7 +354,19 @@ export async function selectExposedModels(publicIds, options) {
     const activation = sync.activation && typeof sync.activation === 'object'
         ? sync.activation
         : {};
-    return commandResult('models.select', sync.ok === true, status, { selected_count: requested.length, catalog_sync: sync }, sync.ok === true ? [] : stringArray(activation.blockers), options);
+    const changed = before.selection.openrouter.public_ids.join('\0') !== requested.join('\0');
+    const restart = sync.ok === true
+        ? await maybeRestartRunningCodexApp({
+            env: controllerEnv(options),
+            changed,
+            noRestart: false,
+            ...(options.platform ? { platform: options.platform } : {}),
+            ...(options.codexAppRunningImpl ? { isRunningImpl: options.codexAppRunningImpl } : {}),
+            ...(options.codexAppRestartImpl ? { restartImpl: options.codexAppRestartImpl } : {})
+        })
+        : null;
+    const restartBlockers = codexRestartBlockers(restart);
+    return commandResult('models.select', sync.ok === true && restartBlockers.length === 0, status, { selected_count: requested.length, changed, catalog_sync: sync, codex_restart: restart }, [...(sync.ok === true ? [] : stringArray(activation.blockers)), ...restartBlockers], options);
 }
 function seedSelectionFromConfiguredModel(selection, configText) {
     const configured = readTopLevelTomlString(configText, 'model');

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

@@ -8,7 +8,8 @@ import { DESKTOP_BRIDGE_OFFICIAL_UPSTREAM_BASE_URL } from '../desktop-bridge/ind
 import { resolveBridgeRequestRoute } from '../request-route-resolver.js';
 import { applyOfficialModelPassthrough, buildBridgeRoutingPolicy, setBridgeRoutingDefault, writeBridgeRoutingPolicy } from '../provider-route-policy.js';
 import { syncCatalogInternal } from './catalog.js';
-import { codexRestartBlockers, releaseOpenRouterOnlyForAuthPriority, releaseOpenRouterOnlyWithoutBridge, restartCodexAfterOpenRouterOnlyOff } from './openrouter-only-commands.js';
+import { codexRestartBlockers } from '../../codex-app/codex-app-restart-policy.js';
+import { releaseOpenRouterOnlyForAuthPriority, releaseOpenRouterOnlyWithoutBridge, restartCodexAfterOpenRouterOnlyOff } from './openrouter-only-commands.js';
 import { openRouterOnlyStatus } from './openrouter-only-status.js';
 import { commandResult, controllerPaths, nowIso, persistRuntimeSettings, providerCode, providerRegistrySnapshot, stringArray } from './shared.js';
 import { desktopBridgeStatusV3, loadCore, statusFromCore } from './status.js';

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

@@ -1,8 +1,9 @@
 import { readTopLevelTomlString } from '../../codex-app/codex-model-catalog.js';
-import { maybeRestartRunningCodexApp } from '../../codex-app/codex-app-restart-policy.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
@@ -32,11 +64,7 @@ function syncBlockers(sync) {
     const blockers = stringArray(activation.blockers);
     return blockers.length > 0 ? blockers : ['combined_catalog_sync_failed'];
 }
-export const CODEX_RESTART_FAILED_BLOCKER = 'codex_restart_failed_manual_restart_required';
 export const CODEX_RELAUNCH_FOR_SUBAGENT_MODELS_WARNING = 'codex_relaunch_required_for_new_subagent_models';
-export function codexRestartBlockers(restart) {
-    return restart?.attempted && !restart.ok ? [CODEX_RESTART_FAILED_BLOCKER] : [];
-}
 function restartCodex(changed, noRestart, options) {
     return maybeRestartRunningCodexApp({
         env: controllerEnv(options),
@@ -241,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/commands/align-command.js

@@ -9,6 +9,7 @@ import { maybeFinalizeRoute } from '../proof/auto-finalize.js';
 import { sksPrefixedDollarCommand } from '../routes/dollar-prefix.js';
 import { closeWorkOrderLedgerForRouteResult } from '../work-order-ledger.js';
 import { flag, positionalArgs, promptOf, warnOnMultipleActiveSessions } from './command-utils.js';
+import { narutoUsesCurrentSession } from '../subagents/naruto-execution-mode.js';
 const ACTIONS = new Set(['prepare', 'run', 'status', 'proof', 'fixture', 'help', '--help', '-h']);
 export async function alignCommand(sub = 'prepare', args = []) {
     const action = String(sub || 'prepare').toLowerCase();
@@ -262,7 +263,7 @@ async function closeVerifiedAlignRoute(root, missionId, sessionKey) {
     return closed?.ok === true;
 }
 function ownerSessionKey() {
-    if (process.env.SKS_NARUTO_STANDALONE_CLI === '1')
+    if (!narutoUsesCurrentSession())
         return null;
     return String(process.env.CODEX_THREAD_ID || '').trim() || null;
 }

package/dist/core/commands/naruto-command.js

@@ -16,6 +16,7 @@ import { effectiveSubagentTarget, refreshSubagentWaveLifecycle } from '../subage
 import { HOST_CAPABILITY_HOOK_RUNTIME_FILENAME, bindParentSummaryToHostCapabilityEvidence, createHostCapabilityHookRuntimeBinding, resolveHostCapabilityHookRuntimeBinding } from '../agent-bridge/host-capability-runtime.js';
 import { renderHostCapabilityBlockedLines } from '../agent-bridge/host-capability-policy.js';
 import { uniqueStrings } from '../text/strings.js';
+import { configureNarutoExecution } from './naruto-config-command.js';
 import { completeNarutoTerminalBundle, refreshOfficialSubagentCompletionArtifacts } from '../hooks-runtime/official-subagent-lifecycle.js';
 export { buildNarutoGateResult } from '../subagents/official-subagent-preparation.js';
 export { attachNarutoLaunchDiagnostics } from '../subagents/naruto-launch-diagnostics.js';
@@ -65,10 +66,53 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
         return narutoSubagents(parsed);
     if (parsed.action === 'proof')
         return narutoProof(parsed);
+    if (parsed.action === 'execution')
+        return narutoExecution(parsed);
     if (parsed.action === 'parent-summary')
         return narutoParentSummary(parsed);
     return narutoRun(parsed);
 }
+async function narutoExecution(parsed) {
+    const configuration = await configureNarutoExecution({
+        ...(parsed.executionMode ? { mode: parsed.executionMode } : {}),
+        restart: parsed.restart
+    });
+    const result = {
+        schema: 'sks.naruto-execution-result.v1',
+        ok: configuration.ok,
+        action: 'execution',
+        command: parsed.executionCommand,
+        mode: configuration.mode,
+        stored: configuration.stored,
+        changed: configuration.changed,
+        path: configuration.path,
+        blockers: configuration.blockers,
+        restart: configuration.restart
+    };
+    return emit(parsed, result, () => {
+        if (!configuration.ok) {
+            for (const blocker of configuration.blockers)
+                console.error(`Naruto execution setting blocked: ${blocker}`);
+            return;
+        }
+        if (parsed.executionCommand === 'status') {
+            console.log(`Naruto execution mode: ${configuration.mode} (${configuration.stored ? 'saved' : 'default'})`);
+            console.log(`Preference: ${configuration.path}`);
+            return;
+        }
+        const restart = configuration.restart;
+        const suffix = restart?.status === 'restarted'
+            ? ' Codex was restarted; start a new task.'
+            : restart?.reason === 'codex_not_running'
+                ? ' Codex is not running; the setting applies on its next launch.'
+                : restart?.reason === 'not_macos'
+                    ? ' The setting is saved; restart Codex on macOS to apply it.'
+                    : restart?.status === 'skipped'
+                        ? ` The setting is saved; restart skipped (${restart.reason || 'policy'}).`
+                        : '';
+        console.log(`Naruto execution mode saved: ${configuration.mode}.${suffix}`);
+    }, !configuration.ok);
+}
 async function narutoParentSummary(parsed) {
     const root = await sksRoot();
     const appSession = detectCodexAppSession();

package/dist/core/commands/naruto-config-command.js

@@ -0,0 +1,23 @@
+import { codexRestartBlockers, maybeRestartRunningCodexApp } from '../codex-app/codex-app-restart-policy.js';
+import { readNarutoExecutionMode, writeNarutoExecutionMode } from '../subagents/naruto-execution-mode.js';
+export async function configureNarutoExecution(input) {
+    const env = input.env || process.env;
+    try {
+        const preference = input.mode
+            ? await writeNarutoExecutionMode(input.mode, env)
+            : { ...readNarutoExecutionMode(env), changed: false };
+        if (preference.blockers.length)
+            return { ...preference, ok: false, restart: null };
+        const restart = input.mode && input.restart
+            ? await maybeRestartRunningCodexApp({ env, changed: true, noRestart: false, ...input.restartOptions })
+            : null;
+        const blockers = restart && !restart.ok
+            ? [...restart.blockers, ...codexRestartBlockers(restart)]
+            : [];
+        return { ...preference, ok: blockers.length === 0, blockers, restart };
+    }
+    catch (error) {
+        return { ...readNarutoExecutionMode(env), ok: false, changed: false, restart: null,
+            blockers: [error instanceof Error ? error.message : 'naruto_execution_config_failed'] };
+    }
+}

package/dist/core/commands/pipeline-command.js

@@ -7,10 +7,11 @@ import { PIPELINE_PLAN_ARTIFACT, pipelinePlanState, projectGateStatus, sealRoute
 import { routePrompt } from '../routes.js';
 import { positionalArgs } from '../../cli/args.js';
 import { flag, readFlagValue, resolveMissionId } from './command-utils.js';
+import { narutoUsesCurrentSession } from '../subagents/naruto-execution-mode.js';
 export async function pipelineCommand(args = []) {
     const root = await projectRoot();
     const action = args[0] || 'status';
-    const sessionKey = process.env.SKS_NARUTO_STANDALONE_CLI === '1' ? '' : process.env.CODEX_THREAD_ID;
+    const sessionKey = narutoUsesCurrentSession() ? process.env.CODEX_THREAD_ID : '';
     const state = await loadOwnedRouteState(root, sessionKey);
     const sessions = await listSessionStates(root);
     if (action === 'status') {

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');
 }