sneakoscope 10.3.7 → 10.3.8

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

@@ -0,0 +1,107 @@
+import { consultJevOptions } from './integration.js';
+import { canonicalChildModelId, defaultSubagentEntry, subagentEntryForModel } from '../subagents/child-model-allowlist.js';
+const QUESTION_BUDGET_BYTES = 16_000;
+const TASK_CHARS = 1200;
+function optionId(index) {
+    return `m${index + 1}`;
+}
+function optionSummary(entry) {
+    const criteria = entry.criteria || 'General work; no special criteria.';
+    return `${entry.model}${entry.default ? ' (default)' : ''}: ${criteria}`;
+}
+function laneQuestionId(lane, index) {
+    const slug = String(lane.id || '').toLowerCase().replace(/[^a-z0-9_]+/g, '_').replace(/^_+|_+$/g, '').slice(0, 24);
+    return `child_model_${slug || index}`.slice(0, 40);
+}
+export function childModelQuestion(id, entries, lane) {
+    const options = {};
+    entries.forEach((entry, index) => { options[optionId(index)] = optionSummary(entry); });
+    const fallback = entries.findIndex((entry) => entry.default);
+    return {
+        id,
+        instructions: 'Choose the model on the user\'s list that should run the child task in state.task. Each option is the user\'s rule for when to use that model; follow those rules. When several fit equally, choose the default.',
+        options,
+        state: {
+            task: String(lane.task || '').slice(0, TASK_CHARS),
+            role: lane.role || null,
+            requested_model: lane.requestedModel || null,
+            default_option: optionId(fallback === -1 ? 0 : fallback)
+        }
+    };
+}
+export function fallbackChildModel(state, requestedModel, reason) {
+    const requested = subagentEntryForModel(state, requestedModel);
+    if (requested)
+        return { entry: requested, source: 'requested', reason };
+    const fallback = defaultSubagentEntry(state);
+    return fallback ? { entry: fallback, source: 'default', reason } : null;
+}
+export async function chooseChildModels(input) {
+    const entries = input.state.subagent_models;
+    const result = {};
+    if (!entries.length)
+        return result;
+    const fallbackAll = (reason) => {
+        for (const lane of input.lanes) {
+            const choice = fallbackChildModel(input.state, lane.requestedModel, reason);
+            if (choice)
+                result[lane.id] = choice;
+        }
+        return result;
+    };
+    if (entries.length === 1)
+        return fallbackAll('single_entry');
+    const asked = [];
+    const questions = [];
+    let bytes = 0;
+    input.lanes.forEach((lane, index) => {
+        const questionId = laneQuestionId(lane, index);
+        if (asked.some((row) => row.questionId === questionId))
+            return;
+        const question = childModelQuestion(questionId, entries, lane);
+        const size = Buffer.byteLength(JSON.stringify(question));
+        if (bytes + size > QUESTION_BUDGET_BYTES)
+            return;
+        bytes += size;
+        asked.push({ lane, questionId });
+        questions.push(question);
+    });
+    const decision = questions.length
+        ? await consultJevOptions({
+            root: input.root,
+            workflowId: input.workflowId,
+            goal: input.goal,
+            questions,
+            facts: { openrouter_only: true, subagent_models: entries.map((entry) => canonicalChildModelId(entry.model)) },
+            ...(input.env ? { env: input.env } : {}),
+            ...(input.deadlineMs === undefined ? {} : { deadlineMs: input.deadlineMs })
+        })
+        : { called: false, choices: {}, reason: 'budget' };
+    for (const lane of input.lanes) {
+        const questionId = asked.find((row) => row.lane === lane)?.questionId;
+        const picked = questionId ? decision.choices[questionId] : undefined;
+        const pickedIndex = picked && /^m\d+$/.test(picked) ? Number(picked.slice(1)) - 1 : -1;
+        const entry = pickedIndex >= 0 ? entries[pickedIndex] : undefined;
+        if (entry) {
+            result[lane.id] = { entry, source: 'jev', reason: 'applied' };
+            continue;
+        }
+        const reason = !questionId ? 'budget' : decision.reason === 'applied' ? 'keep_baseline' : decision.reason;
+        const choice = fallbackChildModel(input.state, lane.requestedModel, reason);
+        if (choice)
+            result[lane.id] = choice;
+    }
+    return result;
+}
+export async function chooseChildModel(input) {
+    const choices = await chooseChildModels({
+        root: input.root,
+        workflowId: 'spawn-child-model',
+        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.env ? { env: input.env } : {}),
+        ...(input.deadlineMs === undefined ? {} : { deadlineMs: input.deadlineMs })
+    });
+    return choices.spawn ?? null;
+}

