sneakoscope 10.3.7 → 10.3.8

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

@@ -0,0 +1,179 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { isOpenRouterModelId } from '../imagegen/imagegen-config.js';
+import { latestTierModelSet } from './model-tiers.js';
+export const OPENROUTER_ONLY_SCHEMA = 'sks.openrouter-only.v1';
+export const OPENROUTER_ONLY_FILENAME = 'sks-openrouter-only.json';
+export const MAX_SUBAGENT_MODELS = 16;
+export const MAX_SUBAGENT_CRITERIA_CHARS = 240;
+export const SUBAGENT_MODEL_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
+export function openRouterOnlyStatePath(input = {}) {
+    const env = input.env || process.env;
+    return path.join(input.home || env.HOME || os.homedir(), '.codex', 'sks', OPENROUTER_ONLY_FILENAME);
+}
+export function defaultOpenRouterOnlyState() {
+    return { schema: OPENROUTER_ONLY_SCHEMA, enabled: false, subagent_models: [], restore: null, updated_at: null };
+}
+export function canonicalChildModelId(value) {
+    return String(value ?? '').trim().toLowerCase();
+}
+export function isSubagentModelEffort(value) {
+    return typeof value === 'string' && SUBAGENT_MODEL_EFFORTS.includes(value);
+}
+function cleanCriteria(value) {
+    return String(value ?? '')
+        .replace(/[\u0000-\u001f\u007f]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, MAX_SUBAGENT_CRITERIA_CHARS);
+}
+export function normalizeSubagentModelList(raw) {
+    const rows = Array.isArray(raw) ? raw : [];
+    const issues = [];
+    const entries = [];
+    const seen = new Set();
+    rows.forEach((row, index) => {
+        const record = row && typeof row === 'object' ? row : {};
+        const model = String(record.model ?? '').trim();
+        if (!isOpenRouterModelId(model)) {
+            issues.push({ index, code: 'subagent_model_id_invalid' });
+            return;
+        }
+        const key = canonicalChildModelId(model);
+        if (seen.has(key)) {
+            issues.push({ index, code: 'subagent_model_duplicate' });
+            return;
+        }
+        const effort = record.reasoning_effort ?? null;
+        if (effort !== null && effort !== '' && !isSubagentModelEffort(effort)) {
+            issues.push({ index, code: 'subagent_model_effort_invalid' });
+            return;
+        }
+        if (entries.length >= MAX_SUBAGENT_MODELS) {
+            issues.push({ index, code: 'subagent_model_list_too_long' });
+            return;
+        }
+        seen.add(key);
+        entries.push({
+            model: key,
+            criteria: cleanCriteria(record.criteria),
+            reasoning_effort: isSubagentModelEffort(effort) ? effort : null,
+            default: record.default === true
+        });
+    });
+    const firstDefault = entries.findIndex((entry) => entry.default);
+    entries.forEach((entry, index) => { entry.default = index === (firstDefault === -1 ? 0 : firstDefault); });
+    return { entries, issues };
+}
+function normalizeRestore(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const record = raw;
+    const text = (value) => (typeof value === 'string' && value.trim() ? value.trim() : null);
+    return { previous_model: text(record.previous_model), applied_model: text(record.applied_model) };
+}
+export function normalizeOpenRouterOnlyState(raw) {
+    if (!raw || typeof raw !== 'object')
+        return defaultOpenRouterOnlyState();
+    const record = raw;
+    if (record.schema !== OPENROUTER_ONLY_SCHEMA)
+        return defaultOpenRouterOnlyState();
+    return {
+        schema: OPENROUTER_ONLY_SCHEMA,
+        enabled: record.enabled === true,
+        subagent_models: normalizeSubagentModelList(record.subagent_models).entries,
+        restore: normalizeRestore(record.restore),
+        updated_at: typeof record.updated_at === 'string' ? record.updated_at : null
+    };
+}
+export function readOpenRouterOnlyStateSync(input = {}) {
+    try {
+        return normalizeOpenRouterOnlyState(JSON.parse(fs.readFileSync(openRouterOnlyStatePath(input), 'utf8')));
+    }
+    catch {
+        return defaultOpenRouterOnlyState();
+    }
+}
+export async function readOpenRouterOnlyState(input = {}) {
+    return readOpenRouterOnlyStateSync(input);
+}
+export async function writeOpenRouterOnlyState(update, input = {}) {
+    const current = readOpenRouterOnlyStateSync(input);
+    const next = normalizeOpenRouterOnlyState({
+        ...current,
+        ...update,
+        schema: OPENROUTER_ONLY_SCHEMA,
+        updated_at: nowIso()
+    });
+    await writeJsonAtomic(openRouterOnlyStatePath(input), next, { mode: 0o600 });
+    return next;
+}
+export function defaultSubagentEntry(state) {
+    return state.subagent_models.find((entry) => entry.default) || state.subagent_models[0] || null;
+}
+export function subagentEntryForModel(state, model) {
+    const key = canonicalChildModelId(model);
+    if (!key)
+        return null;
+    return state.subagent_models.find((entry) => canonicalChildModelId(entry.model) === key) || null;
+}
+function openRouterRoutedModels(input) {
+    const env = input.env || process.env;
+    const file = path.join(input.home || env.HOME || os.homedir(), '.codex', 'sks', 'sks-bridge-route-policy.json');
+    try {
+        const routes = JSON.parse(fs.readFileSync(file, 'utf8'))?.model_routes;
+        if (!routes || typeof routes !== 'object')
+            return null;
+        const routed = new Set();
+        for (const [key, route] of Object.entries(routes)) {
+            if (route?.provider_id === 'openrouter')
+                routed.add(canonicalChildModelId(key.replace(/^openrouter:/i, '')));
+        }
+        return routed.size ? routed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function routableSubagentState(state, input = {}) {
+    const routed = openRouterRoutedModels(input);
+    if (!routed)
+        return { state, unroutable: [] };
+    const keep = state.subagent_models.filter((entry) => routed.has(canonicalChildModelId(entry.model)));
+    const unroutable = state.subagent_models.filter((entry) => !keep.includes(entry)).map((entry) => entry.model);
+    if (!unroutable.length)
+        return { state, unroutable };
+    const preferred = keep.findIndex((entry) => entry.default);
+    const entries = keep.map((entry, index) => ({ ...entry, default: index === (preferred === -1 ? 0 : preferred) }));
+    return { state: { ...state, subagent_models: entries }, unroutable };
+}
+export function effectiveChildModelAllowlist(input = {}) {
+    const stored = readOpenRouterOnlyStateSync(input);
+    if (stored.enabled) {
+        const { state, unroutable } = routableSubagentState(stored, input);
+        return {
+            mode: 'openrouter_only',
+            models: state.subagent_models.map((entry) => entry.model),
+            entries: state.subagent_models,
+            default_model: defaultSubagentEntry(state)?.model ?? null,
+            unroutable
+        };
+    }
+    return { mode: 'tiers', models: [...latestTierModelSet(input)], entries: [], default_model: null };
+}
+export function isAllowedChildModel(model, allowlist) {
+    const key = canonicalChildModelId(model);
+    if (!key)
+        return false;
+    if (allowlist.mode === 'tiers')
+        return allowlist.models.includes(String(model ?? '').trim());
+    return allowlist.models.some((candidate) => canonicalChildModelId(candidate) === key);
+}
+export function allowlistedChildModel(model, allowlist) {
+    const key = canonicalChildModelId(model);
+    if (!key)
+        return null;
+    return allowlist.models.find((candidate) => canonicalChildModelId(candidate) === key) ?? null;
+}

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

@@ -0,0 +1,117 @@
+import { chooseChildModels } from '../decisions/child-model-choice.js';
+import { MAX_JEV_ROUTING_ROLES } from '../decisions/routing.js';
+import { SUBAGENT_MODEL_EFFORTS, defaultSubagentEntry, readOpenRouterOnlyStateSync, routableSubagentState } from './child-model-allowlist.js';
+import { latestTierModelSet } from './model-tiers.js';
+import { readCodexMainModel } from './naruto-host-credentials.js';
+import { READ_ONLY_LIST_ROLE } from './read-only-list-role.js';
+export function readChildModelPlanContext(location = {}) {
+    const stored = readOpenRouterOnlyStateSync(location);
+    if (!stored.enabled) {
+        return { allowlist: { mode: 'tiers', models: [...latestTierModelSet(location)], entries: [], default_model: null }, list: null };
+    }
+    const { state, unroutable } = routableSubagentState(stored, location);
+    const allowlist = {
+        mode: 'openrouter_only',
+        models: state.subagent_models.map((entry) => entry.model),
+        entries: state.subagent_models,
+        default_model: defaultSubagentEntry(state)?.model ?? null,
+        unroutable
+    };
+    return { allowlist, list: { state, allowlist, mainModel: readCodexMainModel(location) } };
+}
+export function listEntryEffort(entry, roleEffort) {
+    if (entry.reasoning_effort)
+        return entry.reasoning_effort;
+    const effort = String(roleEffort || '');
+    return SUBAGENT_MODEL_EFFORTS.includes(effort) ? effort : null;
+}
+function routedRow(row, choice) {
+    return {
+        ...row,
+        routed_provider: 'openrouter',
+        routed_model: choice?.entry.model ?? null,
+        routed_model_reasoning_effort: choice ? listEntryEffort(choice.entry, row.model_reasoning_effort) : null,
+        routed_model_policy: choice?.source === 'jev' ? 'openrouter_only_jev' : 'openrouter_only_default',
+        routing_dynamic: true,
+        role_model_preference_source: 'ignored_openrouter_only',
+        openrouter_only_choice: choice
+            ? { model: choice.entry.model, source: choice.source, reason: choice.reason, default_entry: choice.entry.default }
+            : { model: null, source: 'default', reason: 'subagent_list_empty', default_entry: false }
+    };
+}
+export function listBaselineAgentRouting(agentRouting, list) {
+    const fallback = defaultSubagentEntry(list.state);
+    const choice = fallback ? { entry: fallback, source: 'default', reason: 'baseline' } : null;
+    return Object.fromEntries(Object.entries(agentRouting).map(([name, row]) => [name, routedRow(row, choice)]));
+}
+export function childModelLanes(input) {
+    const assigned = new Set(input.slices.map((slice) => String(slice.agent || '')).filter(Boolean));
+    const names = Object.keys(input.agents);
+    const ordered = [...names.filter((name) => assigned.has(name)), ...names.filter((name) => !assigned.has(name))];
+    return ordered.slice(0, MAX_JEV_ROUTING_ROLES).map((name) => {
+        const own = input.slices.filter((slice) => slice.agent === name);
+        const work = own.length
+            ? own.map((slice) => `${slice.title}: ${slice.description}${slice.readOnly ? ' (read-only)' : ''}`).join('\n')
+            : `Role ${name}: ${String(input.agents[name]?.description || name)}`;
+        return { id: name, role: name, task: work, requestedModel: null };
+    });
+}
+export async function chooseListRoleModels(input) {
+    const lanes = childModelLanes(input);
+    try {
+        const choices = await chooseChildModels({
+            root: input.root,
+            workflowId: 'plan-child-models',
+            goal: input.goal || 'Plan official subagent roles.',
+            lanes,
+            state: input.list.state,
+            ...(input.env ? { env: input.env } : {})
+        });
+        return { lanes: lanes.map((lane) => lane.id), choices };
+    }
+    catch {
+        const fallback = defaultSubagentEntry(input.list.state);
+        const choices = {};
+        if (fallback)
+            for (const lane of lanes)
+                choices[lane.id] = { entry: fallback, source: 'default', reason: 'transport_error' };
+        return { lanes: lanes.map((lane) => lane.id), choices };
+    }
+}
+function uncappedReason(lanes, choices) {
+    const reasons = new Set(lanes.map((lane) => choices[lane]?.reason).filter((reason) => Boolean(reason)));
+    const decided = lanes.some((lane) => choices[lane]?.source === 'jev' || choices[lane]?.reason === 'keep_baseline');
+    return !decided && reasons.size === 1 ? [...reasons][0] : 'role_cap';
+}
+export function applyListRoleModels(agents, chosen, list, readOnlyRoleInstalled = null) {
+    const fallback = defaultSubagentEntry(list.state);
+    const lanes = chosen?.lanes || [];
+    const routed = new Set(lanes);
+    const capped = chosen ? uncappedReason(lanes, chosen.choices) : 'role_cap';
+    const next = {};
+    const roles = {};
+    const jevModels = {};
+    for (const [name, row] of Object.entries(agents)) {
+        const choice = chosen?.choices[name]
+            ?? (fallback ? { entry: fallback, source: 'default', reason: routed.has(name) ? 'keep_baseline' : capped } : null);
+        next[name] = routedRow(row, choice);
+        roles[name] = next[name].openrouter_only_choice;
+        if (choice?.source === 'jev')
+            jevModels[name] = choice.entry.model;
+    }
+    return {
+        agents: next,
+        jevModels,
+        evidence: {
+            enabled: true,
+            main_model: list.mainModel,
+            default_subagent_model: fallback?.model ?? null,
+            subagent_models: list.state.subagent_models.map((entry) => ({ ...entry })),
+            routed_roles: [...lanes],
+            jev_decided_roles: Object.keys(jevModels),
+            roles,
+            read_only_role: { name: READ_ONLY_LIST_ROLE.codex_name, installed: readOnlyRoleInstalled },
+            warnings: readOnlyRoleInstalled === false ? ['openrouter_only_read_only_role_missing'] : []
+        }
+    };
+}

package/dist/core/subagents/naruto-host-credentials.js

@@ -1,9 +1,27 @@
+import fs from 'node:fs';
+import { codexUserConfigPath, readTopLevelTomlString } from '../codex-app/codex-model-catalog.js';
+import { isOpenRouterModelId } from '../imagegen/imagegen-config.js';
 import { defaultSubagentModel } from './model-policy.js';
 import { codexListedEfforts, latestTierModelSet } from './model-tiers.js';
+import { SUBAGENT_MODEL_EFFORTS, defaultSubagentEntry, readOpenRouterOnlyStateSync, subagentEntryForModel } from './child-model-allowlist.js';
 export const NARUTO_AUTH_MODES = ['managed', 'host'];
 const IDENTIFIER_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const RETIRED_DIRECT_MANAGED_PROVIDERS = new Set(['codex-lb', 'openrouter']);
 export const NARUTO_EFFORT_TIERS = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+export function readCodexMainModel(location = {}) {
+    try {
+        return readTopLevelTomlString(fs.readFileSync(codexUserConfigPath(location), 'utf8'), 'model')?.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readNarutoOpenRouterOnlyContext(location = {}) {
+    const state = readOpenRouterOnlyStateSync(location);
+    if (!state.enabled)
+        return null;
+    return { state, mainModel: readCodexMainModel(location) };
+}
 function readFlagValue(args, name) {
     const inline = args.find((arg) => arg.startsWith(`${name}=`));
     if (inline)
@@ -78,12 +96,15 @@ export function resolveNarutoCredentialPolicy(input) {
         sources.forcedLoginMethod = args.includes('--no-forced-login-method') ? 'flag' : 'env';
         warnings.push('naruto_forced_login_method_released_without_host_auth_mode');
     }
-    const models = [
-        { key: 'parentModel', flag: '--parent-model', envKey: 'SKS_NARUTO_PARENT_MODEL', fallback: input.defaultParentModel, effort: false },
-        { key: 'parentEffort', flag: '--parent-effort', envKey: 'SKS_NARUTO_PARENT_EFFORT', fallback: input.defaultParentEffort, effort: true },
-        { key: 'subagentModel', flag: '--subagent-model', envKey: 'SKS_NARUTO_SUBAGENT_MODEL', fallback: defaultSubagentModel(), effort: false },
-        { key: 'subagentEffort', flag: '--subagent-effort', envKey: 'SKS_NARUTO_SUBAGENT_EFFORT', fallback: input.defaultSubagentEffort, effort: true }
-    ];
+    const openRouterOnly = input.openRouterOnly === undefined ? readNarutoOpenRouterOnlyContext() : input.openRouterOnly;
+    const models = openRouterOnly
+        ? openRouterOnlyModelFlags(input, openRouterOnly)
+        : [
+            { key: 'parentModel', flag: '--parent-model', envKey: 'SKS_NARUTO_PARENT_MODEL', fallback: input.defaultParentModel, effort: false },
+            { key: 'parentEffort', flag: '--parent-effort', envKey: 'SKS_NARUTO_PARENT_EFFORT', fallback: input.defaultParentEffort, effort: true },
+            { key: 'subagentModel', flag: '--subagent-model', envKey: 'SKS_NARUTO_SUBAGENT_MODEL', fallback: defaultSubagentModel(), effort: false },
+            { key: 'subagentEffort', flag: '--subagent-effort', envKey: 'SKS_NARUTO_SUBAGENT_EFFORT', fallback: input.defaultSubagentEffort, effort: true }
+        ];
     const resolvedModels = {};
     for (const entry of models) {
         const raw = resolve(args, env, entry.flag, entry.envKey);
@@ -94,7 +115,7 @@ export function resolveNarutoCredentialPolicy(input) {
         }
         const ok = entry.effort
             ? NARUTO_EFFORT_TIERS.includes(raw.value)
-            : validIdentifier(raw.value);
+            : validIdentifier(raw.value) || (openRouterOnly !== null && isOpenRouterModelId(raw.value));
         if (!ok) {
             blockers.push(`naruto_${String(entry.key)}_invalid:${raw.value.slice(0, 32)}`);
             resolvedModels[entry.key] = entry.fallback;
@@ -104,12 +125,17 @@ export function resolveNarutoCredentialPolicy(input) {
         resolvedModels[entry.key] = raw.value;
         sources[entry.key] = raw.source;
     }
-    if (!latestTierModelSet().has(String(resolvedModels.subagentModel))) {
-        blockers.push('naruto_subagent_model_must_be_current');
-        resolvedModels.subagentModel = defaultSubagentModel();
+    if (openRouterOnly) {
+        validateOpenRouterOnlyModels(openRouterOnly, resolvedModels, sources, blockers);
+    }
+    else {
+        if (!latestTierModelSet().has(String(resolvedModels.subagentModel))) {
+            blockers.push('naruto_subagent_model_must_be_current');
+            resolvedModels.subagentModel = defaultSubagentModel();
+        }
+        validateGpt56EffortPair('parent', String(resolvedModels.parentModel), String(resolvedModels.parentEffort), blockers);
+        validateGpt56EffortPair('subagent', String(resolvedModels.subagentModel), String(resolvedModels.subagentEffort), blockers);
     }
-    validateGpt56EffortPair('parent', String(resolvedModels.parentModel), String(resolvedModels.parentEffort), blockers);
-    validateGpt56EffortPair('subagent', String(resolvedModels.subagentModel), String(resolvedModels.subagentEffort), blockers);
     const envKeyRaw = resolve(args, env, '--provider-env-key', 'SKS_NARUTO_PROVIDER_ENV_KEY');
     let providerEnvKey = null;
     sources.providerEnvKey = 'default';
@@ -141,11 +167,53 @@ export function resolveNarutoCredentialPolicy(input) {
         parentEffort: String(resolvedModels.parentEffort),
         subagentModel: String(resolvedModels.subagentModel),
         subagentEffort: String(resolvedModels.subagentEffort),
+        childModelMode: openRouterOnly ? 'openrouter_only' : 'tiers',
         sources,
         warnings,
-        blockers
+        blockers,
+        hint: openRouterOnly && blockers.some((blocker) => OPENROUTER_ONLY_BLOCKER.test(blocker)) ? OPENROUTER_ONLY_HINT : null
     };
 }
+const OPENROUTER_ONLY_BLOCKER = /^naruto_(parent_model_not_openrouter|subagent_model_not_in_list|subagent_model_list_empty|parent_effort_unsupported_openrouter|subagent_effort_unsupported_openrouter)(:|$)/;
+const OPENROUTER_ONLY_HINT = 'OpenRouter Only Mode is on: the parent runs the OpenRouter main model in Codex config.toml and children run only models on the subagent list (Control Center > Subagent Models, or `sks bridge subagent-models list`); pass --parent-model=<vendor/model>, --subagent-model=<a listed model>, and efforts low|medium|high|xhigh';
+const OPENROUTER_ONLY_PARENT_EFFORT = 'xhigh';
+function openRouterOnlyEffort(value, fallback) {
+    return value && SUBAGENT_MODEL_EFFORTS.includes(value) ? value : fallback;
+}
+function openRouterOnlyModelFlags(input, context) {
+    const listDefault = defaultSubagentEntry(context.state);
+    return [
+        { key: 'parentModel', flag: '--parent-model', envKey: 'SKS_NARUTO_PARENT_MODEL', fallback: context.mainModel || '', effort: false },
+        { key: 'parentEffort', flag: '--parent-effort', envKey: 'SKS_NARUTO_PARENT_EFFORT', fallback: openRouterOnlyEffort(input.defaultParentEffort, OPENROUTER_ONLY_PARENT_EFFORT), effort: true },
+        { key: 'subagentModel', flag: '--subagent-model', envKey: 'SKS_NARUTO_SUBAGENT_MODEL', fallback: listDefault?.model || '', effort: false },
+        { key: 'subagentEffort', flag: '--subagent-effort', envKey: 'SKS_NARUTO_SUBAGENT_EFFORT', fallback: openRouterOnlyEffort(listDefault?.reasoning_effort ?? input.defaultSubagentEffort, 'medium'), effort: true }
+    ];
+}
+function validateOpenRouterOnlyModels(context, resolved, sources, blockers) {
+    const parent = String(resolved.parentModel || '');
+    const parentLabel = parent.slice(0, 64) || 'unset';
+    if (!isOpenRouterModelId(parent))
+        blockers.push(`naruto_parent_model_not_openrouter:${parentLabel}`);
+    const listDefault = defaultSubagentEntry(context.state);
+    if (!listDefault) {
+        blockers.push('naruto_subagent_model_list_empty');
+    }
+    else {
+        const listed = subagentEntryForModel(context.state, resolved.subagentModel);
+        if (!listed)
+            blockers.push(`naruto_subagent_model_not_in_list:${String(resolved.subagentModel || '').slice(0, 64)}`);
+        const entry = listed ?? listDefault;
+        resolved.subagentModel = entry.model;
+        if (sources.subagentEffort === 'default' && entry.reasoning_effort)
+            resolved.subagentEffort = entry.reasoning_effort;
+    }
+    for (const scope of ['parent', 'subagent']) {
+        const effort = String(resolved[`${scope}Effort`] || '');
+        if (!SUBAGENT_MODEL_EFFORTS.includes(effort)) {
+            blockers.push(`naruto_${scope}_effort_unsupported_openrouter:${effort}:allowed_${SUBAGENT_MODEL_EFFORTS.join('_or_')}`);
+        }
+    }
+}
 function validateGpt56EffortPair(scope, model, effort, blockers) {
     const allowed = codexListedEfforts(model);
     if (allowed && !allowed.includes(effort)) {
@@ -172,6 +240,7 @@ export function narutoCredentialPolicyReceipt(policy) {
         parent_effort: policy.parentEffort,
         subagent_model: policy.subagentModel,
         subagent_effort: policy.subagentEffort,
+        child_model_mode: policy.childModelMode,
         sources: policy.sources,
         warnings: policy.warnings,
         blockers: policy.blockers,

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

@@ -7,6 +7,8 @@ import { ensureConfinedDirectory, inspectConfinedPath } from '../managed-path-sa
 import { MANAGED_OFFICIAL_SUBAGENT_ROLES, managedOfficialSubagentRoleContent, managedOfficialSubagentRoleOwnsText } from '../managed-assets/managed-assets-manifest.js';
 import { DEFAULT_SUBAGENT_EFFORT, defaultSubagentModel as latestDefaultSubagentModel } from './model-policy.js';
 import { latestTierModelSet } from './model-tiers.js';
+import { allowlistedChildModel, effectiveChildModelAllowlist } from './child-model-allowlist.js';
+import { READ_ONLY_LIST_ROLE, readOnlyListRoleContent, readOnlyListRoleOwnsText } from './read-only-list-role.js';
 import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
 import { escapeRegExp } from '../text/regex.js';
 export const DEFAULT_OFFICIAL_SUBAGENT_MAX_THREADS = 256;
@@ -52,8 +54,14 @@ export function mergeOfficialSubagentConfigResult(text = '', opts = {}) {
     next = upsertDefaultUnlessInherited(next, inheritedAgents, 'enabled', `enabled = ${DEFAULT_OFFICIAL_SUBAGENT_ENABLED}`);
     next = upsertDefaultUnlessInherited(next, inheritedAgents, 'max_depth', `max_depth = ${DEFAULT_OFFICIAL_SUBAGENT_MAX_DEPTH}`);
     next = upsertDefaultUnlessInherited(next, inheritedAgents, 'interrupt_message', `interrupt_message = ${DEFAULT_OFFICIAL_SUBAGENT_INTERRUPT_MESSAGE}`);
+    const childModels = opts.childModels ?? effectiveChildModelAllowlist();
     const existingDefault = /^\s*default_subagent_model\s*=\s*"([^"]*)"/m.exec(next)?.[1] || '';
-    next = upsertTomlTableKey(next, 'agents', `default_subagent_model = "${latestTierModelSet().has(existingDefault) ? existingDefault : defaultOfficialSubagentModel()}"`);
+    const childDefault = childModels.mode === 'openrouter_only'
+        ? childModels.default_model
+        : latestTierModelSet().has(existingDefault) ? existingDefault : defaultOfficialSubagentModel();
+    if (childDefault) {
+        next = upsertTomlTableKey(next, 'agents', `default_subagent_model = "${childDefault}"`);
+    }
     next = upsertDefaultUnlessInherited(next, inheritedAgents, 'default_subagent_reasoning_effort', `default_subagent_reasoning_effort = "${DEFAULT_OFFICIAL_SUBAGENT_REASONING_EFFORT}"`);
     next = mergeOfficialMultiAgentV2FeatureConfig(next, {
         sksOwned: opts.sksOwned === true,
@@ -140,17 +148,23 @@ export async function readOfficialSubagentConfig(root, opts = {}) {
     const effectiveMaxThreads = Math.min(maxThreads.value, HARD_NARUTO_MAX_THREADS);
     const maxDepth = resolveLayeredValue(projectLayer.agents.max_depth, globalLayer.agents.max_depth, DEFAULT_OFFICIAL_SUBAGENT_MAX_DEPTH, positiveInteger);
     const interruptMessage = resolveLayeredValue(projectLayer.agents.interrupt_message, globalLayer.agents.interrupt_message, DEFAULT_OFFICIAL_SUBAGENT_INTERRUPT_MESSAGE, booleanValue);
-    const defaultSubagentModel = resolveLayeredValue(projectLayer.agents.default_subagent_model, globalLayer.agents.default_subagent_model, defaultOfficialSubagentModel(), nonEmptyString);
+    const childModels = opts.childModels ?? effectiveChildModelAllowlist({ home });
+    const listDefault = childModels.mode === 'openrouter_only' ? childModels.default_model : null;
+    const defaultSubagentModel = resolveLayeredValue(projectLayer.agents.default_subagent_model, globalLayer.agents.default_subagent_model, listDefault ?? defaultOfficialSubagentModel(), nonEmptyString);
     const defaultSubagentReasoningEffort = resolveLayeredValue(projectLayer.agents.default_subagent_reasoning_effort, globalLayer.agents.default_subagent_reasoning_effort, DEFAULT_OFFICIAL_SUBAGENT_REASONING_EFFORT, nonEmptyString);
     const multiAgentV2 = resolveMultiAgentV2Layer(projectLayer.features.multi_agent_v2, globalLayer.features.multi_agent_v2, effectiveMaxThreads);
     const effectiveMultiAgentV2 = {
         ...multiAgentV2.value,
         maxConcurrentThreadsPerSession: Math.min(multiAgentV2.value.maxConcurrentThreadsPerSession, HARD_NARUTO_MAX_THREADS + 1)
     };
-    const modelCoerced = !latestTierModelSet().has(String(defaultSubagentModel.value));
+    const childDefault = coercedChildDefault(String(defaultSubagentModel.value), childModels);
+    const modelCoerced = childDefault.coerced;
     const depthCoerced = maxDepth.value > 1;
     const warnings = [
-        ...(modelCoerced ? [`official_subagent_model_coerced_to_latest:${defaultSubagentModel.value}:${defaultSubagentModel.source}`] : []),
+        ...(modelCoerced
+            ? [`${childModels.mode === 'openrouter_only' ? 'official_subagent_model_coerced_to_list_default' : 'official_subagent_model_coerced_to_latest'}:${defaultSubagentModel.value}:${defaultSubagentModel.source}`]
+            : []),
+        ...(childModels.mode === 'openrouter_only' && !listDefault ? ['official_subagent_model_list_empty_openrouter_only'] : []),
         ...(depthCoerced ? [`official_subagent_max_depth_coerced_to_one:${maxDepth.value}:${maxDepth.source}`] : []),
         ...capacityNormalizationWarnings(maxThreads, multiAgentV2),
         ...(projectLayer.legacyWarnings),
@@ -162,7 +176,7 @@ export async function readOfficialSubagentConfig(root, opts = {}) {
         maxDepth: depthCoerced ? DEFAULT_OFFICIAL_SUBAGENT_MAX_DEPTH : maxDepth.value,
         jobMaxRuntimeSeconds: null,
         interruptMessage: interruptMessage.value,
-        defaultSubagentModel: modelCoerced ? defaultOfficialSubagentModel() : String(defaultSubagentModel.value),
+        defaultSubagentModel: childDefault.model,
         defaultSubagentReasoningEffort: defaultSubagentReasoningEffort.value,
         multiAgentV2: effectiveMultiAgentV2,
         sources: {
@@ -180,6 +194,17 @@ export async function readOfficialSubagentConfig(root, opts = {}) {
         warnings
     };
 }
+function coercedChildDefault(value, childModels) {
+    if (childModels.mode === 'openrouter_only') {
+        if (!childModels.default_model)
+            return { model: value, coerced: false };
+        const listed = allowlistedChildModel(value, childModels);
+        return listed ? { model: listed, coerced: false } : { model: childModels.default_model, coerced: true };
+    }
+    return latestTierModelSet().has(value)
+        ? { model: value, coerced: false }
+        : { model: defaultOfficialSubagentModel(), coerced: true };
+}
 export function officialSubagentConfigWarnings(text = '', inheritedText = '') {
     const project = configLayer(text, 'project');
     const inherited = configLayer(inheritedText, 'global');
@@ -212,7 +237,31 @@ export function resolveInheritedOfficialSubagentConfigPath(projectConfigPath, op
     return globalConfigPath === path.resolve(projectConfigPath) ? null : globalConfigPath;
 }
 export async function installOfficialSubagentAgentConfigs(root, opts = {}) {
-    return installOfficialSubagentAgentConfigsAt(root, '.codex/agents', opts);
+    const childModels = opts.childModels ?? effectiveChildModelAllowlist();
+    return installOfficialSubagentAgentConfigsAt(root, '.codex/agents', {
+        ...(opts.apply === undefined ? {} : { apply: opts.apply }),
+        readOnlyListRole: childModels.mode === 'openrouter_only'
+    });
+}
+function managedRoleFiles(readOnlyListRole) {
+    return [
+        ...MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => ({
+            filename: role.filename,
+            codexName: role.codex_name,
+            expected: managedOfficialSubagentRoleContent(role),
+            owns: (text) => managedOfficialSubagentRoleOwnsText(text, role),
+            marker: role.ownership_marker
+        })),
+        ...(readOnlyListRole
+            ? [{
+                    filename: READ_ONLY_LIST_ROLE.filename,
+                    codexName: READ_ONLY_LIST_ROLE.codex_name,
+                    expected: readOnlyListRoleContent(),
+                    owns: readOnlyListRoleOwnsText,
+                    marker: READ_ONLY_LIST_ROLE.ownership_marker
+                }]
+            : [])
+    ];
 }
 export async function refreshGlobalOfficialSubagentAgentConfigs(codexHome, opts = {}) {
     const home = path.resolve(codexHome);
@@ -223,6 +272,8 @@ export async function refreshGlobalOfficialSubagentAgentConfigs(codexHome, opts
 }
 async function installOfficialSubagentAgentConfigsAt(root, relativeDir, opts) {
     const apply = opts.apply !== false;
+    const roleFiles = managedRoleFiles(opts.readOnlyListRole === true);
+    const installedAgents = roleFiles.map((role) => role.codexName);
     const agentsDir = path.join(path.resolve(root), relativeDir);
     const missing = [];
     const existing = [];
@@ -262,8 +313,8 @@ async function installOfficialSubagentAgentConfigsAt(root, relativeDir, opts) {
             schema: 'sks.official-subagent-agent-install.v1',
             ok: false,
             apply,
-            installed_agents: MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => role.codex_name),
-            missing: MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => role.filename),
+            installed_agents: installedAgents,
+            missing: roleFiles.map((role) => role.filename),
             existing,
             stale,
             created,
@@ -277,10 +328,10 @@ async function installOfficialSubagentAgentConfigsAt(root, relativeDir, opts) {
     }
     if (apply && !opts.existingOnly)
         await ensureConfinedDirectory(root, agentsDir);
-    for (const role of MANAGED_OFFICIAL_SUBAGENT_ROLES) {
+    for (const role of roleFiles) {
         const absolute = path.join(agentsDir, role.filename);
         const relative = `${relativeDir}/${role.filename}`;
-        const expected = managedOfficialSubagentRoleContent(role);
+        const expected = role.expected;
         const inspected = await inspectConfinedPath(root, absolute).catch(() => null);
         if (!inspected) {
             preserved.push(relative);
@@ -320,7 +371,7 @@ async function installOfficialSubagentAgentConfigsAt(root, relativeDir, opts) {
             generatedFiles.push(relative);
             continue;
         }
-        if (managedOfficialSubagentRoleOwnsText(current, role)) {
+        if (role.owns(current)) {
             stale.push(relative);
             if (apply) {
                 await writeTextAtomic(absolute, expected);
@@ -330,7 +381,7 @@ async function installOfficialSubagentAgentConfigsAt(root, relativeDir, opts) {
             continue;
         }
         preserved.push(relative);
-        manualBlockers.push(manualCollisionBlocker(relative, current, role));
+        manualBlockers.push(manualCollisionBlocker(relative, current, role.marker));
     }
     const remainingMissing = apply
         ? missing.filter((filename) => !created.includes(`${relativeDir}/${filename}`))
@@ -339,7 +390,7 @@ async function installOfficialSubagentAgentConfigsAt(root, relativeDir, opts) {
         schema: 'sks.official-subagent-agent-install.v1',
         ok: manualBlockers.length === 0 && (apply ? remainingMissing.length === 0 : true),
         apply,
-        installed_agents: MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => role.codex_name),
+        installed_agents: installedAgents,
         missing,
         existing,
         stale,
@@ -383,8 +434,8 @@ export async function backupInvalidToml(file, text, tag) {
     await writeTextAtomic(backupPath, String(text || ''), { mode: 0o600 });
     return backupPath;
 }
-function manualCollisionBlocker(relative, text, role) {
-    const markerPresent = String(text || '').includes(role.ownership_marker);
+function manualCollisionBlocker(relative, text, marker) {
+    const markerPresent = String(text || '').includes(marker);
     return markerPresent
         ? `manual_modified_official_subagent_config:${relative}`
         : `manual_user_owned_official_subagent_collision:${relative}`;