sneakoscope 10.3.2 → 10.3.4

package/dist/core/routes.js

@@ -6,7 +6,7 @@ import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_ONLY_POLICY, COD
 import { getdesignReferencePolicyText, imageUxReviewPipelinePolicyText } from './routes/design-policy.js';
 import { PPT_PIPELINE_SKILL_ALLOWLIST, pptPipelineAllowlistPolicyText } from './routes/ppt-policy.js';
 import { normalizeDollarSkillName, prefixKnownSksDollarReferences, sksPrefixedDollarCommand, sksPrefixedSkillName, unprefixedSksSkillName } from './routes/dollar-prefix.js';
-import { classifyTaskProfile, isTaskProfile, looksLikeDatabaseWorkRequest } from './runtime/task-profile.js';
+import { classifyTaskProfile, IMPLEMENTATION_VERB_RE, isTaskProfile, looksLikeDatabaseWorkRequest } from './runtime/task-profile.js';
 import { legacyCoreSkillNames } from './codex-native/core-skill-manifest.js';
 export * from './routes/constants.js';
 export * from './routes/design-policy.js';
@@ -121,9 +121,6 @@ export function noUnrequestedFallbackCodePolicyText() {
 export function outcomeRubricPolicyText() {
     return 'Outcome rubric: apply the Core Engineering Directive, then use Proof Field, route-gate, reflection, and Honest Mode evidence to judge goal fit, touched surface, verification, and escalation.';
 }
-export function speedLanePolicyText() {
-    return 'Proof Field speed lane policy: after the intended write scope is known, run or mentally apply `sks proof-field scan --intent "<goal>" --changed <files>`. Fast lanes keep the parent-owned minimal patch, listed verification, TriWiki validate, and Honest Mode; DB, security, visual-forensic, unknown surface, broad changes, failed verification, or unsupported claims fail closed to the normal Naruto/Honest path.';
-}
 export function hasFromChatImgSignal(prompt = '') {
     return /(?:^|\s)\$?(?:sks-)?from-chat-img(?:\s|:|$)/i.test(String(prompt || ''));
 }
@@ -233,7 +230,7 @@ export const ROUTES = [
         command: '$Naruto',
         mode: 'NARUTO',
         route: 'Codex official subagent workflow',
-        description: '$Naruto runs explicit parallel work through Codex official subagents. The selected parent owns decomposition, integration, and scoped verification; standalone launches default to GPT-6 Astra. Delegate independent slices with disjoint writes, preserve the Astra-only child role profiles, honor explicit counts and measured host limits, and reuse returned capacity.',
+        description: '$Naruto runs implementation work through Codex official subagents. The parent orchestrates: it owns decomposition, integration, and scoped verification, spawns a child per disjoint slice, and does not implement slices itself; standalone launches default to the latest deep-tier model. Each child runs the newest model of the tier its work needs; Jev mode picks the tier on spawn, and a stored role preference wins. Honor explicit counts and measured host limits, and reuse returned capacity.',
         requiredSkills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
         dollarAliases: ['$Work'],
         appSkillAliases: ['work', 'from-chat-img'],
@@ -699,7 +696,7 @@ export const COMMAND_CATALOG = [
     { name: 'wiki', usage: 'sks wiki coords|pack|refresh|publish|rebuild-index|validate|validate-shared|wrongness ...', description: 'Build, refresh, publish shared shards, rebuild ignored indexes, validate, and attach wrongness-memory context to RGBA/trig LLM Wiki packs with attention.use_first and attention.hydrate_first for compact recall plus source hydration.' },
     { name: 'memory', usage: 'sks memory build [--json] | sks memory gc [--dry-run]', description: 'Project TriWiki context-pack memory into managed AGENTS.md blocks or run bounded memory cleanup.' },
     { name: 'hproof', usage: 'sks hproof check [mission-id|latest]', description: 'Evaluate the H-Proof done gate for a mission.' },
-    { name: 'naruto', usage: 'sks naruto run \"task\" [--agents N] [--max-threads N] [--trusted-project] [--json] | sks naruto status|subagents|proof [latest|M-...] [--json] | sks naruto parent-summary --mission M-... --stdin [--json]', description: 'Run or inspect the Codex official subagent workflow with an Astra standalone parent default and Astra Low mechanical and instructed implementation, Astra Max judgment, and Astra Medium long-context/tool profiles, max_depth=1, and structured parent-thread completion evidence.' },
+    { name: 'naruto', usage: 'sks naruto run \"task\" [--agents N] [--max-threads N] [--trusted-project] [--json] | sks naruto status|subagents|proof [latest|M-...] [--json] | sks naruto parent-summary --mission M-... --stdin [--json]', description: 'Run or inspect the Codex official subagent workflow: an orchestrating parent (latest deep-tier standalone default), children on the newest model of their tier (Jev picks the tier on spawn when Jev mode is on), max_depth=1, and structured parent-thread completion evidence.' },
     { name: 'reasoning', usage: 'sks reasoning ["prompt"] [--json]', description: 'Show SKS temporary reasoning-effort routing: medium for simple tasks, high for logic, xhigh for research.' },
     { name: 'gx', usage: 'sks gx init|render|validate|drift|snapshot [name]', description: 'Create and verify deterministic SVG/HTML visual context cartridges.' },
     { name: 'profile', usage: 'sks profile show|set <model>', description: 'Inspect or set the current SKS model profile metadata.' },
@@ -1207,6 +1204,9 @@ export function narutoDecisionForRoute(route, prompt = '', profile = classifyTas
     if (NARUTO_GATE_SPECIALIZED_PARALLEL_ROUTE_IDS.has(routeId)) {
         return narutoRouteDecision('generic_naruto', routeId, profile, `specialized_route_default_parallel:${routeId}`, false);
     }
+    if (routeId === 'Naruto' && profile === 'answer') {
+        return narutoRouteDecision('generic_naruto', routeId, profile, 'naruto_route_work_without_change_verb', false);
+    }
     if (profile === 'passthrough' || profile === 'answer' || profile === 'tiny-change') {
         return narutoRouteDecision('none', routeId, profile, `task_profile_${profile}_bypass`, true);
     }
@@ -1263,7 +1263,8 @@ export function reflectionRequiredForRoute(route) {
 export function looksLikeCodeChangingWork(prompt = '') {
     const text = String(prompt || '');
     return /\b(implement|build|make|add|edit|modify|change|fix|refactor|simplify|optimi[sz]e|improve|rewrite|migrate|create|delete|remove|rename|update|patch)\b/i.test(text)
-        || /(코드|구현|개발|수정|변경|추가|삭제|제거|최적화|개선|단순화|정리|해결|고쳐|바꿔|리팩터|마이그레이션)/i.test(text);
+        || /(코드|구현|개발|수정|변경|추가|삭제|제거|최적화|개선|단순화|정리|해결|고쳐|바꿔|리팩터|마이그레이션)/i.test(text)
+        || IMPLEMENTATION_VERB_RE.test(text);
 }
 export function classifyPromptExecutionEffect(prompt = '') {
     const text = String(prompt || '').trim();
@@ -1303,9 +1304,8 @@ export function subagentExecutionPolicyText(route, prompt = '') {
         return 'Subagent policy: not required for this task profile. Keep the work parent-owned unless a later, concrete decomposition reveals independent slices.';
     }
     return [
-        'Codex subagent workflow: required for this explicit Naruto or parallel task.',
-        'The parent agent owns decomposition, integration, scoped verification, and the final answer. Preserve its selected settings; every child uses gpt-6-astra with the sealed role effort, regardless of parent model or saved role preferences.',
-        'Delegate only genuinely independent slices. Use Astra Low for tiny short-context mechanical work and instructed ordinary implementation, Astra Max for review/debug/planning/analysis/architecture/integration/risk judgment, and Astra Medium for long-context or Computer Use, Browser/Chrome, and image-generation execution. Explicit Astra effort preferences, including High, remain supported.',
+        'Codex subagent workflow: required. The parent orchestrates only: it decomposes the task into disjoint slices, spawns a child for each slice, waits, integrates, verifies, and writes the final answer. It does not implement slice work itself; the PreToolUse gate denies parent source edits before the first child starts and while children are running.',
+        'The parent keeps its user-selected model, effort, and service tier. Every child runs the newest model of the tier its work needs: fast for mechanical work, balanced for instructed implementation, context for long-context, browser, Computer Use, and image work, and deep for planning, review, debugging, and risk judgment. When Jev mode is on, Jev picks each spawn\'s tier and SKS seals it; do not pick child models yourself. A stored user role-model preference wins in both modes.',
         'Parallel writes require disjoint paths; serialize overlapping paths, prohibit nested delegation, avoid duplicate work, wait for all requested agent threads, and close completed threads after collecting results.',
         'Completion evidence comes from official SubagentStart/SubagentStop events plus the parent integration summary, not process counts or PID evidence.'
     ].join(' ');

package/dist/core/runtime/task-profile.js

@@ -16,7 +16,11 @@ const GENERIC_DATABASE_DOMAIN_RE = /\bDB\b|디비/i;
 const DATABASE_WORK_RE = /\b(?:apply|execute|run|fix|change|modify|migrate|audit|review|inspect|analy[sz]e|query|seed|backfill|optimi[sz]e|create|alter|drop|truncate|update|delete|repair)\b|적용|실행|수정|변경|검수|검토|점검|분석|조회|쿼리|시드|백필|최적화|생성|추가|삭제|복구|만들어/i;
 const DATABASE_CONTROL_SURFACE_META_RE = /\bsks\s+db\b|\b(?:db|database|migrate|migrations?)\b[\s\S]{0,48}\b(?:command|cli|route|routing|parser|classifier|regex|help|usage|topic|docs?|documentation|constant|keyword|alias)\b|\b(?:command|cli|route|routing|parser|classifier|regex|help|usage|topic|docs?|documentation|constant|keyword|alias)\b[\s\S]{0,48}\b(?:db|database|migrate|migrations?)\b|(?:db|디비|데이터베이스|migration|migrate|마이그레이션)\s*(?:커맨드|명령|명령어|CLI|라우트|라우팅|파서|분류기|정규식|도움말|헬프|사용법|토픽|문서|상수|키워드|별칭)|(?:커맨드|명령|명령어|CLI|라우트|라우팅|파서|분류기|정규식|도움말|헬프|사용법|토픽|문서|상수|키워드|별칭)[\s\S]{0,32}(?:db|디비|데이터베이스|migration|migrate|마이그레이션)/i;
 const PARALLEL_CUE_RE = /\b(parallel|subagents?|one agent per|fan out|independent slices?|naruto)\b|병렬|하위\s*에이전트|서브\s*에이전트|나루토|분담/i;
-const CHANGE_RE = /\b(fix|implement|implementation|change|edit|add|remove|delete|drop|modify|refactor|simplify|optimi[sz]e|improve|build|create|write|update|rename|rewrite|patch|apply|execute|repair|resolve|solve|publish|release|deploy|migrate)\b|\bwork\s+on\b|고쳐|고치|수정|변경|추가|삭제|제거|최적화|개선|단순화|정리|구현|리팩터|작성|생성|만들어|업데이트|적용|실행|해결|이름\s*변경|배포|출시|마이그레이션/i;
+export const IMPLEMENTATION_VERB_RE = /\b(?:make|set\s+up|port|convert|wire(?:\s+up)?|hook\s+up|handle|integrate|connect|enable|disable|configure|upgrade|bump|replace|move|split|merge|extend|scaffold|introduce)\b|바꿔|바꾸|개발|붙여|연동|연결해|옮겨|설정해|세팅|셋업|넣어|합쳐|분리해|교체|도입|처리해|올려\s*(?:줘|주세요)|짜\s*(?:줘|주세요)/i;
+const BASE_CHANGE_RE = /\b(fix|implement|implementation|change|edit|add|remove|delete|drop|modify|refactor|simplify|optimi[sz]e|improve|build|create|write|update|rename|rewrite|patch|apply|execute|repair|resolve|solve|publish|release|deploy|migrate)\b|\bwork\s+on\b|고쳐|고치|수정|변경|추가|삭제|제거|최적화|개선|단순화|정리|구현|리팩터|작성|생성|만들어|업데이트|적용|실행|해결|이름\s*변경|배포|출시|마이그레이션/i;
+function hasChangeVerb(text) {
+    return BASE_CHANGE_RE.test(text) || IMPLEMENTATION_VERB_RE.test(text);
+}
 const BOUNDED_READ_WORK_RE = /\b(audit|review|inspect|analy[sz]e|diagnose|trace|map|verify|test|check|investigate|evaluate)\b|감사|검토|점검|분석|진단|추적|매핑|검증|테스트|조사|평가/i;
 const TINY_CHANGE_RE = /\b(typo|copy|wording|label|spacing|whitespace|punctuation|spelling|one[-\s]?line|single[-\s]?(?:line|word)|rename only)\b|오타|문구|라벨|띄어쓰기|공백|맞춤법|구두점|한\s*줄|단어\s*하나|이름만\s*변경/i;
 const NON_RUNTIME_TINY_SURFACE_RE = /\b(copy|wording|label|spacing|whitespace|punctuation|spelling|readme|docs?|documentation|comment)\b|문구|라벨|띄어쓰기|공백|맞춤법|구두점|문서|주석/i;
@@ -30,18 +34,18 @@ export function classifyTaskProfile(prompt) {
     if (looksLikeExplanationQuestion(text))
         return 'answer';
     const databaseWork = looksLikeDatabaseWorkRequest(text);
-    const highRiskMutation = databaseWork || (CHANGE_RE.test(text) && NON_DATABASE_HIGH_RISK_RE.test(text));
+    const highRiskMutation = databaseWork || (hasChangeVerb(text) && NON_DATABASE_HIGH_RISK_RE.test(text));
     if (looksLikeTinyChange(text) && (!highRiskMutation || NON_RUNTIME_TINY_SURFACE_RE.test(text)))
         return 'tiny-change';
     if (highRiskMutation)
         return 'high-risk';
-    if (PARALLEL_CUE_RE.test(text) && CHANGE_RE.test(text))
+    if (PARALLEL_CUE_RE.test(text) && hasChangeVerb(text))
         return 'parallel-write';
     if (PARALLEL_CUE_RE.test(text))
         return 'parallel-read';
     if (DATABASE_CONTROL_SURFACE_META_RE.test(text) && DATABASE_WORK_RE.test(text))
         return 'bounded-work';
-    if (CHANGE_RE.test(text))
+    if (hasChangeVerb(text))
         return 'bounded-work';
     if (BOUNDED_READ_WORK_RE.test(text))
         return 'bounded-work';
@@ -84,7 +88,7 @@ function matchIndexes(text, pattern) {
         .filter((index) => Number.isInteger(index));
 }
 function looksLikeTinyChange(text) {
-    return CHANGE_RE.test(text) && TINY_CHANGE_RE.test(text);
+    return hasChangeVerb(text) && TINY_CHANGE_RE.test(text);
 }
 function looksLikeExplanationQuestion(text) {
     return (EXPLANATION_QUESTION_RE.test(text) || EXPLANATION_REQUEST_RE.test(text))

package/dist/core/subagents/model-policy.js

@@ -1,44 +1,37 @@
+import { latestModelForTier } from './model-tiers.js';
 export const NARUTO_PARENT_MODEL = 'gpt-6-astra';
 export const NARUTO_PARENT_EFFORT = 'max';
+export function narutoParentModel() {
+    return latestModelForTier('deep');
+}
 export const ASTRA_SUBAGENT_MODEL = 'gpt-6-astra';
-export const NARUTO_LUNA_MODEL = 'gpt-5.6-luna';
-export const NARUTO_SOL_MODEL = 'gpt-5.6-sol';
-export const NARUTO_TERRA_MODEL = 'gpt-5.6-terra';
-export const LUNA_SUBAGENT_MODEL = ASTRA_SUBAGENT_MODEL;
-export const TERRA_SUBAGENT_MODEL = ASTRA_SUBAGENT_MODEL;
-export const SOL_SUBAGENT_MODEL = ASTRA_SUBAGENT_MODEL;
 export const LUNA_SUBAGENT_EFFORT = 'low';
 export const TERRA_SUBAGENT_EFFORT = 'medium';
 export const DEFAULT_SUBAGENT_EFFORT = 'low';
 export const SOL_MAX_SUBAGENT_EFFORT = 'max';
-export const DEFAULT_SUBAGENT_MODEL = SOL_SUBAGENT_MODEL;
-export const THINKING_SUBAGENT_MODEL = SOL_SUBAGENT_MODEL;
 export const SUBAGENT_EFFORT = SOL_MAX_SUBAGENT_EFFORT;
+export function thinkingSubagentModel() {
+    return latestModelForTier('deep');
+}
+export function defaultSubagentModel() {
+    return latestModelForTier('deep');
+}
+function tierProfile(policy, kind, tier, modelReasoningEffort) {
+    return Object.freeze({
+        policy,
+        kind,
+        tier,
+        get model() {
+            return latestModelForTier(tier);
+        },
+        modelReasoningEffort
+    });
+}
 export const SUBAGENT_MODEL_POLICIES = Object.freeze({
-    luna_max_mechanical: Object.freeze({
-        policy: 'luna_max_mechanical',
-        kind: 'worker',
-        model: LUNA_SUBAGENT_MODEL,
-        modelReasoningEffort: LUNA_SUBAGENT_EFFORT
-    }),
-    sol_high_implementation: Object.freeze({
-        policy: 'sol_high_implementation',
-        kind: 'worker',
-        model: SOL_SUBAGENT_MODEL,
-        modelReasoningEffort: DEFAULT_SUBAGENT_EFFORT
-    }),
-    sol_max_judgment: Object.freeze({
-        policy: 'sol_max_judgment',
-        kind: 'expert',
-        model: SOL_SUBAGENT_MODEL,
-        modelReasoningEffort: SOL_MAX_SUBAGENT_EFFORT
-    }),
-    terra_max_context_tools: Object.freeze({
-        policy: 'terra_max_context_tools',
-        kind: 'worker',
-        model: TERRA_SUBAGENT_MODEL,
-        modelReasoningEffort: TERRA_SUBAGENT_EFFORT
-    })
+    luna_max_mechanical: tierProfile('luna_max_mechanical', 'worker', 'fast', LUNA_SUBAGENT_EFFORT),
+    sol_high_implementation: tierProfile('sol_high_implementation', 'worker', 'balanced', DEFAULT_SUBAGENT_EFFORT),
+    sol_max_judgment: tierProfile('sol_max_judgment', 'expert', 'deep', SOL_MAX_SUBAGENT_EFFORT),
+    terra_max_context_tools: tierProfile('terra_max_context_tools', 'worker', 'context', TERRA_SUBAGENT_EFFORT)
 });
 const JUDGMENT_TASK_RE = new RegExp([
     '\\breview(?:er|ing)?\\b',
@@ -272,19 +265,8 @@ const IMPLEMENTATION_TASK_RE = new RegExp([
 const CLEAR_IMPLEMENTATION_ACTION_RE = /(?:^|[.!?]\s*|\bphase\s*:\s*)\s*(?:implement|build|create|add|modify|fix|code|refactor)\b|(?:^|[.!?]\s*)\s*(?:구현|개발|추가|수정|고쳐|코딩|리팩터)/i;
 const DOCUMENT_EXPLORATION_RE = /\b(?:read|scan|explore|compare|summarize|review)\b[^\n]{0,64}\b(?:docs?|documentation|manual|notes?|references?)\b|(?:문서|매뉴얼|노트|자료)[^\n]{0,32}(?:읽|탐색|조사|비교|정리|검토)/i;
 export function subagentModelProfile(policy) {
-    return SUBAGENT_MODEL_POLICIES[policy];
-}
-export function narutoChildAssignment(policy) {
-    switch (policy) {
-        case 'luna_max_mechanical':
-            return { model: NARUTO_LUNA_MODEL, effort: 'low' };
-        case 'sol_high_implementation':
-            return { model: NARUTO_SOL_MODEL, effort: 'low' };
-        case 'terra_max_context_tools':
-            return { model: NARUTO_TERRA_MODEL, effort: 'medium' };
-        case 'sol_max_judgment':
-            return { model: ASTRA_SUBAGENT_MODEL, effort: 'max' };
-    }
+    const profile = SUBAGENT_MODEL_POLICIES[policy];
+    return { policy: profile.policy, kind: profile.kind, tier: profile.tier, model: profile.model, modelReasoningEffort: profile.modelReasoningEffort };
 }
 export function decideSubagentModel(input = {}) {
     const text = [

package/dist/core/subagents/model-tiers.js

@@ -0,0 +1,153 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { codexHomePath } from '../codex-app/codex-model-catalog.js';
+const MODELS_CACHE_FILENAME = 'models_cache.json';
+function modelsCachePath(input) {
+    return path.join(codexHomePath(input), MODELS_CACHE_FILENAME);
+}
+export const MODEL_TIERS = Object.freeze(['fast', 'balanced', 'context', 'deep']);
+export const MODEL_TIER_EFFORT = Object.freeze({
+    fast: 'low',
+    balanced: 'low',
+    context: 'medium',
+    deep: 'max'
+});
+export const MODEL_TIER_SUMMARY = Object.freeze({
+    fast: 'Fastest latest model. Mechanical edits, renames, formatting, and other one-step changes.',
+    balanced: 'Fast latest model. Simple coding whose result is already specified.',
+    context: 'Latest model at medium effort. Search, multi-file reading, broad exploration, and tool use.',
+    deep: 'Most capable latest model. Judgment, architecture, ambiguity, security, or high-stakes work.'
+});
+const TIER_FAMILIES = Object.freeze({
+    fast: ['luna'],
+    balanced: ['sol'],
+    context: ['terra', 'sol'],
+    deep: ['astra']
+});
+export const BUILTIN_LATEST_TIER_MODELS = Object.freeze({
+    fast: 'gpt-6-luna',
+    balanced: 'gpt-6-sol',
+    context: 'gpt-6-sol',
+    deep: 'gpt-6-astra'
+});
+const MODEL_ID_RE = /^gpt-(\d+(?:\.\d+)*)-([a-z]+)$/;
+let memo = null;
+export function resetLatestModelTierCache() {
+    memo = null;
+}
+export function resolveLatestModelTiers(input = {}) {
+    const file = modelsCachePath(input);
+    let stat = null;
+    try {
+        stat = fs.statSync(file);
+    }
+    catch {
+        stat = null;
+    }
+    const key = stat ? `${file}:${stat.mtimeMs}:${stat.size}` : `${file}:absent`;
+    if (memo?.key === key)
+        return memo.value;
+    const rows = stat && stat.isFile() && stat.size <= 16 * 1024 * 1024 ? readCandidateRows(file) : [];
+    const value = resolveFromRows(rows);
+    memo = { key, value };
+    return value;
+}
+export function latestModelForTier(tier, input = {}) {
+    return resolveLatestModelTiers(input).models[tier];
+}
+export function latestTierModelSet(input = {}) {
+    return new Set(Object.values(resolveLatestModelTiers(input).models));
+}
+export function isModelTier(value) {
+    return typeof value === 'string' && MODEL_TIERS.includes(value);
+}
+export function modelTierForModel(model) {
+    const match = MODEL_ID_RE.exec(String(model || '').trim());
+    if (!match)
+        return null;
+    const family = String(match[2] || '');
+    for (const tier of MODEL_TIERS) {
+        if (TIER_FAMILIES[tier][0] === family)
+            return tier;
+    }
+    return null;
+}
+export function effortForTier(tier, resolved = resolveLatestModelTiers()) {
+    const wanted = MODEL_TIER_EFFORT[tier];
+    const supported = resolved.supported_efforts[resolved.models[tier]] || [];
+    if (!supported.length || supported.includes(wanted))
+        return wanted;
+    const order = ['low', 'medium', 'high', 'max'];
+    const index = order.indexOf(wanted);
+    const byDistance = [...order].sort((a, b) => Math.abs(order.indexOf(a) - index) - Math.abs(order.indexOf(b) - index));
+    return byDistance.find((effort) => supported.includes(effort)) || wanted;
+}
+function readCandidateRows(file) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return [];
+    }
+    const models = Array.isArray(parsed?.models) ? parsed.models : Array.isArray(parsed) ? parsed : [];
+    const rows = [];
+    for (const row of models.slice(0, 1024)) {
+        if (!row || typeof row !== 'object')
+            continue;
+        const slug = String(row.slug || row.model || row.id || '').trim();
+        const match = MODEL_ID_RE.exec(slug);
+        if (!match)
+            continue;
+        const visibility = String(row.visibility || 'list').toLowerCase();
+        if (visibility === 'hide' || visibility === 'hidden')
+            continue;
+        const efforts = Array.isArray(row.supported_reasoning_levels)
+            ? row.supported_reasoning_levels
+                .map((level) => String(typeof level === 'string' ? level : level?.effort || '').trim().toLowerCase())
+                .filter(Boolean)
+            : [];
+        rows.push({ slug, version: String(match[1] || '0').split('.').map(Number), family: String(match[2] || ''), efforts });
+    }
+    return rows;
+}
+function compareVersions(a, b) {
+    const length = Math.max(a.length, b.length);
+    for (let index = 0; index < length; index += 1) {
+        const diff = (a[index] || 0) - (b[index] || 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+function newestRow(rows) {
+    return [...rows].sort((left, right) => compareVersions(right.version, left.version))[0] || null;
+}
+function resolveFromRows(rows) {
+    const models = { ...BUILTIN_LATEST_TIER_MODELS };
+    const supported = Object.fromEntries(rows.map((row) => [row.slug, row.efforts]));
+    let fromCache = true;
+    for (const tier of MODEL_TIERS) {
+        const families = TIER_FAMILIES[tier];
+        const candidates = rows
+            .filter((row) => families.includes(row.family))
+            .sort((left, right) => compareVersions(right.version, left.version)
+            || families.indexOf(left.family) - families.indexOf(right.family));
+        const pick = candidates[0] || newestRow(rows);
+        if (!pick) {
+            fromCache = false;
+            continue;
+        }
+        models[tier] = pick.slug;
+    }
+    return Object.freeze({
+        source: fromCache && rows.length ? 'models_cache' : 'builtin',
+        models: Object.freeze(models),
+        efforts: MODEL_TIER_EFFORT,
+        supported_efforts: Object.freeze(supported)
+    });
+}
+export function codexListedEfforts(model, input = {}) {
+    const efforts = resolveLatestModelTiers(input).supported_efforts[String(model || '').trim()];
+    return efforts && efforts.length ? efforts : null;
+}

package/dist/core/subagents/naruto-command-args.js

@@ -1,7 +1,7 @@
 import { uniqueStrings } from '../text/strings.js';
 import { NARUTO_CREDENTIAL_BOOLEAN_FLAGS, NARUTO_CREDENTIAL_VALUE_FLAGS } from './naruto-command-input-contract.js';
 import { resolveNarutoCredentialPolicy } from './naruto-host-credentials.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 { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
 export function parseNarutoArgs(args) {
     const helpRequested = args.includes('--help') || args.includes('-h');
@@ -121,9 +121,9 @@ export function parseNarutoArgs(args) {
         credentialPolicy: resolveNarutoCredentialPolicy({
             args: action === 'run' ? optionArgs : [],
             env: action === 'run' ? process.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/naruto-help-contract.js

@@ -1,4 +1,5 @@
-import { NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
+import { NARUTO_PARENT_EFFORT, narutoParentModel } from './model-policy.js';
+import { resolveLatestModelTiers } from './model-tiers.js';
 import { NARUTO_ACTIONS } from '../safety/command-contract/types.js';
 import { DEFAULT_AUTOMATIC_SUBAGENT_COUNT, MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, MAX_CRITICAL_AUTOMATIC_REVIEWER_COUNT, MAX_MASS_AUTOMATIC_SUBAGENT_COUNT, officialSubagentRolePlan } from './agent-catalog.js';
 export const NARUTO_HELP_SCHEMA = 'sks.naruto-subagent-workflow.v1';
@@ -21,16 +22,18 @@ export function renderNarutoUsage() {
         '  --model-provider NAME    Host config.toml provider block (host mode only).',
         '  --provider-env-key NAME  Environment-variable name used by that provider.',
         '  --parent-model NAME      Override the parent model identifier.',
-        '  --parent-effort TIER     Astra parent default: max; use model-advertised tiers.',
-        '  --subagent-model NAME    Child model; only gpt-6-astra is accepted.',
-        '  --subagent-effort TIER   Astra low|medium|high|xhigh|max|ultra; vary effort by task.',
+        '  --parent-effort TIER     Parent default: max; use efforts the model lists.',
+        '  --subagent-model NAME    Default child model; any current tier model (default: latest deep).',
+        '  --subagent-effort TIER   low|medium|high|xhigh|max|ultra as the model lists; vary by task.',
         '  --no-forced-login-method Do not inject a forced login method.',
         '  --json                   Emit machine-readable output.',
         '',
-        'Default efforts: Low for instructed ordinary coding and tiny mechanical work, Medium for context/tools, Max for planning/analysis/review judgment; explicit High remains supported.',
-        'Automatic fan-out starts at 4/6/8, or 16 for eligible mass mechanical or exploration work on the Astra Low/Medium lanes.',
+        'Model tiers: every child runs the newest model of its tier: fast for tiny mechanical work, balanced for instructed coding, context for reads and tools, deep for planning, analysis, and review judgment.',
+        'Automatic fan-out starts at 4/6/8, or 16 for eligible mass mechanical or exploration work on the fast and context tiers.',
         'After decomposition, either lane may expand to 256 independent useful children.',
-        'A measured lower Codex host or explicit provider/API limit remains authoritative.'
+        'A measured lower Codex host or explicit provider/API limit remains authoritative.',
+        'Jev mode on: Jev picks each Codex App child spawn\'s tier and SKS seals its newest model; a stored role preference wins.',
+        'The parent orchestrates only; the PreToolUse gate denies parent source edits before the first child starts and while children run.'
     ].join('\n');
 }
 export function buildNarutoHelpResult() {
@@ -53,7 +56,7 @@ export function buildNarutoHelpResult() {
         automatic_subagent_ceiling: MAX_AUTOMATIC_SUBAGENT_COUNT,
         mass_automatic_subagent_ceiling: MAX_MASS_AUTOMATIC_SUBAGENT_COUNT,
         absolute_hard_frame_cap: 256,
-        fanout_contract: 'automatic fan-out starts at 4/6/8/16 for bounded, explicit-parallel, large-scale, and mass mechanical or exploration work on the Astra Low/Medium lanes; after decomposition both lanes may expand to the 256-child SKS ceiling, max_threads defaults to a 256-child frame budget that is a cap rather than a target, measured lower Codex host and explicit provider/API limits remain authoritative, and later waves reuse capacity',
+        fanout_contract: 'automatic fan-out starts at 4/6/8/16 for bounded, explicit-parallel, large-scale, and mass mechanical or exploration work on the fast and context tiers; after decomposition both lanes may expand to the 256-child SKS ceiling, max_threads defaults to a 256-child frame budget that is a cap rather than a target, measured lower Codex host and explicit provider/API limits remain authoritative, and later waves reuse capacity',
         automatic_reviewer_ceiling: MAX_AUTOMATIC_REVIEWER_COUNT,
         critical_multi_domain_reviewer_ceiling: MAX_CRITICAL_AUTOMATIC_REVIEWER_COUNT,
         max_threads_is_cap_not_target: true,
@@ -62,17 +65,19 @@ export function buildNarutoHelpResult() {
         triwiki_context: 'bounded_attention_use_first_with_on_demand_hydration',
         model_routing_policy: {
             luna_max: 'tiny_short_context_mechanical_and_mass_shards',
-            sol_high: 'astra_low_instructed_ordinary_ui_logic_backend_and_native_implementation',
-            sol_max: 'astra_max_review_debug_planning_architecture_security_database_research_release_and_judgment',
-            terra_max: 'astra_medium_broad_search_exploration_long_context_long_term_memory_large_first_draft_computer_use_browser_chrome_and_image_generation_execution',
-            mixed_slice_rule: 'split_execution_from_judgment_when_possible_otherwise_astra_max_wins'
+            sol_high: 'balanced_tier_instructed_ordinary_ui_logic_backend_and_native_implementation',
+            sol_max: 'deep_tier_review_debug_planning_architecture_security_database_research_release_and_judgment',
+            terra_max: 'context_tier_broad_search_exploration_long_context_long_term_memory_large_first_draft_computer_use_browser_chrome_and_image_generation_execution',
+            mixed_slice_rule: 'split_execution_from_judgment_when_possible_otherwise_deep_tier_wins',
+            tier_models: 'each tier resolves to the newest model the Codex models cache lists; no model family is pinned',
+            current_tier_models: resolveLatestModelTiers().models
         },
         completion_evidence: {
             lifecycle_events: ['SubagentStart', 'SubagentStop'],
             stop_is_success_evidence: false,
             structured_parent_summary: 'subagent-parent-summary.json'
         },
-        parent: { model: NARUTO_PARENT_MODEL, model_reasoning_effort: NARUTO_PARENT_EFFORT },
+        parent: { model: narutoParentModel(), model_reasoning_effort: NARUTO_PARENT_EFFORT },
         agent_catalog_mode: 'full_catalog_only_on_explicit_help',
         agents: officialSubagentRolePlan()
     };

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

@@ -1,4 +1,5 @@
-import { ASTRA_SUBAGENT_MODEL, LUNA_SUBAGENT_MODEL } from './model-policy.js';
+import { defaultSubagentModel } from './model-policy.js';
+import { codexListedEfforts, latestTierModelSet } from './model-tiers.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']);
@@ -80,7 +81,7 @@ export function resolveNarutoCredentialPolicy(input) {
     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: ASTRA_SUBAGENT_MODEL, effort: false },
+        { 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 = {};
@@ -103,9 +104,9 @@ export function resolveNarutoCredentialPolicy(input) {
         resolvedModels[entry.key] = raw.value;
         sources[entry.key] = raw.source;
     }
-    if (resolvedModels.subagentModel !== ASTRA_SUBAGENT_MODEL) {
-        blockers.push('naruto_subagent_model_must_be_astra');
-        resolvedModels.subagentModel = ASTRA_SUBAGENT_MODEL;
+    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);
@@ -146,15 +147,9 @@ export function resolveNarutoCredentialPolicy(input) {
     };
 }
 function validateGpt56EffortPair(scope, model, effort, blockers) {
-    const allowed = model === ASTRA_SUBAGENT_MODEL
-        ? ['low', 'medium', 'high', 'xhigh', 'max', 'ultra']
-        : model === LUNA_SUBAGENT_MODEL || model === 'gpt-5.6-terra'
-            ? ['max']
-            : model === 'gpt-5.6-sol'
-                ? scope === 'parent' ? ['max'] : ['high', 'max']
-                : null;
+    const allowed = codexListedEfforts(model);
     if (allowed && !allowed.includes(effort)) {
-        blockers.push(`naruto_${scope}_gpt56_effort_policy_mismatch:${model}:${effort}:allowed_${allowed.join('_or_')}`);
+        blockers.push(`naruto_${scope}_effort_unsupported:${model}:${effort}:allowed_${allowed.join('_or_')}`);
     }
 }
 export function narutoCredentialConfigArgs(policy) {

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

@@ -5,7 +5,8 @@ import { parse } from 'smol-toml';
 import { ensureDir, exists, PACKAGE_VERSION, readText, sha256, writeTextAtomic } from '../fsx.js';
 import { ensureConfinedDirectory, inspectConfinedPath } from '../managed-path-safety.js';
 import { MANAGED_OFFICIAL_SUBAGENT_ROLES, managedOfficialSubagentRoleContent, managedOfficialSubagentRoleOwnsText } from '../managed-assets/managed-assets-manifest.js';
-import { DEFAULT_SUBAGENT_EFFORT, DEFAULT_SUBAGENT_MODEL } from './model-policy.js';
+import { DEFAULT_SUBAGENT_EFFORT, defaultSubagentModel as latestDefaultSubagentModel } from './model-policy.js';
+import { latestTierModelSet } from './model-tiers.js';
 import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
 import { escapeRegExp } from '../text/regex.js';
 export const DEFAULT_OFFICIAL_SUBAGENT_MAX_THREADS = 256;
@@ -13,7 +14,9 @@ export const DEFAULT_OFFICIAL_SUBAGENT_MAX_DEPTH = 1;
 export const DEFAULT_OFFICIAL_SUBAGENT_JOB_MAX_RUNTIME_SECONDS = 1200;
 export const DEFAULT_OFFICIAL_SUBAGENT_INTERRUPT_MESSAGE = true;
 export const DEFAULT_OFFICIAL_SUBAGENT_ENABLED = true;
-export const DEFAULT_OFFICIAL_SUBAGENT_MODEL = DEFAULT_SUBAGENT_MODEL;
+export function defaultOfficialSubagentModel() {
+    return latestDefaultSubagentModel();
+}
 export const DEFAULT_OFFICIAL_SUBAGENT_REASONING_EFFORT = DEFAULT_SUBAGENT_EFFORT;
 export const DEFAULT_MULTI_AGENT_V2_MAX_CONCURRENT_THREADS_PER_SESSION = DEFAULT_OFFICIAL_SUBAGENT_MAX_THREADS + 1;
 export const LEGACY_SKS_MAX_THREAD_VALUES = Object.freeze([4, 5, 6, 12]);
@@ -49,7 +52,8 @@ 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}`);
-    next = upsertTomlTableKey(next, 'agents', `default_subagent_model = "${DEFAULT_OFFICIAL_SUBAGENT_MODEL}"`);
+    const existingDefault = /^\s*default_subagent_model\s*=\s*"([^"]*)"/m.exec(next)?.[1] || '';
+    next = upsertTomlTableKey(next, 'agents', `default_subagent_model = "${latestTierModelSet().has(existingDefault) ? existingDefault : defaultOfficialSubagentModel()}"`);
     next = upsertDefaultUnlessInherited(next, inheritedAgents, 'default_subagent_reasoning_effort', `default_subagent_reasoning_effort = "${DEFAULT_OFFICIAL_SUBAGENT_REASONING_EFFORT}"`);
     next = mergeOfficialMultiAgentV2FeatureConfig(next, {
         sksOwned: opts.sksOwned === true,
@@ -136,17 +140,17 @@ 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, DEFAULT_OFFICIAL_SUBAGENT_MODEL, nonEmptyString);
+    const defaultSubagentModel = resolveLayeredValue(projectLayer.agents.default_subagent_model, globalLayer.agents.default_subagent_model, 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 = defaultSubagentModel.value !== DEFAULT_OFFICIAL_SUBAGENT_MODEL;
+    const modelCoerced = !latestTierModelSet().has(String(defaultSubagentModel.value));
     const depthCoerced = maxDepth.value > 1;
     const warnings = [
-        ...(modelCoerced ? [`official_subagent_model_coerced_to_astra:${defaultSubagentModel.value}:${defaultSubagentModel.source}`] : []),
+        ...(modelCoerced ? [`official_subagent_model_coerced_to_latest:${defaultSubagentModel.value}:${defaultSubagentModel.source}`] : []),
         ...(depthCoerced ? [`official_subagent_max_depth_coerced_to_one:${maxDepth.value}:${maxDepth.source}`] : []),
         ...capacityNormalizationWarnings(maxThreads, multiAgentV2),
         ...(projectLayer.legacyWarnings),
@@ -158,7 +162,7 @@ export async function readOfficialSubagentConfig(root, opts = {}) {
         maxDepth: depthCoerced ? DEFAULT_OFFICIAL_SUBAGENT_MAX_DEPTH : maxDepth.value,
         jobMaxRuntimeSeconds: null,
         interruptMessage: interruptMessage.value,
-        defaultSubagentModel: DEFAULT_OFFICIAL_SUBAGENT_MODEL,
+        defaultSubagentModel: modelCoerced ? defaultOfficialSubagentModel() : String(defaultSubagentModel.value),
         defaultSubagentReasoningEffort: defaultSubagentReasoningEffort.value,
         multiAgentV2: effectiveMultiAgentV2,
         sources: {