package/dist/core/decisions/cli.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { printJson } from '../../cli/output.js';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
 import { resolveOpenRouterApiKey } from '../providers/openrouter/openrouter-secret-store.js';
+import { effectiveChildModelAllowlist } from '../subagents/child-model-allowlist.js';
 import { jevEnabled, readDecisionConfig, writeDecisionConfig, jevCapabilityActive } from './config.js';
 import { buildEvaluationReport } from './evaluation.js';
 import { OPENROUTER_DECISIONS_ENDPOINT, OPENROUTER_DECISIONS_MODEL, requestOpenRouterDecision } from './openrouter.js';
@@ -103,7 +104,10 @@ export async function runDecisionCommand(args, env = process.env) {
                 output(report, json, () => [
                     `mode: ${report.mode}  consent: ${report.consentCloud}  credential: ${report.credential.present ? report.credential.source : 'missing'}`,
                     `model: ${report.model}  endpoint: ${report.endpoint}`,
-                    `capabilities: context=${report.capabilities.context.ready ? 'ready' : 'off'} plan=${report.capabilities.plan.ready ? 'ready' : 'off'} recovery=${report.capabilities.recovery.reason}`
+                    `capabilities: context=${report.capabilities.context.ready ? 'ready' : 'off'} plan=${report.capabilities.plan.ready ? 'ready' : 'off'} recovery=${report.capabilities.recovery.reason}`,
+                    ...(report.openrouter_only.enabled
+                        ? [`openrouter-only: on · child models by ${report.openrouter_only.child_model_decision} · ${report.openrouter_only.subagent_model_count} listed`]
+                        : [])
                 ]);
                 return 0;
             }
