sneakoscope 10.5.2 → 10.5.3

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.3**. 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.3"
 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.3"
 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/config/skills-manifest.json

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

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,5 +1,5 @@
 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';
@@ -32,11 +32,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),

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/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/naruto-command-args.js

@@ -3,6 +3,7 @@ import { NARUTO_CREDENTIAL_BOOLEAN_FLAGS, NARUTO_CREDENTIAL_VALUE_FLAGS } from '
 import { resolveNarutoCredentialPolicy } from './naruto-host-credentials.js';
 import { DEFAULT_SUBAGENT_EFFORT, defaultSubagentModel, NARUTO_PARENT_EFFORT, narutoParentModel } from './model-policy.js';
 import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
+import { isNarutoExecutionMode } from './naruto-execution-mode.js';
 export function parseNarutoArgs(args) {
     const helpRequested = args.includes('--help') || args.includes('-h');
     const validationArgs = [...args];
@@ -11,7 +12,7 @@ export function parseNarutoArgs(args) {
         : args;
     const first = normalized[0] && !normalized[0].startsWith('-') ? normalized[0] : '';
     const actionName = first;
-    const actions = new Set(['run', 'status', 'subagents', 'proof', 'parent-summary', 'help']);
+    const actions = new Set(['run', 'status', 'subagents', 'proof', 'parent-summary', 'execution', 'help']);
     const action = (actions.has(actionName) ? actionName : 'run');
     const explicitAction = actions.has(actionName);
     const rest = explicitAction ? normalized.slice(1) : normalized;
@@ -20,6 +21,7 @@ export function parseNarutoArgs(args) {
     const maxThreadsOption = optionValue(optionArgs, '--max-threads');
     const missionOption = optionValue(optionArgs, '--mission');
     const missionIdOption = optionValue(optionArgs, '--mission-id');
+    const modeOption = optionValue(optionArgs, '--mode');
     const credentialOptions = NARUTO_CREDENTIAL_VALUE_FLAGS.map((name) => ({
         name,
         option: optionValue(optionArgs, name)
@@ -29,6 +31,7 @@ export function parseNarutoArgs(args) {
         ...optionErrors('--max-threads', maxThreadsOption, true),
         ...optionErrors('--mission', missionOption, false),
         ...optionErrors('--mission-id', missionIdOption, false),
+        ...optionErrors('--mode', modeOption, false),
         ...credentialOptions.flatMap(({ name, option }) => optionErrors(name, option, false)),
         ...booleanOptionErrors(validationArgs),
         ...unknownOptionErrors(validationArgs)
@@ -50,7 +53,7 @@ export function parseNarutoArgs(args) {
         : undefined;
     const prompt = action === 'run' ? positional.join(' ').trim() : '';
     const positionalHead = String(positional[0] || '').toLowerCase();
-    const subcommandNames = new Set(['run', 'status', 'subagents', 'proof', 'parent-summary', 'help']);
+    const subcommandNames = new Set(['run', 'status', 'subagents', 'proof', 'parent-summary', 'execution', 'help']);
     if (!first && !explicitAction && positionalHead && !subcommandNames.has(positionalHead)) {
         argumentErrors.push(`unknown_subcommand:${positionalHead}`);
     }
@@ -60,7 +63,32 @@ export function parseNarutoArgs(args) {
     else if (!explicitAction && subcommandNames.has(positionalHead)) {
         argumentErrors.push(`misplaced_subcommand:${positionalHead}`);
     }
-    if (action !== 'run') {
+    let executionCommand = 'status';
+    if (action === 'execution') {
+        const command = String(positional[0] || 'status').toLowerCase();
+        if (command === 'status' || command === 'set')
+            executionCommand = command;
+        else
+            argumentErrors.push(`invalid_naruto_execution_command:${command}`);
+        if (positional.length > 1) {
+            for (const value of positional.slice(1))
+                argumentErrors.push(`unexpected_positional:${value}`);
+        }
+        if (executionCommand === 'status') {
+            if (modeOption.present)
+                argumentErrors.push('option_not_supported_for_action:execution:--mode');
+            if (normalized.includes('--restart'))
+                argumentErrors.push('option_not_supported_for_action:execution:--restart');
+        }
+        else {
+            if (!modeOption.present || !modeOption.value)
+                argumentErrors.push('naruto_execution_set_requires_mode');
+            if (modeOption.value !== undefined && !isNarutoExecutionMode(modeOption.value)) {
+                argumentErrors.push(`invalid_naruto_execution_mode:${modeOption.value}`);
+            }
+        }
+    }
+    else if (action !== 'run') {
         let missionConsumed = false;
         for (const value of positional) {
             if (!missionConsumed && positionalMission !== undefined && value === positionalMission) {
@@ -87,6 +115,10 @@ export function parseNarutoArgs(args) {
         ...(normalized.includes('--trusted-project') ? ['--trusted-project'] : []),
         ...(normalized.includes('--no-forced-login-method') ? ['--no-forced-login-method'] : [])
     ];
+    const presentExecutionOptions = [
+        ...(modeOption.present ? ['--mode'] : []),
+        ...(normalized.includes('--restart') ? ['--restart'] : [])
+    ];
     if (action === 'parent-summary') {
         if (!missionOption.present || !missionOption.value || missionOption.value === 'latest') {
             argumentErrors.push('parent_summary_requires_explicit_mission');
@@ -104,6 +136,11 @@ export function parseNarutoArgs(args) {
                 argumentErrors.push(`option_not_supported_for_action:${action}:${name}`);
             }
         }
+        if (action !== 'execution' || executionCommand === 'status') {
+            for (const name of presentExecutionOptions) {
+                argumentErrors.push(`option_not_supported_for_action:${action}:${name}`);
+            }
+        }
         if (normalized.includes('--stdin'))
             argumentErrors.push('stdin_only_supported_for_parent_summary');
     }
@@ -113,6 +150,9 @@ export function parseNarutoArgs(args) {
         requestedSubagents,
         maxThreads,
         missionId: String(missionFlag || positionalMission || 'latest'),
+        executionCommand,
+        executionMode: modeOption.value && isNarutoExecutionMode(modeOption.value) ? modeOption.value : undefined,
+        restart: normalized.includes('--restart'),
         json: normalized.includes('--json'),
         stdin: normalized.includes('--stdin'),
         readOnly: normalized.includes('--readonly') || normalized.includes('--read-only'),
@@ -130,11 +170,11 @@ export function parseNarutoArgs(args) {
 }
 function positionalValues(args) {
     const valueFlags = new Set([
-        '--agents', '--max-threads', '--mission', '--mission-id',
+        '--agents', '--max-threads', '--mission', '--mission-id', '--mode',
         ...NARUTO_CREDENTIAL_VALUE_FLAGS
     ]);
     const booleanFlags = new Set([
-        '--json', '--stdin', '--readonly', '--read-only', '--trusted-project',
+        '--json', '--stdin', '--readonly', '--read-only', '--trusted-project', '--restart',
         ...NARUTO_CREDENTIAL_BOOLEAN_FLAGS
     ]);
     const result = [];
@@ -197,8 +237,8 @@ function optionErrors(name, option, numeric) {
 }
 function unknownOptionErrors(args) {
     const canonical = new Set([
-        '--agents', '--max-threads', '--mission', '--mission-id',
-        '--json', '--stdin', '--readonly', '--read-only', '--trusted-project', '--help', '-h', '--',
+        '--agents', '--max-threads', '--mission', '--mission-id', '--mode',
+        '--json', '--stdin', '--readonly', '--read-only', '--trusted-project', '--restart', '--help', '-h', '--',
         ...NARUTO_CREDENTIAL_VALUE_FLAGS,
         ...NARUTO_CREDENTIAL_BOOLEAN_FLAGS
     ]);
@@ -220,6 +260,7 @@ function booleanOptionErrors(args) {
         '--readonly',
         '--read-only',
         '--trusted-project',
+        '--restart',
         ...NARUTO_CREDENTIAL_BOOLEAN_FLAGS,
         '--help',
         '-h'

package/dist/core/subagents/naruto-command-input-contract.js

@@ -1,5 +1,6 @@
 import { NARUTO_ACTIONS } from '../safety/command-contract/types.js';
 import { NARUTO_AUTH_MODES, NARUTO_EFFORT_TIERS } from './naruto-host-credentials.js';
+import { NARUTO_EXECUTION_MODES } from './naruto-execution-mode.js';
 import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
 export const NARUTO_CREDENTIAL_VALUE_FLAGS = Object.freeze([
     '--auth-mode',
@@ -29,6 +30,11 @@ export const NARUTO_RUN_ONLY_INPUT_FIELDS = Object.freeze([
     'subagent_effort',
     'no_forced_login_method'
 ]);
+export const NARUTO_EXECUTION_INPUT_FIELDS = Object.freeze([
+    'execution_command',
+    'mode',
+    'restart'
+]);
 export function narutoCommandInputSchema() {
     const properties = {
         action: { type: 'string', enum: [...NARUTO_ACTIONS] },
@@ -48,6 +54,9 @@ export function narutoCommandInputSchema() {
         subagent_model: identifierSchema(),
         subagent_effort: { type: 'string', enum: [...NARUTO_EFFORT_TIERS] },
         no_forced_login_method: { type: 'boolean' },
+        execution_command: { type: 'string', enum: ['status', 'set'] },
+        mode: { type: 'string', enum: [...NARUTO_EXECUTION_MODES] },
+        restart: { type: 'boolean' },
         json: { type: 'boolean' }
     };
     const exactlyOneTask = {
@@ -60,16 +69,16 @@ export function narutoCommandInputSchema() {
     const runBranch = {
         properties: { action: { const: 'run' } },
         required: ['action'],
-        allOf: [exactlyOneTask, absentFields(['stdin'])]
+        allOf: [exactlyOneTask, absentFields(['stdin', ...NARUTO_EXECUTION_INPUT_FIELDS])]
     };
     const implicitRunBranch = {
         not: { required: ['action'] },
-        allOf: [exactlyOneTask, absentFields(['stdin'])]
+        allOf: [exactlyOneTask, absentFields(['stdin', ...NARUTO_EXECUTION_INPUT_FIELDS])]
     };
     const observationBranch = {
         properties: { action: { enum: ['status', 'subagents', 'proof'] } },
         required: ['action'],
-        allOf: [runOnlyAbsent, absentFields(['stdin'])]
+        allOf: [runOnlyAbsent, absentFields(['stdin', ...NARUTO_EXECUTION_INPUT_FIELDS])]
     };
     const parentSummaryBranch = {
         properties: {
@@ -77,11 +86,34 @@ export function narutoCommandInputSchema() {
             stdin: { const: true }
         },
         required: ['action', 'mission', 'stdin'],
-        allOf: [runOnlyAbsent]
+        allOf: [runOnlyAbsent, absentFields(NARUTO_EXECUTION_INPUT_FIELDS)]
     };
     const helpBranch = {
         properties: { action: { const: 'help' } },
         required: ['action'],
+        allOf: [runOnlyAbsent, absentFields(['mission', 'stdin', ...NARUTO_EXECUTION_INPUT_FIELDS])]
+    };
+    const executionStatusBranch = {
+        properties: { action: { const: 'execution' } },
+        required: ['action'],
+        allOf: [runOnlyAbsent, absentFields(['mission', 'stdin', ...NARUTO_EXECUTION_INPUT_FIELDS])]
+    };
+    const executionStatusExplicitBranch = {
+        properties: {
+            action: { const: 'execution' },
+            execution_command: { const: 'status' }
+        },
+        required: ['action', 'execution_command'],
+        allOf: [runOnlyAbsent, absentFields(['mission', 'stdin', 'mode', 'restart'])]
+    };
+    const executionSetBranch = {
+        properties: {
+            action: { const: 'execution' },
+            execution_command: { const: 'set' },
+            mode: { type: 'string', enum: [...NARUTO_EXECUTION_MODES] },
+            restart: { type: 'boolean' }
+        },
+        required: ['action', 'execution_command', 'mode'],
         allOf: [runOnlyAbsent, absentFields(['mission', 'stdin'])]
     };
     const implicitHelpBranch = {
@@ -90,6 +122,7 @@ export function narutoCommandInputSchema() {
                 { required: ['action'] },
                 { required: ['mission'] },
                 { required: ['stdin'] },
+                ...NARUTO_EXECUTION_INPUT_FIELDS.map((field) => ({ required: [field] })),
                 ...NARUTO_RUN_ONLY_INPUT_FIELDS.map((field) => ({ required: [field] }))
             ]
         }
@@ -103,6 +136,9 @@ export function narutoCommandInputSchema() {
             implicitRunBranch,
             observationBranch,
             parentSummaryBranch,
+            executionStatusBranch,
+            executionStatusExplicitBranch,
+            executionSetBranch,
             helpBranch,
             implicitHelpBranch
         ]

package/dist/core/subagents/naruto-execution-mode.js

@@ -0,0 +1,62 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { writeJsonAtomic } from '../fsx.js';
+import { withFileLock } from '../locks/file-lock.js';
+import { ensureConfinedDirectory, inspectConfinedPath } from '../managed-path-safety.js';
+export const NARUTO_EXECUTION_MODES = ['auto', 'current-session', 'standalone'];
+export const NARUTO_EXECUTION_SCHEMA = 'sks.naruto-execution.v1';
+export function narutoExecutionPath(env = process.env) {
+    return path.join(path.resolve(env.SKS_HOME || path.join(env.HOME || os.homedir(), '.sneakoscope')), 'preferences', 'naruto-execution.json');
+}
+export function isNarutoExecutionMode(value) {
+    return NARUTO_EXECUTION_MODES.some(mode => mode === value);
+}
+export function readNarutoExecutionMode(env = process.env) {
+    const file = narutoExecutionPath(env);
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (raw?.schema !== NARUTO_EXECUTION_SCHEMA || !isNarutoExecutionMode(raw.mode))
+            throw new Error('invalid');
+        return { schema: NARUTO_EXECUTION_SCHEMA, mode: raw.mode, path: file, stored: true, blockers: [] };
+    }
+    catch (error) {
+        return {
+            schema: NARUTO_EXECUTION_SCHEMA, mode: 'auto', path: file, stored: false,
+            blockers: error?.code === 'ENOENT' ? [] : ['naruto_execution_preference_unreadable']
+        };
+    }
+}
+export async function writeNarutoExecutionMode(mode, env = process.env, onlyIfAbsent = false) {
+    if (!isNarutoExecutionMode(mode))
+        throw new Error('naruto_execution_mode_invalid');
+    const file = narutoExecutionPath(env);
+    const root = path.dirname(path.dirname(file));
+    await fsp.mkdir(root, { recursive: true });
+    await ensureConfinedDirectory(root, path.dirname(file));
+    return withFileLock({ lockPath: `${file}.lock`, timeoutMs: 5_000, staleMs: 30_000 }, async () => {
+        const safety = await inspectConfinedPath(root, file);
+        if (safety.leafSymlink)
+            throw new Error('naruto_execution_preference_unsafe_path');
+        const before = readNarutoExecutionMode(env);
+        if (before.blockers.length)
+            throw new Error(before.blockers[0]);
+        if ((onlyIfAbsent && before.stored) || (before.stored && before.mode === mode))
+            return { ...before, changed: false };
+        await writeJsonAtomic(file, { schema: NARUTO_EXECUTION_SCHEMA, mode }, { mode: 0o600 });
+        return { ...readNarutoExecutionMode(env), changed: true };
+    });
+}
+export function narutoUsesCurrentSession(env = process.env) {
+    if (env.SKS_NARUTO_STANDALONE_CLI === '1')
+        return false;
+    if (env.SKS_NARUTO_APP_SESSION === '1')
+        return true;
+    const mode = readNarutoExecutionMode(env).mode;
+    if (mode === 'standalone')
+        return false;
+    if (mode === 'current-session')
+        return Boolean(env.CODEX_THREAD_ID?.trim());
+    return Boolean(env.CODEX_THREAD_ID?.trim());
+}

package/dist/core/subagents/naruto-help-contract.js

@@ -9,6 +9,7 @@ export function renderNarutoUsage() {
         '',
         'Usage: sks naruto run "<task>" [options]',
         '       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]',
         '',
         'Run or inspect the Codex official-subagent Naruto workflow.',
@@ -28,6 +29,12 @@ export function renderNarutoUsage() {
         '  --no-forced-login-method Do not inject a forced login method.',
         '  --json                   Emit machine-readable output.',
         '',
+        'Execution mode:',
+        '  auto                    Preserve the Codex App session contract when CODEX_THREAD_ID is present (default when no update-selected lane exists).',
+        '  current-session         Require CODEX_THREAD_ID and use the current Codex App parent.',
+        '  standalone              Launch the official Codex child workflow from a terminal, even if a shell inherited a thread id.',
+        '  Apply the setting from SKS Center to save it and restart a running Codex App when macOS permits it.',
+        '',
         'Model tiers: every child runs the newest model of its tier: fast for tiny mechanical work, balanced for instructed coding, context for reads and tools, deep for planning, analysis, and review judgment.',
         'Automatic fan-out starts at 4/6/8, or 16 for eligible mass mechanical or exploration work on the fast and context tiers.',
         'After decomposition, either lane may expand to 256 independent useful children.',
@@ -48,6 +55,8 @@ export function buildNarutoHelpResult() {
             'sks naruto status [latest|M-...] [--json]',
             'sks naruto subagents [latest|M-...] [--json]',
             'sks naruto 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] (active Codex App Naruto only)'
         ],
         commands: [...NARUTO_ACTIONS],

package/dist/core/subagents/official-subagent-runner.js

@@ -4,6 +4,7 @@ import path from 'node:path';
 import { randomId, runProcess, writeJsonAtomic } from '../fsx.js';
 import { DEFAULT_SUBAGENT_EFFORT, defaultSubagentModel, NARUTO_PARENT_EFFORT, narutoParentModel } from './model-policy.js';
 import { nextAgentGenerationEnv } from '../agents/agent-recursion-guard.js';
+import { narutoUsesCurrentSession } from './naruto-execution-mode.js';
 import { inspectDesktopBridgeCliLaunchGuard, stripRetiredDirectProviderEnv } from '../codex-control/desktop-bridge-launch-guard.js';
 import { prepareCodexAppServerRuntimeEnv } from '../codex-control/codex-app-server-runtime-env.js';
 import { assertCodexFloor } from '../codex-compat/codex-version-policy.js';
@@ -77,11 +78,7 @@ const SECRET_BEARING_ENV_KEYS = new Set([
     'all_proxy'
 ]);
 export function detectCodexAppSession(env = process.env) {
-    if (env.SKS_NARUTO_STANDALONE_CLI === '1')
-        return false;
-    if (env.SKS_NARUTO_APP_SESSION === '1')
-        return true;
-    return Boolean(env.CODEX_THREAD_ID);
+    return narutoUsesCurrentSession(env);
 }
 export function codexAppSessionKey(env = process.env) {
     if (!detectCodexAppSession(env))

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

@@ -283,6 +283,16 @@ const UPDATE_MIGRATION_STAGES = [
         min_from_version: '0.0.0',
         run: runCurrentPublicSurfaceReconcileStage
     },
+    {
+        id: 'naruto-execution-mode',
+        min_from_version: '0.0.0',
+        run: async () => {
+            const { writeNarutoExecutionMode } = await import('../subagents/naruto-execution-mode.js');
+            const initialMode = process.env.SKS_NARUTO_APP_SESSION === '1' ? 'current-session' : 'standalone';
+            const result = await writeNarutoExecutionMode(initialMode, process.env, true);
+            return { ok: true, status: 'ok', actions: [result.changed ? `naruto_execution_${initialMode}_initialized` : 'naruto_execution_preference_preserved'], blockers: [], warnings: [], detail: { mode: result.mode, initial_mode: initialMode } };
+        }
+    },
     {
         id: 'session-state-split',
         min_from_version: '0.0.0',

package/dist/core/version.js

@@ -1 +1 @@
-export const PACKAGE_VERSION = '10.5.2';
+export const PACKAGE_VERSION = '10.5.3';

package/dist/native/sks-menubar/Sources/ProvidersModelExposure.swift

@@ -78,7 +78,7 @@ extension ProvidersViewController: NSTableViewDataSource, NSTableViewDelegate {
         clear.setAccessibilityIdentifier("sks-provider-exposure-clear")
         let card = NativeView.card(
             title: "Models in Codex",
-            subtitle: "Select OpenRouter models, apply, then relaunch Codex to update its picker. Codex-LB models are included unless OpenRouter Only is on.",
+            subtitle: "Select OpenRouter models and apply. SKS rebuilds the bridge catalog and restarts a running Codex App so its picker is current. Codex-LB models are included unless OpenRouter Only is on.",
             views: [exposureStatus, exposureSearchField, scroll, ControlKit.actionRow([exposureApplyButton, clear])]
         )
         card.setAccessibilityIdentifier("sks-provider-card-model-exposure")
@@ -154,9 +154,20 @@ extension ProvidersViewController: NSTableViewDataSource, NSTableViewDelegate {
             let blocker = truth?.blockers.first.map(ProviderSecretRedactor.redact)
             let extra = self.openRouterOnlyEnabled == true ? " plus the subagent list models; Codex-LB models stay hidden while OpenRouter Only is on"
                 : self.openRouterOnlyEnabled == false ? " plus every Codex-LB model" : ""
-            let summary = completed
-                ? "Exposure applied · \(self.exposurePending.count) OpenRouter model(s)\(extra). Restart Codex to refresh its picker."
-                : blocker.map { "Exposure not applied · \($0)" } ?? "Exposure result schema invalid"
+            let restart = self.json(result.output)?["result"] as? [String: Any]
+            let codexRestart = restart?["codex_restart"] as? [String: Any]
+            let summary: String
+            if completed, codexRestart?["status"] as? String == "restarted" {
+                summary = "Exposure applied · \(self.exposurePending.count) OpenRouter model(s)\(extra). Codex restarted; its picker is current."
+            } else if completed, codexRestart?["reason"] as? String == "codex_not_running" {
+                summary = "Exposure applied · \(self.exposurePending.count) OpenRouter model(s)\(extra). Codex is not running; the picker updates on its next launch."
+            } else if completed, codexRestart?["reason"] as? String == "not_macos" {
+                summary = "Exposure applied · \(self.exposurePending.count) OpenRouter model(s)\(extra). Restart Codex on macOS to refresh its picker."
+            } else if completed {
+                summary = "Exposure applied · \(self.exposurePending.count) OpenRouter model(s)\(extra). Codex restart was skipped by policy."
+            } else {
+                summary = blocker.map { "Exposure not applied · \($0)" } ?? "Exposure result schema invalid"
+            }
             _ = self.operations.update(snapshot, state: completed ? .succeeded : .failed, stage: "complete", progress: 1, summary: summary)
             self.exposureStatus.stringValue = summary
             self.exposureStatus.textColor = completed ? .systemGreen : .systemRed

package/dist/native/sks-menubar/Sources/SettingsViewController.swift

@@ -14,8 +14,11 @@ final class SettingsViewController: NSViewController, ControlCenterPage {
     private let followCodexLifecycle = NSButton(checkboxWithTitle: "Show SKS Menu only while Codex is running", target: nil, action: nil)
     private let status = NativeView.detail("Settings use the native app configuration file.")
     private let contextStatus = NativeView.detail("Codex 1M context: checking current state…")
+    private let narutoModePopup = NSPopUpButton()
+    private let narutoModeStatus = NativeView.detail("Naruto execution mode: checking saved preference…")
     private var notificationButton: NSButton!
     private var contextToggleButton: NSButton!
+    private var narutoApplyButton: NSButton!
     private var contextEnabled: Bool?
     private var contextBusy = false
     private var contextGeneration = 0
@@ -24,6 +27,8 @@ final class SettingsViewController: NSViewController, ControlCenterPage {
     private var memoryEnabled: Bool?
     private var memoryBusy = false
     private var memoryGeneration = 0
+    private var narutoBusy = false
+    private var narutoGeneration = 0
     init(processClient: ProcessClient, operations: OperationCoordinator, notifications: NotificationCoordinator) {
         self.processClient = processClient
         self.operations = operations
@@ -44,6 +49,24 @@ final class SettingsViewController: NSViewController, ControlCenterPage {
             subtitle: "Experimental · Keep notes and retrieve earlier messages and tool results. Enabled by default in SKS. Applies to new tasks with supported Codex and eligible ChatGPT sign-in; API-key and custom-provider sessions may not activate it.",
             views: [NativeView.row([memoryToggle, NativeView.detail("Enable experimental context management")]), memoryStatus]
         )
+        narutoModePopup.removeAllItems()
+        for mode in ["auto", "current-session", "standalone"] {
+            narutoModePopup.addItem(withTitle: Self.narutoModeTitle(mode))
+            narutoModePopup.lastItem?.representedObject = mode
+        }
+        narutoModePopup.isEnabled = false
+        narutoModePopup.setAccessibilityLabel("Naruto execution mode")
+        narutoModePopup.setAccessibilityIdentifier("sks-naruto-execution-mode")
+        narutoApplyButton = ControlKit.primaryButton("Apply", target: self, action: #selector(applyNarutoExecution))
+        narutoApplyButton.isEnabled = false
+        narutoApplyButton.setAccessibilityLabel("Apply Naruto execution mode and restart Codex")
+        narutoApplyButton.setAccessibilityIdentifier("sks-naruto-execution-apply")
+        narutoModeStatus.setAccessibilityIdentifier("sks-naruto-execution-status")
+        let narutoCard = NativeView.card(
+            title: "Naruto execution",
+            subtitle: "Choose whether SKS Naruto uses the current Codex App parent or launches the official workflow as a standalone terminal command. Apply saves the preference and restarts a running Codex App so the new mode is active.",
+            views: [NativeView.row([narutoModePopup, narutoApplyButton]), narutoModeStatus]
+        )
         followCodexLifecycle.target = self; followCodexLifecycle.action = #selector(save)
         followCodexLifecycle.setAccessibilityLabel("Show SKS Menu only while Codex is running")
         notificationButton = NativeView.button("Enable Notifications", target: self, action: #selector(enableNotifications))
@@ -66,13 +89,14 @@ final class SettingsViewController: NSViewController, ControlCenterPage {
         )
         view = NativeView.page([
             ControlKit.header("Settings", "Choose how SKS works on this Mac."),
-            memoryCard, lifecycleCard, notificationsCard, NativeDisclosure("Advanced", views: [contextCard])
+            memoryCard, narutoCard, lifecycleCard, notificationsCard, NativeDisclosure("Advanced", views: [contextCard])
         ])
     }
 
     func refreshOnAppear() {
         refreshContextManagement()
         refreshContext1m()
+        refreshNarutoExecution()
         let configResult = readConfig()
         switch configResult {
         case .loaded(let config):
@@ -104,6 +128,86 @@ final class SettingsViewController: NSViewController, ControlCenterPage {
         }
     }
 
+    private static func narutoModeTitle(_ mode: String) -> String {
+        switch mode {
+        case "current-session": return "Current Codex App session"
+        case "standalone": return "Standalone terminal workflow"
+        default: return "Auto (Codex App when available)"
+        }
+    }
+
+    private func refreshNarutoExecution() {
+        guard !narutoBusy else { return }
+        narutoGeneration += 1
+        let requestGeneration = narutoGeneration
+        processClient.run(["naruto", "execution", "status", "--json"], timeout: NativeView.statusTimeout) { [weak self] result in
+            guard let self, requestGeneration == self.narutoGeneration, !self.narutoBusy else { return }
+            let payload = self.json(result.output)
+            guard result.code == 0,
+                  payload?["schema"] as? String == "sks.naruto-execution-result.v1",
+                  payload?["ok"] as? Bool == true,
+                  let mode = payload?["mode"] as? String,
+                  ["auto", "current-session", "standalone"].contains(mode) else {
+                self.narutoModePopup.isEnabled = false
+                self.narutoApplyButton.isEnabled = false
+                self.narutoModeStatus.stringValue = "Naruto execution preference unavailable. Run sks update, then reopen Settings."
+                self.narutoModeStatus.textColor = .systemOrange
+                return
+            }
+            self.narutoModePopup.selectItem(withTitle: Self.narutoModeTitle(mode))
+            self.narutoModePopup.isEnabled = true
+            self.narutoApplyButton.isEnabled = true
+            let stored = payload?["stored"] as? Bool == true
+            self.narutoModeStatus.stringValue = "\(Self.narutoModeTitle(mode)) · \(stored ? "saved preference" : "default until the next update")"
+            self.narutoModeStatus.textColor = .secondaryLabelColor
+        }
+    }
+
+    @objc private func applyNarutoExecution() {
+        guard !narutoBusy,
+              let mode = narutoModePopup.selectedItem?.representedObject as? String,
+              ["auto", "current-session", "standalone"].contains(mode) else { return }
+        guard let operation = operations.begin(kind: "naruto-execution-mode", mutationGroup: "codex-config", summary: "Apply Naruto execution mode") else {
+            narutoModeStatus.stringValue = "Another configuration change is running. Try again when it finishes."
+            narutoModeStatus.textColor = .systemOrange
+            return
+        }
+        narutoBusy = true
+        narutoGeneration += 1
+        narutoModePopup.isEnabled = false
+        narutoApplyButton.isEnabled = false
+        narutoModeStatus.stringValue = "Saving Naruto execution mode and restarting Codex if it is running…"
+        narutoModeStatus.textColor = .secondaryLabelColor
+        _ = operations.update(operation, state: .running, stage: "applying", progress: nil, summary: narutoModeStatus.stringValue)
+        processClient.run(["naruto", "execution", "set", "--mode", mode, "--restart", "--json"], timeout: NativeView.mutationTimeout) { [weak self] result in
+            guard let self else { return }
+            self.narutoBusy = false
+            let payload = self.json(result.output)
+            let ok = result.code == 0
+                && payload?["schema"] as? String == "sks.naruto-execution-result.v1"
+                && payload?["ok"] as? Bool == true
+                && payload?["mode"] as? String == mode
+            let restart = payload?["restart"] as? [String: Any]
+            let summary: String
+            if ok, restart?["status"] as? String == "restarted" {
+                summary = "Naruto mode saved · Codex restarted. Start a new task to use it."
+            } else if ok, restart?["reason"] as? String == "codex_not_running" {
+                summary = "Naruto mode saved · Codex is not running; it applies on the next launch."
+            } else if ok, restart?["reason"] as? String == "not_macos" {
+                summary = "Naruto mode saved · restart Codex on macOS to apply it."
+            } else if ok {
+                summary = "Naruto mode saved · Codex restart was skipped by policy."
+            } else {
+                let blocker = (payload?["blockers"] as? [String])?.first
+                summary = blocker.map { "Naruto mode was not confirmed · \($0)" } ?? "Naruto mode was not confirmed · unexpected CLI response."
+            }
+            _ = self.operations.update(operation, state: ok ? .succeeded : .failed, stage: "complete", progress: 1, summary: summary)
+            self.narutoModeStatus.stringValue = summary
+            self.narutoModeStatus.textColor = ok ? .systemGreen : .systemRed
+            self.refreshNarutoExecution()
+        }
+    }
+
     private func refreshContextManagement() {
         guard !memoryBusy else { return }
         memoryGeneration += 1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "10.5.2",
+  "version": "10.5.3",
   "description": "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.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",