sneakoscope 6.1.2 → 6.2.0

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

@@ -1,29 +1,58 @@
 export const NARUTO_PARENT_MODEL = 'gpt-5.6-sol';
 export const NARUTO_PARENT_EFFORT = 'max';
-export const DEFAULT_SUBAGENT_MODEL = 'gpt-5.6-luna';
-export const THINKING_SUBAGENT_MODEL = 'gpt-5.6-sol';
-export const SUBAGENT_EFFORT = 'max';
-const SOL_TASK_RE = new RegExp([
-    '\\bui\\b',
-    '\\bux\\b',
-    '\\bgui\\b',
-    'frontend',
-    'visual',
-    'review',
-    'audit',
-    'debug',
+export const LUNA_SUBAGENT_MODEL = 'gpt-5.6-luna';
+export const TERRA_SUBAGENT_MODEL = 'gpt-5.6-terra';
+export const SOL_SUBAGENT_MODEL = 'gpt-5.6-sol';
+export const LUNA_SUBAGENT_EFFORT = 'max';
+export const TERRA_SUBAGENT_EFFORT = 'medium';
+export const DEFAULT_SUBAGENT_EFFORT = 'high';
+export const SOL_MAX_SUBAGENT_EFFORT = 'max';
+// Compatibility exports retained for research and older callers. New code
+// should select a policy profile instead of combining model/effort constants.
+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 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_medium_context_tools: Object.freeze({
+        policy: 'terra_medium_context_tools',
+        kind: 'worker',
+        model: TERRA_SUBAGENT_MODEL,
+        modelReasoningEffort: TERRA_SUBAGENT_EFFORT
+    })
+});
+const JUDGMENT_TASK_RE = new RegExp([
+    '\\breview(?:er|ing)?\\b',
+    '\\baudit(?:or|ing)?\\b',
+    '\\bdebug(?:ger|ging)?\\b',
     'diagnos',
     'investigat',
     '\\bwhy\\b',
     '\\bfail(?:ed|ure|ing)?\\b',
     'root[- ]?cause',
     'strategy',
-    '\\bplan\\b',
-    'planning',
+    '\\bplan(?:ning)?\\b',
     'product',
     'architecture',
     'architect',
-    'design',
+    '\\bdesign(?:ing)?\\b',
     'refactor',
     'integrat',
     'conflict',
@@ -36,8 +65,12 @@ const SOL_TASK_RE = new RegExp([
     'release',
     'publish',
     'deploy',
-    'tests?[-_ ]?(?:fail|failure|debug|diagnos|root[- ]?cause)',
-    'failing tests?',
+    'research',
+    'hypothesis',
+    'falsif',
+    'novelty',
+    'test[-_ ]?(?:design|strategy|coverage|gap|review)',
+    'regression',
     'flaky',
     'ambiguous',
     'ambiguity',
@@ -47,15 +80,12 @@ const SOL_TASK_RE = new RegExp([
     'assessment',
     '\\bexpert\\b',
     '\\brisk\\b',
-    '사용성',
-    '화면',
-    '유아이',
-    '유엑스',
-    '프론트엔드',
     '리뷰',
     '검토',
+    '감사',
     '디버깅',
     '진단',
+    '조사',
     '원인',
     '전략',
     '기획',
@@ -66,27 +96,123 @@ const SOL_TASK_RE = new RegExp([
     '통합',
     '충돌',
     '보안',
+    '인증',
     '안전',
     '데이터베이스',
     '마이그레이션',
     '배포',
     '릴리즈',
     '출시',
+    '연구',
+    '가설',
+    '반증',
+    '회귀',
     '모호',
     '트레이드오프',
     '품질',
     '판정',
     '위험'
 ].join('|'), 'i');
-const CLEAR_BOUNDED_TASK_RE = new RegExp([
-    '\\b(?:clear|bounded|exact|specified)\\b[^\n]{0,48}\\b(?:task|change|step|scope|fixture|file|implementation|rename|copy|format|inventory|extract|list|check)\\b',
-    '\\b(?:mechanical|repeatable)\\b',
-    '\\bstructured[- ]?(?:extract|extraction|output|inventory|list)\\b',
-    'code_modification',
-    'test_execution',
-    'single[- ]?(?:file|step|check|change)',
-    '(?:정해진|명확한?|단순한?|반복적?|기계적)[^\n]{0,32}(?:작업|변경|단계|파일|목록|추출|이름\\s*변경)'
+const CONTEXT_TOOL_TASK_RE = new RegExp([
+    'computer[- ]?use',
+    '\\bbrowser(?:[- ]?use)?\\b',
+    '\\bchrome\\b',
+    '\\bplaywright\\b',
+    '\\bselenium\\b',
+    '\\bpuppeteer\\b',
+    'image[- ]?(?:gen|generation)',
+    '\\bimagegen\\b',
+    'gpt[- ]?image',
+    '\\bscreenshot(?:ting)?\\b',
+    'long[- ]?context',
+    'large[- ]?(?:file|document|codebase|repository|context)',
+    '(?:repository|repo)[- ]?wide',
+    'read[- ]?heavy',
+    'supporting[- ]?documents?',
+    'multi[- ]?(?:document|file) scan',
+    '\\bexplor(?:e|er|ation)\\b',
+    '\\bscan(?:ning)?\\b',
+    '\\bextract(?:ion)?\\b',
+    '\\binventory\\b',
+    'extensive[- ]?logs?',
+    '컴퓨터\\s*유즈',
+    '브라우저',
+    '크롬',
+    '이미지\\s*생성',
+    '스크린샷',
+    '롱\\s*컨텍스트',
+    '긴\\s*컨텍스트',
+    '장문',
+    '대규모',
+    '저장소\\s*전체',
+    '여러\\s*(?:문서|파일)',
+    '탐색',
+    '스캔',
+    '추출',
+    '인벤토리'
+].join('|'), 'i');
+const SIMPLE_MECHANICAL_TASK_RE = new RegExp([
+    '\\bone[- ]?line\\b',
+    '\\bsingle[- ]?file\\b',
+    '\\btiny\\b',
+    '\\btrivial\\b',
+    '\\bmechanical\\b',
+    '\\brepeatable\\b',
+    '\\bexact(?:ly)?\\b[^\\n]{0,36}\\b(?:rename|copy|replace|format|fixture|change)\\b',
+    '\\b(?:typo|spacing|label|copy|format)[-_ ]?(?:only|fix|change)?\\b',
+    '\\brename\\b[^\\n]{0,24}\\b(?:symbol|file|label|key|field)\\b',
+    '한\\s*줄',
+    '단일\\s*파일',
+    '아주\\s*(?:작은|단순한?)',
+    '극단적으로\\s*단순',
+    '기계적',
+    '반복적',
+    '정확한?[^\\n]{0,24}(?:이름\\s*변경|복사|치환|포맷|수정)',
+    '오타',
+    '문구',
+    '라벨',
+    '간격',
+    '이름\\s*변경'
+].join('|'), 'i');
+const IMPLEMENTATION_TASK_RE = new RegExp([
+    '\\bimplement(?:ation|er|ing)?\\b',
+    '\\bbuild(?:ing)?\\b',
+    '\\bcreate\\b',
+    '\\badd\\b[^\\n]{0,40}\\b(?:feature|endpoint|component|modal|button|handler|parser)\\b',
+    '\\bmodify\\b',
+    '\\bfix\\b',
+    '\\bcod(?:e|ing)\\b',
+    '\\bui\\b',
+    '\\bux\\b',
+    '\\bgui\\b',
+    'frontend',
+    'backend',
+    '\\blogic\\b',
+    '\\bparser\\b',
+    '\\bcomponent\\b',
+    '\\bmodal\\b',
+    '\\bappkit\\b',
+    '\\bswift\\b',
+    '\\bfeature\\b',
+    '구현',
+    '기능\\s*추가',
+    '코딩',
+    '코드',
+    '로직',
+    '화면',
+    '유아이',
+    '유엑스',
+    '프론트엔드',
+    '백엔드',
+    '컴포넌트',
+    '모달',
+    '버튼',
+    '앱킷',
+    '스위프트'
 ].join('|'), 'i');
+export function subagentModelProfile(policy) {
+    return SUBAGENT_MODEL_POLICIES[policy];
+}
 export function decideSubagentModel(input = {}) {
     const text = [
         input.title,
@@ -94,25 +220,40 @@ export function decideSubagentModel(input = {}) {
         input.role,
         input.expectedOutput
     ].filter(Boolean).join(' ');
-    const useSol = input.requiresJudgment === true
-        || SOL_TASK_RE.test(text)
-        || !CLEAR_BOUNDED_TASK_RE.test(text);
-    if (useSol) {
-        return {
-            kind: 'expert',
-            model: THINKING_SUBAGENT_MODEL,
-            modelReasoningEffort: SUBAGENT_EFFORT,
-            reason: 'reasoning_sensitive_task'
-        };
-    }
-    return {
-        kind: 'worker',
-        model: DEFAULT_SUBAGENT_MODEL,
-        modelReasoningEffort: SUBAGENT_EFFORT,
-        reason: 'clear_bounded_repeatable_task'
-    };
+    const judgment = input.requiresJudgment === true
+        || input.taskClass === 'judgment'
+        || JUDGMENT_TASK_RE.test(text);
+    if (judgment)
+        return decision('sol_max_judgment');
+    const contextOrTools = input.longContext === true
+        || input.toolHeavy === true
+        || input.taskClass === 'context_tools'
+        || input.contextMode === 'long'
+        || (input.toolSurface !== undefined && input.toolSurface !== 'none')
+        || input.scopeSize === 'large'
+        || CONTEXT_TOOL_TASK_RE.test(text);
+    if (contextOrTools)
+        return decision('terra_medium_context_tools');
+    const simpleMechanical = input.simpleMechanical === true
+        || input.taskClass === 'mechanical'
+        || input.scopeSize === 'tiny'
+        || SIMPLE_MECHANICAL_TASK_RE.test(text);
+    if (simpleMechanical)
+        return decision('luna_max_mechanical');
+    const implementation = input.taskClass === 'implementation' || IMPLEMENTATION_TASK_RE.test(text);
+    if (implementation)
+        return decision('sol_high_implementation');
+    // Ambiguous work defaults to the trust-first lane. Sol High is reserved for
+    // clearly identified implementation, not for underspecified judgment.
+    return decision('sol_max_judgment');
 }
 export function isReasoningSensitiveSubagentTask(input = {}) {
-    return decideSubagentModel(input).kind === 'expert';
+    return decideSubagentModel(input).policy === 'sol_max_judgment';
+}
+function decision(policy) {
+    return {
+        ...subagentModelProfile(policy),
+        reason: policy
+    };
 }
 //# sourceMappingURL=model-policy.js.map

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

@@ -1,6 +1,5 @@
 import { NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
-import { DEFAULT_NARUTO_REQUESTED_SUBAGENTS } from './thread-budget.js';
-import { MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, officialSubagentRolePlan } from './agent-catalog.js';
+import { DEFAULT_AUTOMATIC_SUBAGENT_COUNT, MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, officialSubagentRolePlan } from './agent-catalog.js';
 export const NARUTO_HELP_SCHEMA = 'sks.naruto-subagent-workflow.v1';
 export function buildNarutoHelpResult() {
     return {
@@ -16,13 +15,20 @@ export function buildNarutoHelpResult() {
             'sks naruto proof [latest|M-...] [--json]'
         ],
         commands: ['help', 'status', 'subagents', 'proof', 'run'],
-        default_requested_subagents: DEFAULT_NARUTO_REQUESTED_SUBAGENTS,
-        scaling_policy: 'one_safe_direct_child_by_default_parent_owned_risk_based_expansion',
+        default_requested_subagents: DEFAULT_AUTOMATIC_SUBAGENT_COUNT,
+        scaling_policy: 'two_independent_children_for_non_trivial_work_parent_owned_risk_based_expansion',
         automatic_subagent_ceiling: MAX_AUTOMATIC_SUBAGENT_COUNT,
         automatic_reviewer_ceiling: MAX_AUTOMATIC_REVIEWER_COUNT,
         critical_multi_domain_reviewer_ceiling: MAX_AUTOMATIC_SUBAGENT_COUNT,
         max_depth: 1,
         triwiki_context: 'bounded_attention_use_first_with_on_demand_hydration',
+        model_routing_policy: {
+            luna_max: 'tiny_short_context_mechanical_only',
+            sol_high: 'ordinary_ui_logic_backend_and_native_implementation',
+            sol_max: 'review_debug_planning_architecture_security_database_research_release_and_judgment',
+            terra_medium: 'long_context_computer_use_browser_chrome_and_image_generation_execution',
+            mixed_slice_rule: 'split_execution_from_judgment_when_possible_otherwise_sol_max_wins'
+        },
         completion_evidence: {
             lifecycle_events: ['SubagentStart', 'SubagentStop'],
             stop_is_success_evidence: false,
@@ -34,6 +40,7 @@ export function buildNarutoHelpResult() {
         },
         legacy_process_runtime_available: false,
         parent: { model: NARUTO_PARENT_MODEL, model_reasoning_effort: NARUTO_PARENT_EFFORT },
+        agent_catalog_mode: 'full_catalog_only_on_explicit_help',
         agents: officialSubagentRolePlan()
     };
 }

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

@@ -6,7 +6,7 @@ import { chooseVerificationBudget } from '../runtime/verification-budget.js';
 import { buildOfficialSubagentPrompt } from './official-subagent-prompt.js';
 import { readOfficialSubagentConfig } from './official-subagent-config.js';
 import { NARUTO_PARENT_EFFORT, NARUTO_PARENT_MODEL } from './model-policy.js';
-import { officialSubagentFanoutPolicy, officialSubagentRolePlan, recommendOfficialSubagentRoles } from './agent-catalog.js';
+import { MAX_ON_DEMAND_SUBAGENT_ROLE_COUNT, officialSubagentFanoutPolicy, officialSubagentOnDemandRolePlan, officialSubagentRoleCatalog, recommendOfficialSubagentRoles } from './agent-catalog.js';
 import { resolveSubagentThreadBudget } from './thread-budget.js';
 import { readBoundedTriwikiAttention } from './triwiki-attention.js';
 import { SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_EVENT_LOG_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME, normalizeSubagentParentSummary, writeSubagentEvidence } from './subagent-evidence.js';
@@ -24,11 +24,21 @@ export async function prepareOfficialSubagentMission(input) {
         requiresWrite: input.readOnly !== true
     });
     const officialConfig = await readOfficialSubagentConfig(input.root);
-    const triwikiAttention = await readBoundedTriwikiAttention(input.root);
-    const requestedExplicit = input.requestedSubagentsExplicit ?? input.requestedSubagents !== undefined;
+    const triwikiAttention = await readBoundedTriwikiAttention(input.root, triwikiAttentionLimit(taskProfile), goal);
+    const operatorRequested = input.requestedSubagentsExplicit ?? input.requestedSubagents !== undefined;
+    const routeContract = mode === 'generic' && !operatorRequested
+        ? routeOwnedSubagentContract(input.route)
+        : null;
+    const requestedSubagents = input.requestedSubagents ?? routeContract?.count;
+    const requestedSource = operatorRequested
+        ? 'operator'
+        : routeContract
+            ? 'route_contract'
+            : 'automatic';
     const selectedFanoutPolicy = officialSubagentFanoutPolicy({
-        ...(input.requestedSubagents === undefined ? {} : { requestedSubagents: input.requestedSubagents }),
-        requestedExplicit,
+        ...(requestedSubagents === undefined ? {} : { requestedSubagents }),
+        requestedExplicit: requestedSource !== 'automatic',
+        requestedSource,
         taskProfile,
         suggestedRoles: suggestedAgents,
         goal
@@ -53,12 +63,15 @@ export async function prepareOfficialSubagentMission(input) {
         goal: delegationGoal,
         slices: [],
         requestedSubagents: budget.requestedSubagents,
-        requestedSubagentsExplicit: requestedExplicit,
+        requestedSubagentsExplicit: requestedSource === 'operator',
+        requestedSubagentsSource: requestedSource,
         maxThreads: budget.maxThreads,
         decompositionStatus: 'parent_required',
         triwikiAttention,
         recommendedAgents: suggestedAgents
     });
+    const selectedAgentPlan = officialSubagentOnDemandRolePlan(suggestedAgents);
+    const agentCatalog = onDemandAgentCatalogMetadata(selectedAgentPlan);
     const configBlockers = officialConfig.blockers.map((blocker) => `official_subagent_config:${blocker}`);
     const plan = {
         schema: 'sks.subagent-plan.v1',
@@ -73,7 +86,9 @@ export async function prepareOfficialSubagentMission(input) {
         decomposition_status: 'parent_required',
         delegation_prompt: delegationPrompt,
         requested_subagents: budget.requestedSubagents,
-        requested_subagents_explicit: requestedExplicit,
+        requested_subagents_explicit: requestedSource === 'operator',
+        requested_subagents_source: requestedSource,
+        route_owned_count_contract: routeContract,
         max_threads: budget.maxThreads,
         first_wave: budget.firstWave,
         wave_count: budget.waveCount,
@@ -92,7 +107,8 @@ export async function prepareOfficialSubagentMission(input) {
             model: NARUTO_PARENT_MODEL,
             model_reasoning_effort: NARUTO_PARENT_EFFORT
         },
-        agents: officialSubagentRolePlan(),
+        agent_catalog: agentCatalog,
+        agents: selectedAgentPlan,
         verification_budget: verification,
         verification_checks: [],
         verification: { budget: verification },
@@ -134,6 +150,7 @@ export async function prepareOfficialSubagentMission(input) {
             ok: false,
             blockers,
             sessionKey: input.sessionScope || null,
+            suggestedAgents,
             observedParentModel,
             parentModelMatch
         }));
@@ -165,8 +182,25 @@ export async function prepareOfficialSubagentMission(input) {
         parentModelMatch
     };
 }
+function triwikiAttentionLimit(taskProfile) {
+    return ['parallel-read', 'parallel-write', 'high-risk'].includes(taskProfile) ? 6 : 4;
+}
+function routeOwnedSubagentContract(route) {
+    const normalized = String(route || '').replace(/^\$/, '').trim().toLowerCase();
+    if (normalized === 'research') {
+        return { count: 3, reason: 'research_exact_three_independent_reviewers' };
+    }
+    if (normalized === 'autoresearch') {
+        return { count: 3, reason: 'autoresearch_exact_three_independent_reviewers' };
+    }
+    return null;
+}
 export function buildNarutoSummary(input) {
     const parentSummary = normalizeSubagentParentSummary(input.parentSummary);
+    const suggestedAgents = Array.isArray(input.suggestedAgents)
+        ? uniqueStrings(input.suggestedAgents)
+        : [];
+    const selectedAgentPlan = officialSubagentOnDemandRolePlan(suggestedAgents);
     return {
         schema: NARUTO_RESULT_SCHEMA,
         ok: input.ok === true,
@@ -188,7 +222,8 @@ export function buildNarutoSummary(input) {
         started_subagents: Number(input.evidence?.started_threads || 0),
         completed_subagents: Number(input.evidence?.completed_threads || 0),
         failed_subagents: Number(input.evidence?.failed_threads || 0),
-        agents: officialSubagentRolePlan(),
+        agent_catalog: onDemandAgentCatalogMetadata(selectedAgentPlan),
+        agents: selectedAgentPlan,
         verification: {
             budget: input.verification,
             checks: []
@@ -203,6 +238,17 @@ export function buildNarutoSummary(input) {
         updated_at: nowIso()
     };
 }
+function onDemandAgentCatalogMetadata(selectedAgentPlan) {
+    const selectedAgents = Object.keys(selectedAgentPlan);
+    return {
+        mode: 'on_demand',
+        total_available: officialSubagentRoleCatalog().length,
+        selected_count: selectedAgents.length,
+        selected_agents: selectedAgents,
+        max_injected: MAX_ON_DEMAND_SUBAGENT_ROLE_COUNT,
+        full_catalog_injected: false
+    };
+}
 export async function writeNarutoGate(dir, input) {
     await writeJsonAtomic(path.join(dir, NARUTO_GATE_FILENAME), buildNarutoGateResult(input));
 }

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

@@ -1,30 +1,45 @@
 import { HARD_NARUTO_MAX_THREADS } from './thread-budget.js';
-import { MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, officialSubagentRoleCatalog, selectOfficialSubagentRole } from './agent-catalog.js';
+import { MAX_AUTOMATIC_REVIEWER_COUNT, MAX_AUTOMATIC_SUBAGENT_COUNT, officialSubagentOnDemandRoleCatalog, officialSubagentRoleCatalog, selectOfficialSubagentRole } from './agent-catalog.js';
 export function buildOfficialSubagentPrompt(input) {
     const maxThreads = clampThreads(input.maxThreads);
     const requestedSubagents = normalizeRequestedSubagents(input.requestedSubagents, input.slices.length);
     const waveCount = requestedSubagents === 0 ? 0 : Math.ceil(requestedSubagents / maxThreads);
     const parentDecompositionRequired = input.decompositionStatus === 'parent_required';
-    const requestedPolicy = input.requestedSubagentsExplicit === true
+    const requestedSource = input.requestedSubagentsSource === 'route_contract'
+        ? 'route_contract'
+        : input.requestedSubagentsExplicit === true || input.requestedSubagentsSource === 'operator'
+            ? 'operator'
+            : 'automatic';
+    const requestedPolicy = requestedSource === 'operator'
         ? `${requestedSubagents} (explicit operator request)`
-        : `${requestedSubagents} (risk-based automatic count; one child is the safe default; keep the plan and evidence count exact)`;
+        : requestedSource === 'route_contract'
+            ? `${requestedSubagents} (route-owned exact orchestration contract)`
+            : `${requestedSubagents} (risk-based automatic count; two independent children are the non-trivial default; keep the plan and evidence count exact)`;
     const triwiki = renderBoundedTriwikiAttention(input.triwikiAttention);
-    const catalog = renderAgentCatalog(input.recommendedAgents);
-    const rows = input.slices.map((slice, index) => {
-        const agentName = slice.agent || selectOfficialSubagentRole({
+    const resolvedSlices = input.slices.map((slice) => ({
+        slice,
+        agentName: slice.agent || selectOfficialSubagentRole({
             title: slice.title,
             description: slice.description,
             role: slice.kind,
             ...(slice.paths === undefined ? {} : { paths: slice.paths }),
             readOnly: slice.readOnly === true,
             requiresWrite: slice.readOnly !== true
-        });
+        })
+    }));
+    const catalog = renderAgentCatalog([
+        ...resolvedSlices.map((row) => row.agentName),
+        ...(input.recommendedAgents || [])
+    ]);
+    const rows = resolvedSlices.map(({ slice, agentName }, index) => {
         const mode = slice.readOnly ? 'read-only' : 'use the parent permission mode';
         const paths = (slice.paths || []).map((entry) => String(entry).trim()).filter(Boolean);
+        const role = officialSubagentOnDemandRoleCatalog([agentName])[0];
         return [
             `${index + 1}. [${slice.id}] use custom agent \`${agentName}\``,
             `   title: ${slice.title}`,
             `   task: ${slice.description}`,
+            `   model policy: ${role ? `${role.model_policy} (${role.model}/${role.model_reasoning_effort})` : 'resolve from installed custom agent'}`,
             `   mode: ${mode}`,
             `   paths: ${paths.join(', ') || 'assigned by parent'}`
         ].join('\n');
@@ -40,10 +55,14 @@ Parent agent:
 Subagent rules:
 - 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
-- use \`worker\` with gpt-5.6-luna and max reasoning only for clear, bounded, repeatable work
-- use \`expert\` with gpt-5.6-sol and max reasoning only as the read-only judgment fallback
-- automatic fan-out is selected before execution: one by default, two only for explicit parallel work or independent risk domains,
-  and at most ${MAX_AUTOMATIC_SUBAGENT_COUNT} for critical multi-domain risk; never spawn beyond the requested count
+- use \`worker\` with gpt-5.6-luna and max reasoning only for tiny, short-context, mechanical work with no exploration or judgment
+- use gpt-5.6-sol with high reasoning for ordinary UI, logic, backend, and native implementation
+- use gpt-5.6-sol with max reasoning for review, debugging, planning, architecture, security, database, research, release, ambiguity, and every judgment-bearing slice
+- use gpt-5.6-terra with medium reasoning for long-context analysis and direct Computer Use, Browser/Chrome, or image-generation execution
+- split mixed work when possible: Terra gathers or operates, Sol High implements, and Sol Max judges; when one slice cannot be split safely, judgment takes priority
+- never assign Luna to long-context, exploration, review, debugging, planning, or tool-heavy work
+- automatic fan-out is selected before execution: two independent children for non-trivial work,
+  and at most ${MAX_AUTOMATIC_SUBAGENT_COUNT} only for critical multi-domain risk; trivial Answer/DFix work is filtered before this route
 - automatic reviewer-only fan-out is capped at ${MAX_AUTOMATIC_REVIEWER_COUNT} for ordinary work; critical multi-domain review may use the overall cap of ${MAX_AUTOMATIC_SUBAGENT_COUNT}
 - requested subagents: ${requestedPolicy}
 - max open agent threads: ${maxThreads}
@@ -57,9 +76,11 @@ Subagent rules:
 ${parentDecompositionRequired ? `- decomposition status: parent_required
 - before spawning, decompose the goal into independent, non-overlapping slices
 - do not invent write scopes merely to reach the requested count
-${input.requestedSubagentsExplicit === true
+${requestedSource === 'operator'
         ? '- the explicit operator count is authoritative; if it cannot be defended safely, block and report instead of silently changing it'
-        : '- if fewer defensible slices exist, reduce the delegation plan and requested count before execution; never increase automatically beyond the selected count'}` : '- decomposition status: ready'}
+        : requestedSource === 'route_contract'
+            ? '- the route-owned exact count is authoritative; preserve it and follow the route-specific orchestration contract'
+            : '- if fewer defensible slices exist, reduce the delegation plan and requested count before execution; never increase automatically beyond the selected count'}` : '- decomposition status: ready'}
 
 Central TriWiki context:
 ${triwiki}
@@ -111,16 +132,17 @@ function renderBoundedTriwikiAttention(value) {
         `- bounded anchors: ${JSON.stringify(anchors)}`
     ].join('\n');
 }
-function renderAgentCatalog(recommended) {
-    const preferred = new Set((recommended || []).map(String));
-    const included = new Set(['worker', 'implementation_specialist', 'expert', ...preferred]);
-    return officialSubagentRoleCatalog()
-        .filter((role) => included.has(role.name))
-        .map((role) => {
-        const marker = preferred.has(role.name) ? ' [suggested for this goal]' : '';
-        return `- \`${role.name}\`${marker}: ${role.model}/${role.model_reasoning_effort}, ${role.sandbox_mode}; ${role.description}`;
-    })
-        .join('\n');
+function renderAgentCatalog(requested) {
+    const names = [...new Set(requested.map(String).map((name) => name.trim()).filter(Boolean))];
+    const selected = officialSubagentOnDemandRoleCatalog(names.length ? names : ['expert']);
+    const preferred = new Set(names);
+    return [
+        `- metadata mode: on-demand (${selected.length}/${officialSubagentRoleCatalog().length} roles included; full catalog is not injected)`,
+        ...selected.map((role) => {
+            const marker = preferred.has(role.name) ? ' [suggested for this goal]' : '';
+            return `- \`${role.name}\`${marker}: ${role.model_policy}, ${role.model}/${role.model_reasoning_effort}, ${role.sandbox_mode}; ${role.description}`;
+        })
+    ].join('\n');
 }
 function clampThreads(value) {
     const parsed = Number(value);

package/dist/core/subagents/thread-budget.js

@@ -1,6 +1,6 @@
 export const DEFAULT_NARUTO_MAX_THREADS = 12;
 export const HARD_NARUTO_MAX_THREADS = 32;
-export const DEFAULT_NARUTO_REQUESTED_SUBAGENTS = 1;
+export const DEFAULT_NARUTO_REQUESTED_SUBAGENTS = 2;
 export function resolveSubagentThreadBudget(input = {}) {
     const requested = clamp(input.requested ?? input.independentSliceCount ?? DEFAULT_NARUTO_REQUESTED_SUBAGENTS, 1, HARD_NARUTO_MAX_THREADS);
     const configured = clamp(input.configuredMaxThreads ?? DEFAULT_NARUTO_MAX_THREADS, 1, HARD_NARUTO_MAX_THREADS);