@@ -139,6 +143,11 @@ export async function statusReport(env) {
         : !jevEnabled(config)
             ? 'enable'
             : 'ready';
+    const childModels = effectiveChildModelAllowlist({ env });
+    const openRouterOnly = childModels.mode === 'openrouter_only';
+    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));
     return {
         schema: 'sks.jev-decision-status.v1',
         ok: true,
@@ -158,8 +167,16 @@ export async function statusReport(env) {
             recovery: config.capabilities.recovery
         },
         decision_points: jevEnabled(config)
-            ? ['turn_route', 'turn_tier', 'spawn_tier', 'worker_tier', 'role_tiers', 'role_omission', 'plan', 'context', 'parent_edit_delegation', 'image_need', 'image_parameters', 'qa_effort_escalation']
+            ? [...decisionPoints, ...(openRouterOnly ? ['child_model'] : [])]
             : [],
+        openrouter_only: {
+            enabled: openRouterOnly,
+            subagent_model_count: openRouterOnly ? childModels.models.length : 0,
+            default_subagent_model: childModels.default_model,
+            child_model_decision: !openRouterOnly
+                ? null
+                : jevEnabled(config) && resolved.key && childModels.models.length > 1 ? 'jev' : 'default_entry'
+        },
         recovery: RECOVERY_CAPABILITY,
         nextStep,
         notes: [

package/dist/core/decisions/routing.js

@@ -1,4 +1,5 @@
-import { effortForTier, latestTierModelSet, resolveLatestModelTiers } from '../subagents/model-tiers.js';
+import { effortForTier, resolveLatestModelTiers } from '../subagents/model-tiers.js';
+import { effectiveChildModelAllowlist, isAllowedChildModel } from '../subagents/child-model-allowlist.js';
 import { routingTier } from './types.js';
 const ROLE_ID = /^[a-z][a-z0-9_]{0,40}$/;
 export const MAX_JEV_ROUTING_ROLES = 8;
@@ -16,14 +17,14 @@ export function buildRoutingCandidates(input) {
     }
     return out;
 }
-export function applySealedRouting(agents, selected) {
+export function applySealedRouting(agents, selected, allowlist) {
     if (!selected || !agents)
         return { ...(agents || {}) };
     const next = { ...agents };
-    const current = latestTierModelSet();
+    const childModels = allowlist ?? effectiveChildModelAllowlist();
     for (const [name, effort] of Object.entries(selected.efforts)) {
         const model = selected.models[name];
-        if (!model || !current.has(model))
+        if (!model || !isAllowedChildModel(model, childModels))
             continue;
         const row = next[name];
         if (!row || row.routing_dynamic !== true || row.routed_model_policy === 'user_role_model_preference')

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

@@ -8,6 +8,8 @@ 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 { renderChildModelCriteria, SUBAGENT_MODELS_SETTINGS_HINT } from './subagent-spawn-policy.js';
 import { extractUserPrompt, looksLikeCodexGitAction, looksLikeCodexUiSettingsEvent } from './payload-signals.js';
 const STANDALONE_PARENT_BASE_SKILLS = [
     'sks-naruto',
@@ -15,14 +17,25 @@ const STANDALONE_PARENT_BASE_SKILLS = [
     'sks-prompt-pipeline',
     'sks-honest-mode'
 ];
-const OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT = [
+const OFFICIAL_SUBAGENT_SPAWN_CONTRACT_HEAD = [
     'SKS official-subagent spawn contract:',
     '- Full-history forks (`fork_turns="all"`, including the omitted/default full-history mode) inherit the parent agent type, model, and reasoning effort.',
-    '- When selecting a custom `agent_type` or overriding `model`/`reasoning_effort`, set `fork_turns="none"` or a positive bounded turn count and put the complete bounded slice contract in `message`.',
+    '- When selecting a custom `agent_type` or overriding `model`/`reasoning_effort`, set `fork_turns="none"` or a positive bounded turn count and put the complete bounded slice contract in `message`.'
+];
+const OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT = [
+    ...OFFICIAL_SUBAGENT_SPAWN_CONTRACT_HEAD,
     '- SKS children must pass the slice contract `model` (the newest model of the role tier), its `reasoning_effort`, and `fork_turns=\"none\"` or a positive bounded turn count. When Jev mode is on, the SKS PreToolUse hook seals Jev\'s tier on every spawn, so do not tune model or effort yourself. A stored user role-model preference wins.'
 ].join('\n');
-export function officialSubagentSpawnCompatibilityContext() {
-    return OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT;
+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 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.`;
+}
+export function officialSubagentSpawnCompatibilityContext(allowlist = effectiveChildModelAllowlist()) {
+    if (allowlist.mode !== 'openrouter_only')
+        return OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT;
+    return [...OFFICIAL_SUBAGENT_SPAWN_CONTRACT_HEAD, openRouterOnlyChildModelLine(allowlist)].join('\n');
 }
 export function attachOfficialSubagentSpawnCompatibilityContext(state, payload, result) {
     if (result?.decision === 'block' || result?.sksTaskProfile === 'passthrough')
@@ -35,11 +48,12 @@ export function attachOfficialSubagentSpawnCompatibilityContext(state, payload,
     if (!officialSubagentsRequiredForPromptOrState(state, prompt, result))
         return result;
     const existing = String(result?.additionalContext || '');
-    if (existing.includes(OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT))
+    const spawnContract = officialSubagentSpawnCompatibilityContext();
+    if (existing.includes(spawnContract))
         return result;
     return {
         ...result,
-        additionalContext: [OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT, existing].filter(Boolean).join('\n\n')
+        additionalContext: [spawnContract, existing].filter(Boolean).join('\n\n')
     };
 }
 export async function attachAuthoritativeSksSkillContext(root, state, payload, result) {
@@ -207,7 +221,7 @@ export async function hookActiveSkillContextRefresh(root, state, name) {
         };
     }
     const spawnCompatibility = officialSubagentsRequiredForPromptOrState(state, '', {})
-        ? OFFICIAL_SUBAGENT_SPAWN_COMPATIBILITY_CONTEXT
+        ? officialSubagentSpawnCompatibilityContext()
         : '';
     const refresh = await activeAuthoritativeSksSkillRefresh(root, state, { includeContext: true });
     if (refresh.blocked) {

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

@@ -32,8 +32,9 @@ export function normalizeHookResult(name, result = {}) {
         if (out.decision === 'block' || out.permissionDecision === 'deny' || out.decision === 'deny') {
             return buildPreToolUseDeny(reason, { systemMessage });
         }
-        if (out.updatedInput)
-            return buildPreToolUseAllowRewrite(out.updatedInput, { systemMessage });
+        if (out.updatedInput) {
+            return buildPreToolUseAllowRewrite(out.updatedInput, { additionalContext: out.additionalContext, systemMessage });
+        }
         return buildPreToolUseContinue({ additionalContext: out.additionalContext, systemMessage });
     }
     if (eventName === 'PermissionRequest') {

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

@@ -1,8 +1,12 @@
 import { consultJevTurnModel } from '../decisions/integration.js';
+import { chooseChildModel, fallbackChildModel } from '../decisions/child-model-choice.js';
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
+import { OPENROUTER_ONLY_SCHEMA, effectiveChildModelAllowlist, isSubagentModelEffort } from '../subagents/child-model-allowlist.js';
 import { subagentModelProfile } from '../subagents/model-policy.js';
 import { effortForTier, latestModelForTier, latestTierModelSet } from '../subagents/model-tiers.js';
 import { readRoleModelPreferences } from '../subagents/role-model-preferences.js';
+import { READ_ONLY_LIST_ROLE } from '../subagents/read-only-list-role.js';
+import { boundedForkTurns, fullHistoryForkContext, renderChildModelList, SUBAGENT_MODELS_SETTINGS_HINT } from './subagent-spawn-policy.js';
 const SPAWN_TOOLS = new Set(['spawn_agent', 'collaboration.spawn_agent', 'functions.spawn_agent']);
 function spawnInput(payload) {
     const name = String(payload?.tool_name || payload?.toolName || payload?.tool?.name || '');
@@ -18,8 +22,16 @@ function narutoParent(state) {
     const route = String(state?.route || state?.route_command || '').replace(/^\$/, '').toUpperCase();
     return mode === 'NARUTO' || route === 'NARUTO' || state?.subagents_required === true;
 }
-function spawnTask(input) {
-    return [input.message, input.prompt, input.task, input.agent_type, input.agentType]
+function itemTexts(items) {
+    if (!Array.isArray(items))
+        return [];
+    return items
+        .filter((item) => item && typeof item === 'object' && item.type === 'text')
+        .map((item) => item.text);
+}
+function spawnTask(input, opts = {}) {
+    const items = opts.items ? itemTexts(input.items) : [];
+    return [input.message, input.prompt, input.task, ...items, input.agent_type, input.agentType]
         .map((value) => String(value || '').trim())
         .filter(Boolean)
         .join('\n')
@@ -33,11 +45,68 @@ export function roleTierFallback(agentType) {
     }
     return { model: latestModelForTier('deep'), effort: effortForTier('deep') };
 }
-export async function jevSpawnModelRewrite(root, state, payload) {
-    if (!narutoParent(state))
-        return null;
+export async function jevSpawnRouting(root, state, payload) {
     const input = spawnInput(payload);
     if (!input)
+        return { input: null, route: null };
+    const allowlist = effectiveChildModelAllowlist();
+    if (allowlist.mode === 'openrouter_only')
+        return openRouterOnlySpawnRouting(root, state, input, allowlist);
+    return { input: await tierSpawnRewrite(root, state, input), route: null };
+}
+export async function jevSpawnModelRewrite(root, state, payload) {
+    return (await jevSpawnRouting(root, state, payload)).input;
+}
+function listState(allowlist) {
+    return { schema: OPENROUTER_ONLY_SCHEMA, enabled: true, subagent_models: allowlist.entries, restore: null, updated_at: null };
+}
+async function openRouterOnlySpawnRouting(root, parentState, input, allowlist) {
+    if (fullHistoryForkContext(input))
+        return { input: null, route: null };
+    const forkTurns = input.fork_turns === undefined && narutoParent(parentState) ? 'none' : input.fork_turns;
+    if (!boundedForkTurns(forkTurns))
+        return { input: null, route: null };
+    const state = listState(allowlist);
+    const requested = String(input.model || '').trim() || null;
+    const agent = String(input.agent_type || input.agentType || '').trim() || null;
+    const task = spawnTask(input, { items: true });
+    const choice = task
+        ? await chooseChildModel({ root, task, role: agent, requestedModel: requested, state })
+            .catch(() => fallbackChildModel(state, requested, 'consult_failed'))
+        : fallbackChildModel(state, requested, 'empty_task');
+    if (!choice)
+        return { input: null, route: null };
+    const route = {
+        mode: 'openrouter_only',
+        model: choice.entry.model,
+        source: choice.source,
+        reason: choice.reason
+    };
+    const next = { ...input, model: choice.entry.model };
+    const managed = agent ? managedOfficialSubagentRoleByName(agent) : null;
+    if (managed) {
+        delete next.agentType;
+        if (managed.sandbox === 'read-only')
+            next.agent_type = READ_ONLY_LIST_ROLE.codex_name;
+        else
+            delete next.agent_type;
+    }
+    const effort = choice.entry.reasoning_effort
+        || (isSubagentModelEffort(input.reasoning_effort) ? input.reasoning_effort : null);
+    if (effort)
+        next.reasoning_effort = effort;
+    else
+        delete next.reasoning_effort;
+    next.fork_turns = forkTurns;
+    const unchanged = !managed
+        && input.model === next.model
+        && input.reasoning_effort === next.reasoning_effort
+        && Object.hasOwn(input, 'reasoning_effort') === Object.hasOwn(next, 'reasoning_effort')
+        && input.fork_turns === next.fork_turns;
+    return { input: unchanged ? null : next, route };
+}
+async function tierSpawnRewrite(root, state, input) {
+    if (!narutoParent(state))
         return null;
     const agent = String(input.agent_type || input.agentType || '').trim();
     if (agent) {
@@ -67,3 +136,12 @@ export async function jevSpawnModelRewrite(root, state, payload) {
         ...forkTurns
     };
 }
+export function openRouterOnlyJevTurnLine(allowlist, effort, orchestrationRequired) {
+    const hint = effort
+        ? `Jev rated this ${orchestrationRequired ? 'task' : 'turn'} as ${effort}-effort work; the parent model, effort, and service tier stay as the user set them. `
+        : '';
+    const list = allowlist.entries.length
+        ? `every spawn_agent child runs a model from the user's subagent list (${renderChildModelList(allowlist)}); Jev picks the list model for each spawn from the user's criteria, and any other model is denied.`
+        : `the subagent model list is empty, so spawn_agent is denied until the user adds models in ${SUBAGENT_MODELS_SETTINGS_HINT}.`;
+    return `${hint}SKS OpenRouter Only mode: ${list}`;
+}

package/dist/core/hooks-runtime/official-subagent-lifecycle.js

@@ -308,7 +308,8 @@ async function refreshOfficialSubagentCompletionArtifactsLocked(root, state, par
     }
     const previousGate = existingGate || {};
     const parentModel = plan.observed_parent_model || state.observed_parent_model || null;
-    const parentModelMismatch = previousGate.parent_model_match === false || observedParentModelMismatch(parentModel, narutoParentModel());
+    const expectedParentModel = typeof plan.parent_model_policy === 'string' && plan.parent_model_policy ? plan.parent_model_policy : narutoParentModel();
+    const parentModelMismatch = previousGate.parent_model_match === false || observedParentModelMismatch(parentModel, expectedParentModel);
     const blockers = [...new Set([
             ...evidence.blockers,
             ...(Array.isArray(previousGate.config_blockers) ? previousGate.config_blockers.map(String) : []),
@@ -329,7 +330,7 @@ async function refreshOfficialSubagentCompletionArtifactsLocked(root, state, par
         route: '$Naruto',
         status: passed ? 'completed' : evidence.status,
         parent: {
-            model: narutoParentModel(),
+            model: expectedParentModel,
             model_reasoning_effort: NARUTO_PARENT_EFFORT,
             observed_model: parentModel,
             observed_model_match: parentModel ? !parentModelMismatch : null

package/dist/core/hooks-runtime/parent-orchestration-gate.js

@@ -28,6 +28,14 @@ const SHELL_WRITE_RE = new RegExp([
 const PATCH_FILE_RE = /\*\*\*\s+(?:Update|Add|Delete|Move to)\s+File:\s*([^\n\r]+)/g;
 const PATCH_HEADER_RE = /\*\*\*\s+(?:Update|Add|Delete|Move to)\s+File:/;
 const SHELL_PATH_TOKEN_RE = /(?:^|\s)((?:\.{1,2}\/|\/|~\/)?[\w@.+-]+(?:\/[\w@.+-]+)+|[\w@+-]+\.[a-z0-9]{1,8})(?=\s|$)/gi;
+function spawnRouteOf(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const row = raw;
+    const text = (value) => String(value ?? '').trim().slice(0, 200);
+    const route = { mode: text(row.mode), model: text(row.model), source: text(row.source), reason: text(row.reason) };
+    return route.mode && route.model && route.source ? route : null;
+}
 export function isSpawnToolPayload(payload = {}) {
     return SPAWN_TOOL_RE.test(toolNameOf(payload));
 }
@@ -193,6 +201,7 @@ export async function readParentOrchestrationLedger(root, missionId, workflowRun
         return fresh;
     if (workflowRunId && raw.workflow_run_id && String(raw.workflow_run_id) !== workflowRunId)
         return fresh;
+    const spawnRoute = spawnRouteOf(raw.last_spawn_route);
     return {
         ...fresh,
         workflow_run_id: workflowRunId || (typeof raw.workflow_run_id === 'string' ? raw.workflow_run_id : null),
@@ -207,6 +216,7 @@ export async function readParentOrchestrationLedger(root, missionId, workflowRun
         last_tool: typeof raw.last_tool === 'string' ? raw.last_tool : null,
         last_targets: Array.isArray(raw.last_targets) ? raw.last_targets.map((row) => String(row)).slice(0, MAX_TARGETS) : [],
         last_jev_reason: typeof raw.last_jev_reason === 'string' ? raw.last_jev_reason : null,
+        ...(spawnRoute ? { last_spawn_route: spawnRoute } : {}),
         updated_at: typeof raw.updated_at === 'string' ? raw.updated_at : null
     };
 }
@@ -227,7 +237,14 @@ export async function recordParentOrchestrationSpawn(root, state = {}, opts = {}
     const ledger = await readParentOrchestrationLedger(root, missionId, workflowRunId);
     if (opts.atLeastOne && ledger.spawns > 0)
         return ledger;
-    const next = { ...ledger, spawns: ledger.spawns + 1, last_action: 'spawn' };
+    const spawnRoute = spawnRouteOf(opts.spawnRoute);
+    const { last_spawn_route: _previousRoute, ...rest } = ledger;
+    const next = {
+        ...rest,
+        spawns: ledger.spawns + 1,
+        last_action: 'spawn',
+        ...(spawnRoute ? { last_spawn_route: spawnRoute } : {})
+    };
     await writeLedger(root, next);
     return next;
 }

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

@@ -1,8 +1,10 @@
 import path from 'node:path';
 import { readJson } from '../fsx.js';
 import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
-import { latestModelForTier, latestTierModelSet } from '../subagents/model-tiers.js';
+import { latestModelForTier } from '../subagents/model-tiers.js';
+import { effectiveChildModelAllowlist } from '../subagents/child-model-allowlist.js';
 import { jevEnabled, readDecisionConfig } from '../decisions/config.js';
+import { renderChildModelList } from './subagent-spawn-policy.js';
 export async function sealedSubagentRoutingContext(artifactDir, payload = {}) {
     const plan = await readJson(path.join(artifactDir, 'subagent-plan.json'), null).catch(() => null);
     if (!plan || plan.workflow !== 'official_codex_subagent')
@@ -13,6 +15,15 @@ export async function sealedSubagentRoutingContext(artifactDir, payload = {}) {
     const role = agentName ? managedOfficialSubagentRoleByName(agentName) : null;
     if (!agentName)
         return '';
+    const allowlist = effectiveChildModelAllowlist();
+    if (allowlist.mode === 'openrouter_only') {
+        return [
+            'SKS sealed child routing:',
+            `- custom agent: ${agentName}`,
+            `- model and model_reasoning_effort: sealed on the spawn call from the OpenRouter Only subagent list (${renderChildModelList(allowlist) || 'empty'})`,
+            '- keep this sealed profile; do not retarget model/effort or spawn nested agents'
+        ].join('\n');
+    }
     const narutoPlan = plan.mode === 'naruto' || plan.route === '$Naruto';
     const jevSealed = await readDecisionConfig().then(jevEnabled).catch(() => false);
     if (jevSealed) {
@@ -24,7 +35,7 @@ export async function sealedSubagentRoutingContext(artifactDir, payload = {}) {
         ].join('\n');
     }
     const plannedModel = String(planned?.routed_model || planned?.model || '').trim();
-    const sealedModels = latestTierModelSet();
+    const sealedModels = new Set(allowlist.models);
     const model = narutoPlan && sealedModels.has(plannedModel) ? plannedModel : (role?.model || latestModelForTier('deep'));
     const effort = String((model === plannedModel
         ? planned?.routed_model_reasoning_effort || planned?.model_reasoning_effort

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

@@ -1,16 +1,59 @@
-import { latestTierModelSet } from '../subagents/model-tiers.js';
+import { managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
+import { READ_ONLY_LIST_ROLE } from '../subagents/read-only-list-role.js';
+import { effectiveChildModelAllowlist, isAllowedChildModel } from '../subagents/child-model-allowlist.js';
 const SPAWN_TOOLS = new Set(['spawn_agent', 'collaboration.spawn_agent', 'functions.spawn_agent']);
+export const SUBAGENT_MODELS_SETTINGS_HINT = 'SKS Control Center > Subagent Models';
+export function renderChildModelList(allowlist) {
+    if (allowlist.mode !== 'openrouter_only')
+        return allowlist.models.join(', ');
+    return allowlist.entries.map((entry) => `${entry.model}${entry.default ? ' (default)' : ''}`).join(', ');
+}
+export function renderChildModelCriteria(allowlist) {
+    if (allowlist.mode !== 'openrouter_only')
+        return allowlist.models.join(', ');
+    return allowlist.entries
+        .map((entry) => `${entry.model}${entry.default ? ' (default)' : ''}: ${entry.criteria || 'general work'}`)
+        .join('; ');
+}
+function openRouterOnlyBlockReason(allowlist) {
+    if (!allowlist.models.length && allowlist.mode === 'openrouter_only' && allowlist.unroutable?.length) {
+        return `SKS OpenRouter Only mode: no model on the subagent list has an OpenRouter route right now (${allowlist.unroutable.join(', ')}), so no child may be spawned. Ask the user to replace them in ${SUBAGENT_MODELS_SETTINGS_HINT}, then retry spawn_agent. Do not implement the slice in the parent instead.`;
+    }
+    if (!allowlist.models.length) {
+        return `SKS OpenRouter Only mode is on but the subagent model list is empty, so no child may be spawned. Ask the user to add models in ${SUBAGENT_MODELS_SETTINGS_HINT} (or to turn OpenRouter Only off), then retry spawn_agent. Do not implement the slice in the parent instead.`;
+    }
+    return `SKS OpenRouter Only mode: children may run only a model on the user's subagent list: ${renderChildModelList(allowlist)}. Every other model is denied. Retry spawn_agent with one of them (the SKS hook routes each spawn to a list model, by Jev when Jev mode is on) and fork_turns="none" or a positive bounded turn count. Include the complete slice contract in message; do not inherit the parent model. The user adds models in ${SUBAGENT_MODELS_SETTINGS_HINT}.`;
+}
+export function fullHistoryForkContext(input) {
+    return input.fork_context === true || String(input.fork_context ?? '').trim().toLowerCase() === 'true';
+}
+export function boundedForkTurns(value) {
+    return value === 'none' || /^[1-9]\d*$/.test(String(value || ''));
+}
+const FORK_BLOCK_REASON = 'SKS child spawns require fork_turns="none" or a positive bounded turn count. Retry with the complete slice contract in message; full-history/default forks cannot carry an explicit child model.';
 export function subagentSpawnPolicyBlockReason(payload = {}) {
     const name = String(payload.tool_name || payload.toolName || payload.tool?.name || '');
     if (!SPAWN_TOOLS.has(name))
         return null;
     const input = payload.tool_input || payload.toolInput || payload.tool?.input || {};
-    const allowed = latestTierModelSet();
-    if (!allowed.has(String(input.model || ''))) {
-        return `SKS children must name a current model: ${[...allowed].join(', ')} (the latest fast, balanced, context, or deep tier). Retry spawn_agent with the slice contract model, which the SKS hook re-seals when Jev mode is on, and fork_turns="none" or a positive bounded turn count. Include the complete slice contract in message; do not inherit the parent model.`;
+    const allowlist = effectiveChildModelAllowlist();
+    if (allowlist.mode === 'openrouter_only') {
+        if (!isAllowedChildModel(input.model, allowlist))
+            return openRouterOnlyBlockReason(allowlist);
+        if (fullHistoryForkContext(input))
+            return `${FORK_BLOCK_REASON} Omit fork_context (fork_context=true is a full-history fork).`;
+        const agent = String(input.agent_type || input.agentType || '').trim();
+        if (agent && managedOfficialSubagentRoleByName(agent)) {
+            return `SKS OpenRouter Only mode: agent_type "${agent}" pins a tier model, so it cannot run a list model. Omit agent_type and put the role brief in message; read-only slices pass agent_type="${READ_ONLY_LIST_ROLE.codex_name}".`;
+        }
     }
-    if (input.fork_turns !== 'none' && !/^[1-9]\d*$/.test(String(input.fork_turns || ''))) {
-        return 'SKS child spawns require fork_turns="none" or a positive bounded turn count. Retry with the complete slice contract in message; full-history/default forks cannot carry an explicit child model.';
+    else {
+        const allowed = new Set(allowlist.models);
+        if (!allowed.has(String(input.model || ''))) {
+            return `SKS children must name a current model: ${[...allowed].join(', ')} (the latest fast, balanced, context, or deep tier). Retry spawn_agent with the slice contract model, which the SKS hook re-seals when Jev mode is on, and fork_turns="none" or a positive bounded turn count. Include the complete slice contract in message; do not inherit the parent model.`;
+        }
     }
+    if (!boundedForkTurns(input.fork_turns))
+        return FORK_BLOCK_REASON;
     return null;
 }

package/dist/core/hooks-runtime.js

@@ -31,7 +31,8 @@ import { activeNarutoParentLaunchMissionId, claimStandaloneParentHostCapabilityR
 import { classifyTaskProfile } from './runtime/task-profile.js';
 import { resolveSubagentThreadBudget } from './subagents/thread-budget.js';
 import { readOfficialSubagentConfig } from './subagents/official-subagent-config.js';
-import { jevSpawnModelRewrite } from './hooks-runtime/jev-spawn-routing.js';
+import { jevSpawnRouting, openRouterOnlyJevTurnLine } from './hooks-runtime/jev-spawn-routing.js';
+import { effectiveChildModelAllowlist } from './subagents/child-model-allowlist.js';
 import { maybeReconcileManagedGuidancePreflight } from './hooks-runtime/managed-guidance-preflight.js';
 import { evaluateParentOrchestrationGate, isSpawnToolPayload, recordParentOrchestrationSpawn } from './hooks-runtime/parent-orchestration-gate.js';
 import { subagentSpawnPolicyBlockReason } from './hooks-runtime/subagent-spawn-policy.js';
@@ -295,11 +296,15 @@ async function attachJevTurnRouting(root, payload, result, orchestrationRequired
     if (plan?.routeOverride) {
         result = attachContextLine(result, `Jev routed this prompt to the ${plan.routeOverride.routeId} pipeline (the keyword router guessed ${plan.baselineRouteId || 'none'}).`);
     }
-    const line = decision.model
+    const tierLine = decision.model
         ? orchestrationRequired
             ? `Jev rated this task as ${decision.model} (${decision.effort}). Use that as the default child seal; Jev re-seals every spawn_agent call and the parent model stays as the user set it.`
             : `Jev rated this turn as ${decision.effort}-effort work (${decision.model} tier). Treat it as this turn's reasoning hint; the parent model, effort, and service tier stay as the user set them.`
         : '';
+    const allowlist = effectiveChildModelAllowlist();
+    const line = allowlist.mode === 'openrouter_only'
+        ? openRouterOnlyJevTurnLine(allowlist, decision.effort, orchestrationRequired)
+        : tierLine;
     if (!line)
         return { ...result, jev_turn: decision };
     const additionalContext = [result.additionalContext, line].filter(Boolean).join('\n\n');
@@ -649,7 +654,8 @@ async function consumeActiveOfficialWorkflowQueue(root, missionId, workflowRunId
     }
 }
 async function hookPreTool(root, state, payload, noQuestion, sessionKey = null) {
-    const jevSpawnInput = await jevSpawnModelRewrite(root, state, payload).catch(() => null);
+    const jevSpawn = await jevSpawnRouting(root, state, payload).catch(() => null);
+    const jevSpawnInput = jevSpawn?.input ?? null;
     const spawnPayload = jevSpawnInput
         ? { ...payload, tool_input: jevSpawnInput, toolInput: jevSpawnInput }
         : payload;
@@ -724,8 +730,9 @@ async function hookPreTool(root, state, payload, noQuestion, sessionKey = null)
     const hostCapabilityDecision = await enforceHostCapabilityPreTool(root, state, payload, sessionKey);
     if (hostCapabilityDecision && hostCapabilityDecision.continue !== true)
         return hostCapabilityDecision;
-    if (isSpawnToolPayload(spawnPayload))
-        await recordParentOrchestrationSpawn(root, state).catch(() => null);
+    if (isSpawnToolPayload(spawnPayload)) {
+        await recordParentOrchestrationSpawn(root, state, jevSpawn?.route ? { spawnRoute: jevSpawn.route } : {}).catch(() => null);
+    }
     const waveGuidance = await parentWaveGuidanceContext(root, state, sessionKey).catch(() => '');
     const escapeNote = orchestration?.action === 'escape' ? orchestration.message || '' : '';
     const additionalContext = [skillRefresh.context, waveGuidance, escapeNote].filter(Boolean).join('\n\n');

package/dist/core/managed-assets/managed-assets-manifest.js

@@ -551,21 +551,26 @@ export function managedOfficialSubagentRoleBody(role) {
     ].join('\n');
 }
 export function managedOfficialSubagentRoleContent(role) {
-    const body = managedOfficialSubagentRoleBody(role);
+    return managedOfficialSubagentFileContent(role.id, role.schema_version, managedOfficialSubagentRoleBody(role));
+}
+export function managedOfficialSubagentFileContent(id, schemaVersion, body) {
     return [
         `# ${MANAGED_OFFICIAL_SUBAGENT_MARKER}`,
-        `# sks_managed_schema = ${role.schema_version}`,
-        `# sks_managed_id = "${role.id}"`,
+        `# sks_managed_schema = ${schemaVersion}`,
+        `# sks_managed_id = "${id}"`,
         `# sks_managed_body_sha256 = "${sha256(body)}"`,
         '',
         body
     ].join('\n');
 }
 export function managedOfficialSubagentRoleOwnsText(text, role) {
+    return managedOfficialSubagentFileOwnsText(text, role.id);
+}
+export function managedOfficialSubagentFileOwnsText(text, id) {
     const source = String(text || '');
     if (!source.includes(`# ${MANAGED_OFFICIAL_SUBAGENT_MARKER}`))
         return false;
-    if (!source.includes(`sks_managed_id = "${role.id}"`))
+    if (!source.includes(`sks_managed_id = "${id}"`))
         return false;
     const lines = source.split('\n');
     const hashIndex = lines.findIndex((line) => /^#\s*sks_managed_body_sha256\s*=/.test(line.trim()));