sneakoscope 10.3.2 → 10.3.4

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

@@ -6,7 +6,8 @@ import { attentionRiskForTask, classifyTaskProfile } from '../runtime/task-profi
 import { chooseVerificationBudget } from '../runtime/verification-budget.js';
 import { buildOfficialSubagentPrompt, validateOfficialSubagentSlices } from './official-subagent-prompt.js';
 import { readOfficialSubagentConfig } from './official-subagent-config.js';
-import { ASTRA_SUBAGENT_MODEL, NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
+import { NARUTO_PARENT_EFFORT, narutoParentModel } from './model-policy.js';
+import { latestModelForTier } from './model-tiers.js';
 import { MAX_ON_DEMAND_SUBAGENT_ROLE_COUNT, officialSubagentFanoutPolicy, officialSubagentOnDemandRolePlan, officialSubagentRoleCatalog, recommendOfficialSubagentRoles } from './agent-catalog.js';
 import { resolveSubagentThreadBudget } from './thread-budget.js';
 import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
@@ -270,7 +271,7 @@ async function deriveOfficialSubagentPreparation(input, snapshot) {
         return [name, {
                 ...config,
                 routed_provider: 'openai',
-                routed_model: preference?.model || ASTRA_SUBAGENT_MODEL,
+                routed_model: preference?.model || config.model || decision.model,
                 routed_model_reasoning_effort: routedReasoning,
                 routed_model_policy: preference
                     ? 'user_role_model_preference'
@@ -341,11 +342,11 @@ async function deriveOfficialSubagentPreparation(input, snapshot) {
         },
         slice_safety: sliceSafety,
         slices,
-        parent_model_policy: NARUTO_PARENT_MODEL,
+        parent_model_policy: narutoParentModel(),
         observed_parent_model: observedParentModel,
         parent_model_match: parentModelMatch,
         parent: {
-            model: NARUTO_PARENT_MODEL,
+            model: narutoParentModel(),
             model_reasoning_effort: NARUTO_PARENT_EFFORT
         },
         agent_catalog: agentCatalog,
@@ -472,7 +473,7 @@ function applyOfficialSubagentDecision(derived, decided) {
             .filter(([name]) => !derived.roleModelPreferences.store.roles[name])
             .map(([name, effort]) => [name, {
                 provider: 'openai',
-                model: selectedRouting.models[name] || 'gpt-6-astra',
+                model: selectedRouting.models[name] || latestModelForTier('deep'),
                 reasoning_effort: effort,
                 updated_at: derived.plan.workflow_run_id
             }]))
@@ -496,6 +497,8 @@ function applyOfficialSubagentDecision(derived, decided) {
         },
         routedAgents: agents,
         narutoChildRouting: derived.mode === 'naruto',
+        jevRouting: decided.compiled.kind === 'apply'
+            || !['off', 'missing_key'].includes(String(decided.compiled.reason || '')),
         activeMainModel: derived.activeMainModel,
         parentOutputMode: derived.mode === 'naruto' && derived.sessionScope ? 'app_naruto_stdin' : 'raw_json',
         missionId: derived.plan.mission_id,
@@ -503,6 +506,7 @@ function applyOfficialSubagentDecision(derived, decided) {
         decisionContract: decided.compiled.kind === 'apply'
             ? {
                 planId: selectedPlan?.id ?? null,
+                workerCount: selectedPlan?.workerCount ?? null,
                 keepContextIds: decided.selectedContextIds,
                 routingLane: selectedRouting
                     ? Object.entries(selectedRouting.models).map(([name, model]) => `${name}=${model}`).join(', ')
@@ -914,7 +918,7 @@ export function buildNarutoSummary(input) {
         workflow_run_id: input.workflowRunId || input.evidence?.run_id || null,
         mission_id: input.missionId,
         parent: {
-            model: NARUTO_PARENT_MODEL,
+            model: narutoParentModel(),
             model_reasoning_effort: NARUTO_PARENT_EFFORT,
             observed_model: input.observedParentModel || null,
             observed_model_match: input.parentModelMatch ?? null
@@ -994,7 +998,7 @@ export function buildNarutoGateResult(input) {
         workflow: 'official_codex_subagent',
         workflow_run_id: input.workflowRunId || input.evidence?.run_id || null,
         mission_id: input.missionId,
-        parent_model_policy: NARUTO_PARENT_MODEL,
+        parent_model_policy: narutoParentModel(),
         observed_parent_model: input.observedParentModel || null,
         parent_model_match: input.parentModelMatch ?? null,
         status: passed ? 'passed' : 'blocked',
@@ -1039,7 +1043,7 @@ export function buildNarutoGateResult(input) {
     };
 }
 function observedParentModelMatchesPolicy(model) {
-    return model.trim().toLowerCase() === NARUTO_PARENT_MODEL;
+    return model.trim().toLowerCase() === narutoParentModel();
 }
 export const NARUTO_MISSION_RUN_LOCK = '.naruto-run.lock';
 export const NARUTO_MISSION_RUN_STALE_MS = 120_000;

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

@@ -1,4 +1,4 @@
-import { ASTRA_SUBAGENT_MODEL, NARUTO_PARENT_MODEL, NARUTO_PARENT_EFFORT } from './model-policy.js';
+import { latestTierModelSet } from './model-tiers.js';
 import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
 import { coreEngineeringDirectiveReferenceText } from '../lean-engineering-policy.js';
 import { MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, MAX_CRITICAL_AUTOMATIC_REVIEWER_COUNT, officialSubagentOnDemandRoleCatalog, officialSubagentRoleCatalog, selectOfficialSubagentRole } from './agent-catalog.js';
@@ -44,30 +44,30 @@ export function buildOfficialSubagentPrompt(input) {
         ...(input.recommendedAgents || [])
     ]);
     const activeMainModel = normalizedActiveMainModel(input.activeMainModel);
-    const effortPreferences = Object.fromEntries(Object.entries(input.roleModelPreferences || {})
-        .filter(([name, row]) => row.model === ASTRA_SUBAGENT_MODEL
+    const currentModels = latestTierModelSet();
+    const rolePreferences = Object.fromEntries(Object.entries(input.roleModelPreferences || {})
+        .filter(([name, row]) => currentModels.has(row.model)
         && ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(row.reasoning_effort)
-        && officialSubagentOnDemandRoleCatalog([name]).some((role) => role.name === name))
-        .map(([name, row]) => [name, row.reasoning_effort]));
+        && officialSubagentOnDemandRoleCatalog([name]).some((role) => role.name === name)));
+    const effortPreferences = Object.fromEntries(Object.entries(rolePreferences).map(([name, row]) => [name, row.reasoning_effort]));
     const narutoChildren = input.narutoChildRouting === true;
-    const spawnModelRouting = renderSpawnModelRouting(narutoChildren);
+    const jevRouting = input.jevRouting === true;
+    const spawnModelRouting = renderSpawnModelRouting(narutoChildren, jevRouting);
+    const tierRules = jevRouting
+        ? []
+        : [
+            '- tiers: fast for tiny mechanical shards (search, rename, copy, label, one-line edits), balanced for instructed UI, logic, backend, and native implementation, context for long reads, exploration, large first drafts, Computer Use, browser, or image work, deep for planning, review, debugging, architecture, security, database, research, release, or other judgment',
+            '- explicit task class and phase win over incidental keywords; a mixed slice takes the deeper tier; never apply the parent profile to every child'
+        ];
     const childModelRules = narutoChildren
         ? [
             '- the parent orchestrates only: decompose the goal, assign disjoint slices, spawn children, and integrate their results',
             '- do not implement the assigned slice work in the parent thread',
-            '- use the model and reasoning_effort named in each slice spawn contract',
-            '- sealed child models are gpt-5.6-luna, gpt-5.6-sol, gpt-5.6-terra, and gpt-6-astra',
+            '- use the model and reasoning_effort named in each slice spawn contract; each is the newest model of its tier',
+            ...tierRules,
             '- keep a stored user role-model preference for that role'
         ].join('\n')
-        : [
-            '- use `worker` with gpt-6-astra and low reasoning for tiny short-context mechanical work such as simple search, typing, rename, copy, label, or one-line edits with no exploration or judgment',
-            '- use gpt-6-astra with low reasoning for ordinary UI, logic, backend, and native implementation with established instructions',
-            '- use gpt-6-astra with max reasoning for planning, analysis, review, focused unresolved, high-risk, architecture, security, database, research, release, or other explicit judgment slices',
-            '- use gpt-6-astra with medium reasoning for long context/memory, large docs/repository reads or exploration, large-scale first-draft code processing, and direct Computer Use, Browser/Chrome, or image generation',
-            '- explicit task class and phase win over incidental keywords: Astra Medium explores, Astra Low executes mechanical and instructed coding tasks, and Astra Max judges',
-            '- in mass fan-out, use worker/Astra Low for tiny mechanical shards and explorer/Astra Medium for broad exploration; use Astra Low for instructed implementation and Astra Max for judgment',
-            '- keep context, exploration, review, debugging, planning, and direct tool operation on their assigned defaults; preserve each sealed role model and effort instead of applying the parent profile to every child'
-        ].join('\n');
+        : tierRules.join('\n');
     const parentOutputMode = input.parentOutputMode === 'app_naruto_stdin'
         ? 'app_naruto_stdin'
         : 'raw_json';
@@ -80,10 +80,10 @@ export function buildOfficialSubagentPrompt(input) {
             || effortPreferences[agentName]
             || role?.model_reasoning_effort
             || 'medium';
-        const sealedModel = routed?.routed_model || role?.model;
+        const sealedModel = routed?.routed_model || rolePreferences[agentName]?.model || role?.model;
         const spawnContract = role
             ? `pass model=${JSON.stringify(sealedModel)} and reasoning_effort=${JSON.stringify(sealedReasoning)} from the sealed role policy`
-            : 'stop before spawning: resolve an installed sealed Astra role and its effort first';
+            : 'stop before spawning: resolve an installed sealed role and its tier first';
         return [
             `${index + 1}. [${slice.id}] use custom agent \`${agentName}\``,
             `   ${slice.title}: ${slice.description}`,
@@ -114,15 +114,15 @@ Host capability policy:
 - Slack delivery is ACAS-runtime-only, never a model tool
 
 Subagent rules:
-- parent model policy: ${activeMainModel ? `keep the current app-selected main model ${activeMainModel.provider}:${activeMainModel.model}` : `${NARUTO_PARENT_MODEL} with ${NARUTO_PARENT_EFFORT} reasoning`}
+- parent model policy: ${activeMainModel ? `keep the current app-selected main model ${activeMainModel.provider}:${activeMainModel.model}` : 'keep the user-selected parent model'}
 - use only Codex official subagent threads; do not launch shell workers, a custom scheduler, a worker pool, or model fanout
 - select the narrowest matching project custom agent by its description; the custom agent name is the spawn type
 - custom \`agent_type\` selection and spawn-time \`model\`/\`reasoning_effort\` overrides must use \`fork_turns="none"\` or a positive bounded turn count, with the complete bounded slice contract in \`message\`; context contract: pass fork_turns="none" for listed slices
-- \`spawn_agent\` has no provider argument; ${narutoChildren ? 'Naruto children use the sealed model named in the spawn contract (gpt-5.6-luna, gpt-5.6-sol, gpt-5.6-terra, or gpt-6-astra)' : 'every child uses the exact model slug gpt-6-astra'}
+- \`spawn_agent\` has no provider argument; ${narutoChildren ? 'Naruto children use the tier model named in the spawn contract' : 'children use the sealed model slug'}
 - never combine \`fork_turns="all"\` or the omitted/default full-history mode with \`agent_type\`, \`model\`, or \`reasoning_effort\`; Codex rejects that start before SubagentStart
 - never use a full-history fork for SKS children
 ${spawnModelRouting}
-${Object.keys(effortPreferences).length ? `- explicit Astra effort preferences override role defaults, including later slices: ${JSON.stringify(effortPreferences)}` : ''}
+${Object.keys(effortPreferences).length ? `- stored role effort preferences override role defaults, including later slices: ${JSON.stringify(effortPreferences)}` : ''}
 ${childModelRules}
 
 Plan and capacity:
@@ -228,18 +228,17 @@ function normalizedActiveMainModel(value) {
     const model = String(value?.model || '').trim();
     return provider && model ? { provider, model } : null;
 }
-function renderSpawnModelRouting(narutoChildRouting) {
-    if (narutoChildRouting) {
-        return [
-            '- Naruto child models come from the spawn contract, including slices created after parent decomposition',
-            '- when Jev mode selected a role, that contract names gpt-5.6-luna at low, gpt-5.6-sol at low, gpt-5.6-terra at medium, or gpt-6-astra at max',
-            '- explicit user role-model preferences stay authoritative',
-            '- preserve the user-selected parent model, reasoning effort, and service tier'
-        ].join('\n');
-    }
+function renderSpawnModelRouting(narutoChildRouting, jevRouting) {
+    const lines = jevRouting
+        ? [
+            '- Jev mode: Jev picks each child tier (fast, balanced, context, or deep) and the SKS PreToolUse hook seals that tier\'s newest model on every spawn_agent call; pass the contract model unchanged and spend no time choosing models or efforts'
+        ]
+        : [
+            `- model routing applies to every child, including slices created after parent decomposition: the newest model of the role tier${narutoChildRouting ? ' named in the spawn contract' : ''}`
+        ];
     return [
-        '- model routing applies to every child, including slices created after parent decomposition: gpt-6-astra only, with the selected role effort',
-        '- use sealed Astra Low/Astra Medium/Astra Max role defaults across four task-class profiles; parent selection and saved non-Astra preferences never override the child model; explicit Astra effort preferences, including High, may override role defaults',
+        ...lines,
+        '- parent selection never overrides the child model; stored user role preferences stay authoritative',
         '- preserve the user-selected parent model, reasoning effort, and service tier'
     ].join('\n');
 }
@@ -330,6 +329,7 @@ function renderDecisionContract(value) {
     return [
         'Selected decision contract:',
         `- execute the selected plan${value.planId ? ` ${value.planId}` : ''} and retained optional context IDs; do not choose them again`,
+        value.workerCount ? `- Jev fixed the automatic child target at ${value.workerCount}; do not recompute it (real host capacity still caps each wave)` : '',
         value.routingLane ? `- Jev sealed models: ${value.routingLane}` : '',
         value.keepContextIds?.length
             ? `- retained optional context IDs: ${value.keepContextIds.join(', ')}`

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

@@ -2,7 +2,7 @@ import fsp from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { randomId, runProcess, writeJsonAtomic } from '../fsx.js';
-import { DEFAULT_SUBAGENT_EFFORT, DEFAULT_SUBAGENT_MODEL, NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
+import { DEFAULT_SUBAGENT_EFFORT, defaultSubagentModel, NARUTO_PARENT_EFFORT, narutoParentModel } from './model-policy.js';
 import { nextAgentGenerationEnv } from '../agents/agent-recursion-guard.js';
 import { inspectDesktopBridgeCliLaunchGuard, stripRetiredDirectProviderEnv } from '../codex-control/desktop-bridge-launch-guard.js';
 import { prepareCodexAppServerRuntimeEnv } from '../codex-control/codex-app-server-runtime-env.js';
@@ -93,9 +93,9 @@ export function defaultNarutoCredentialPolicy() {
     return resolveNarutoCredentialPolicy({
         args: [],
         env: {},
-        defaultParentModel: NARUTO_PARENT_MODEL,
+        defaultParentModel: narutoParentModel(),
         defaultParentEffort: NARUTO_PARENT_EFFORT,
-        defaultSubagentModel: DEFAULT_SUBAGENT_MODEL,
+        defaultSubagentModel: defaultSubagentModel(),
         defaultSubagentEffort: DEFAULT_SUBAGENT_EFFORT
     });
 }

package/dist/core/subagents/role-model-preferences.js

@@ -5,24 +5,28 @@ import { writeTextAtomic } from '../fsx.js';
 import { MANAGED_OFFICIAL_SUBAGENT_ROLES, managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
 import { inferProviderFromModel, normalizeCodexModelId, normalizeCodexReasoningEffort, readConfiguredCodexModelRoutingContext } from '../codex-app/codex-model-catalog.js';
 import { isRecord } from '../json/records.js';
-import { ASTRA_SUBAGENT_MODEL, SUBAGENT_MODEL_POLICIES } from './model-policy.js';
+import { codexListedEfforts, latestModelForTier, latestTierModelSet, modelTierForModel } from './model-tiers.js';
 export const ROLE_MODEL_PREFERENCES_SCHEMA = 'sks.role-model-preferences.v2';
 const LEGACY_ROLE_MODEL_PREFERENCES_SCHEMA = 'sks.role-model-preferences.v1';
 const ROLE_MODEL_PROFILE_PRESENTATION_LIMIT = 1_000;
-export const SUPPORTED_ROLE_MODEL_PROFILES = Object.freeze([
-    ...Object.values(SUBAGENT_MODEL_POLICIES).map((profile) => Object.freeze({
+const ROLE_PREFERENCE_EFFORTS = ['low', 'medium', 'high', 'max'];
+export function supportedRoleModelProfiles() {
+    const defaults = new Set(MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => `${role.model}\0${role.model_reasoning_effort}`));
+    return [...latestTierModelSet()].flatMap((model) => (codexListedEfforts(model) || ROLE_PREFERENCE_EFFORTS)
+        .filter((effort) => ROLE_PREFERENCE_EFFORTS.includes(effort))
+        .map((effort) => ({
         provider: 'openai',
-        model: profile.model,
-        reasoning_effort: profile.modelReasoningEffort,
-        source: 'managed-default'
-    })),
-    Object.freeze({
-        provider: 'openai',
-        model: ASTRA_SUBAGENT_MODEL,
-        reasoning_effort: 'high',
-        source: 'explicit-override'
-    })
-]);
+        model,
+        reasoning_effort: effort,
+        source: defaults.has(`${model}\0${effort}`) ? 'managed-default' : 'explicit-override'
+    })));
+}
+function currentRoleModel(model, fallback) {
+    if (latestTierModelSet().has(model))
+        return model;
+    const tier = modelTierForModel(model);
+    return tier ? latestModelForTier(tier) : fallback;
+}
 export function roleModelPreferencesPath(env = process.env) {
     const sksHome = path.resolve(env.SKS_HOME || path.join(env.HOME || os.homedir(), '.sneakoscope'));
     return path.join(sksHome, 'preferences', 'role-models.json');
@@ -52,10 +56,11 @@ export async function readRoleModelPreferences(input = {}) {
                 blockers.push(`role_model_preference_invalid_profile:${role.codex_name}`);
                 continue;
             }
-            const keepEffort = provider === 'openai' && isSupportedRoleModelProfile(model, reasoning);
+            const effectiveModel = provider === 'openai' ? currentRoleModel(model, role.model) : role.model;
+            const keepEffort = effectiveModel === model && isSupportedRoleModelProfile(effectiveModel, reasoning);
             roles[role.codex_name] = {
                 provider: 'openai',
-                model: ASTRA_SUBAGENT_MODEL,
+                model: effectiveModel,
                 reasoning_effort: keepEffort ? reasoning : role.model_reasoning_effort,
                 updated_at: String(rawPreference.updated_at || parsed.updated_at || '')
             };
@@ -91,13 +96,13 @@ export async function roleModelPreferencesStatus(input = {}) {
         ? []
         : [`role_model_preference_not_managed:${role}`]));
     const allProfiles = dedupeProfiles([
-        ...SUPPORTED_ROLE_MODEL_PROFILES
+        ...supportedRoleModelProfiles()
     ]);
     const supportedProfiles = allProfiles.slice(0, ROLE_MODEL_PROFILE_PRESENTATION_LIMIT);
     const roles = MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => {
         const override = read.store.roles[role.codex_name] || null;
         const effectiveProvider = 'openai';
-        const effectiveModel = ASTRA_SUBAGENT_MODEL;
+        const effectiveModel = override?.model || role.model;
         const effectiveReasoning = override?.reasoning_effort || role.model_reasoning_effort;
         return {
             role: role.codex_name,
@@ -163,8 +168,8 @@ export async function setRoleModelPreference(input) {
     const reasoning = normalizeCodexReasoningEffort(input.reasoning);
     if (!model || !reasoning)
         return mutationBlocked('role_model_profile_invalid');
-    if (model !== ASTRA_SUBAGENT_MODEL)
-        return mutationBlocked('role_model_astra_required');
+    if (!latestTierModelSet().has(model))
+        return mutationBlocked('role_model_current_model_required');
     const env = input.env || process.env;
     const routing = await readConfiguredCodexModelRoutingContext({
         env,
@@ -248,7 +253,7 @@ export async function resetRoleModelPreference(input) {
 export function isSupportedRoleModelProfile(model, reasoning) {
     const normalizedModel = normalizeCodexModelId(model);
     const normalizedReasoning = normalizeCodexReasoningEffort(reasoning);
-    return SUPPORTED_ROLE_MODEL_PROFILES.some((profile) => (profile.model === normalizedModel
+    return supportedRoleModelProfiles().some((profile) => (profile.model === normalizedModel
         && profile.reasoning_effort === normalizedReasoning));
 }
 async function writeOwnerOnlyStore(filePath, store) {