sneakoscope 6.1.2 → 6.2.0

package/dist/core/research/research-super-search.js

@@ -2,8 +2,12 @@ import path from 'node:path';
 import { readJson, sha256 } from '../fsx.js';
 import { runCodexTask } from '../codex-control/codex-task-runner.js';
 import { runSuperSearch } from '../super-search/index.js';
-import { DEFAULT_SUBAGENT_MODEL, SUBAGENT_EFFORT } from '../subagents/model-policy.js';
+import { TERRA_SUBAGENT_EFFORT, TERRA_SUBAGENT_MODEL } from '../subagents/model-policy.js';
 import {} from './research-source-shards.js';
+export const RESEARCH_SOURCE_ACQUISITION_MODEL_POLICY = Object.freeze({
+    model: TERRA_SUBAGENT_MODEL,
+    model_reasoning_effort: TERRA_SUBAGENT_EFFORT
+});
 export async function runResearchSuperSearchShard(input) {
     const missionId = String(input.plan?.mission_id || '');
     const acquisitionDir = path.join(input.dir, 'research', `cycle-${input.cycle}`, 'source-acquisition', input.layer.id);
@@ -99,9 +103,9 @@ function createCodexSourceSearch(input) {
                 hardTimeoutMs: input.timeoutMs,
                 ...(input.deadlineMs === undefined ? {} : { deadlineEpochMs: input.deadlineMs })
             },
-            model: DEFAULT_SUBAGENT_MODEL,
-            reasoningEffort: SUBAGENT_EFFORT,
-            modelReasoningEffort: SUBAGENT_EFFORT,
+            model: RESEARCH_SOURCE_ACQUISITION_MODEL_POLICY.model,
+            reasoningEffort: RESEARCH_SOURCE_ACQUISITION_MODEL_POLICY.model_reasoning_effort,
+            modelReasoningEffort: RESEARCH_SOURCE_ACQUISITION_MODEL_POLICY.model_reasoning_effort,
             serviceTier: 'fast'
         });
         const worker = await readJson(result.workerResultPath, null);

package/dist/core/research.js

@@ -17,6 +17,7 @@ import { RESEARCH_WORK_GRAPH_ARTIFACT, writeResearchWorkGraph } from './research
 import { buildResearchReviewArtifactDigest, validateResearchReviewArtifactDigest } from './research/research-review-artifact-digest.js';
 import { RESEARCH_SOURCE_LAYER_IDS, RESEARCH_SOURCE_LAYERS } from './research/research-source-layer-catalog.js';
 import { eligibleResearchSourceIdSet } from './research/research-source-evidence.js';
+import { renderResearchPlanMarkdown, renderResearchSourceSkillMarkdown } from './research/research-plan-markdown.js';
 import { resolveCodexAppExecutionProfile } from './codex-app/codex-app-execution-profile.js';
 import { resolveCodexNativeInvocationPlan } from './codex-native/codex-native-invocation-router.js';
 import { SUBAGENT_EVIDENCE_FILENAME, SUBAGENT_PARENT_SUMMARY_FILENAME, buildSubagentEvidence, normalizeSubagentParentSummary, readSubagentEvents } from './subagents/subagent-evidence.js';
@@ -208,7 +209,7 @@ export function createResearchPlan(prompt, opts = {}) {
                 required_model: 'gpt-5.6-sol',
                 required_effort: 'max',
                 applies_to: 'every_official_adversarial_reviewer',
-                rule: 'Every adversarial reviewer uses the verified research_reviewer custom agent configuration with GPT-5.6 Sol Max. Bounded source extraction may use Luna Max; synthesis, falsification, and review use Sol Max.'
+                rule: 'Every adversarial reviewer uses the verified research_reviewer custom agent configuration with GPT-5.6 Sol Max. Long-context and source-tool acquisition uses Terra Medium; synthesis, falsification, and review use Sol Max.'
             },
             eureka_policy: {
                 exclamation: 'Eureka!',
@@ -329,126 +330,10 @@ export function createResearchPlan(prompt, opts = {}) {
     };
 }
 export function researchPlanMarkdown(plan) {
-    const lines = [];
-    lines.push('# SKS Research Plan');
-    lines.push('');
-    lines.push(`Prompt: ${plan.prompt}`);
-    lines.push(`Depth: ${plan.depth}`);
-    lines.push(`Methodology: ${plan.methodology}`);
-    lines.push(`Research paper: ${researchPaperArtifactForPlan(plan)}`);
-    if (plan.codex_app_execution_profile) {
-        lines.push(`Execution profile: ${plan.codex_app_execution_profile.mode}; agent role strategy ${plan.codex_app_execution_profile.agent_role_strategy}`);
-    }
-    if (plan.execution_policy) {
-        lines.push(`Execution: ${plan.execution_policy.normal_run}; default cycle timeout ${plan.execution_policy.default_cycle_timeout_minutes} minutes`);
-        if (plan.execution_policy.default_max_cycles)
-            lines.push(`Adversarial review loop: run three independent official research_reviewer threads, revise on any objection, then run a fresh three-thread cycle; default safety cap ${plan.execution_policy.default_max_cycles} cycles`);
-        lines.push(`Mock policy: ${plan.execution_policy.mock_policy}`);
-    }
-    if (plan.mutation_policy)
-        lines.push(`Mutation policy: ${plan.mutation_policy.rule}`);
-    lines.push('');
-    if (plan.quality_contract) {
-        const contract = plan.quality_contract;
-        lines.push('## Quality Contract');
-        lines.push(`- minimum sources: ${contract.min_sources_total}`);
-        lines.push(`- minimum source layers covered: ${contract.min_source_layers_covered}`);
-        lines.push(`- minimum counterevidence sources: ${contract.min_counterevidence_sources}`);
-        lines.push(`- minimum key claims: ${contract.min_key_claims}`);
-        lines.push(`- minimum triangulated claims: ${contract.min_trianguled_claims}`);
-        lines.push(`- minimum blueprint sections: ${contract.min_implementation_blueprint_sections}`);
-        lines.push(`- minimum falsification cases: ${contract.min_falsification_cases}`);
-        lines.push(`- minimum experiment steps: ${contract.min_experiment_steps}`);
-        lines.push(`- minimum report words: ${contract.min_report_words}`);
-        lines.push('');
-    }
-    if (plan.native_agent_plan) {
-        lines.push('## Official Subagent Review Plan');
-        lines.push(`Backend: ${plan.native_agent_plan.backend}`);
-        lines.push(`Sessions: ${plan.native_agent_plan.session_count}`);
-        lines.push(`AutoResearch batches: ${plan.native_agent_plan.autoresearch_cycle_policy?.uses_agent_batches ? 'enabled' : 'disabled'}`);
-        for (const persona of plan.native_agent_plan.personas || []) {
-            lines.push(`- ${persona.id}: ${persona.role}; outputs ${(persona.outputs || []).join(', ')}`);
-        }
-        for (const batch of plan.native_agent_plan.batches || []) {
-            lines.push(`- batch ${batch.id}: ${(batch.agents || []).join(', ')} -> ${(batch.outputs || []).join(', ')}`);
-        }
-        lines.push('');
-    }
-    lines.push('## Rules');
-    for (const rule of plan.rules)
-        lines.push(`- ${rule}`);
-    lines.push('');
-    if (plan.research_council?.agents?.length) {
-        lines.push('## Genius Agent Council');
-        lines.push(`Policy: ${plan.research_council.policy}`);
-        for (const agent of plan.research_council.agents)
-            lines.push(`- ${researchAgentAgentName(agent)}: ${agent.persona || agent.role} - ${agent.mandate} (${agent.persona_boundary || 'persona-inspired lens only'})`);
-        lines.push('');
-    }
-    if (plan.web_research_policy) {
-        lines.push('## Web Research Policy');
-        lines.push(`Mode: ${plan.web_research_policy.mode}`);
-        lines.push(`Requirement: ${plan.web_research_policy.requirement}`);
-        if (plan.web_research_policy.source_tool_routing)
-            lines.push(`Source tool routing: ${plan.web_research_policy.source_tool_routing.mode}`);
-        for (const querySet of plan.web_research_policy.query_sets || [])
-            lines.push(`- query set: ${querySet}`);
-        if (plan.web_research_policy.skill_creator?.artifact)
-            lines.push(`- source skill artifact: ${plan.web_research_policy.skill_creator.artifact}`);
-        for (const layer of plan.web_research_policy.source_layers || []) {
-            lines.push(`- layer ${layer.id}: ${layer.purpose}`);
-        }
-        lines.push('');
-    }
-    lines.push('## Outcome Rubric');
-    for (const item of plan.outcome_rubric || [])
-        lines.push(`- ${item.id}: ${item.description}`);
-    lines.push('');
-    lines.push('## Phases');
-    for (const phase of plan.phases)
-        lines.push(`- ${phase.id}: ${phase.goal}`);
-    lines.push('');
-    lines.push('## Required Artifacts');
-    for (const artifact of plan.required_artifacts)
-        lines.push(`- ${artifact}`);
-    lines.push('');
-    return `${lines.join('\n')}\n`;
+    return renderResearchPlanMarkdown(plan, { researchPaperArtifactForPlan, researchAgentAgentName });
 }
 export function researchSourceSkillMarkdown(plan) {
-    const layers = plan?.web_research_policy?.source_layers?.length ? plan.web_research_policy.source_layers : RESEARCH_SOURCE_LAYERS;
-    const lines = [];
-    lines.push('# Research Source Layer Skill');
-    lines.push('');
-    lines.push('Status: route-local candidate skill. Use it inside this research mission before agent synthesis. Do not install or edit generated .agents/skills from this artifact.');
-    lines.push('Real-run policy: collect live sources for as long as needed within the mission timeout; mock or fixture evidence is valid only for explicit --mock selftests.');
-    lines.push('');
-    lines.push('## Trigger');
-    lines.push('- Any `$Research` run that must collect broad public evidence before synthesis, adversarial review, falsification, or paper writing.');
-    lines.push('');
-    lines.push('## Source Layers');
-    for (const layer of layers) {
-        lines.push(`- ${layer.id}: ${layer.purpose}`);
-        lines.push(`  Examples: ${(layer.examples || []).join(', ')}`);
-        lines.push(`  Query templates: ${(layer.query_templates || []).join(' | ')}`);
-    }
-    lines.push('');
-    lines.push('## Output Contract');
-    lines.push('- Fill source-ledger.json with `source_layers`, `sources[].layer`, `counterevidence_sources[].layer`, `citation_coverage`, `triangulation.cross_layer_checks`, and `blockers`.');
-    lines.push('- Each source entry should record title, locator/URL, publisher or author when known, published_at when known, accessed_at, layer, reliability, credibility, stance, supports or undermines, and notes.');
-    lines.push('- Public discourse sources such as X/Twitter or Reddit are signals and edge cases, not truth. They must be triangulated with formal, official, practitioner, or counterevidence layers.');
-    lines.push('- If a layer cannot be searched with the available runtime or credentials, record the blocker and keep research-gate.json unpassed.');
-    lines.push('- Do not modify repository source code or generated harness files during Research; write only route-local mission artifacts.');
-    lines.push('');
-    lines.push('## Official Reviewer Use');
-    lines.push('- Only source-ledger ids with correlated verified-content Super Search proof may support a real-run reviewer finding or Eureka idea.');
-    lines.push('- Run exactly three independent official `research_reviewer` threads on GPT-5.6 Sol Max: Einstein, von Neumann, and Skeptic composite lenses.');
-    lines.push('- The skeptic lens must challenge the strongest claim using counterevidence or source-quality downgrades.');
-    lines.push('- Any objection triggers a mission-local `research_synthesizer` revision followed by a fresh three-thread review cycle; do not launch a custom scheduler or debate pool.');
-    lines.push('- `agent-ledger.json` and `debate-ledger.json` are compatibility projections from official reviewer outcomes. Canonical convergence requires three trustworthy parent outcomes and zero unresolved objections.');
-    lines.push('- Synthesis keeps only claims that survive cross-layer triangulation and falsification.');
-    lines.push('');
-    return `${lines.join('\n')}\n`;
+    return renderResearchSourceSkillMarkdown(plan, RESEARCH_SOURCE_LAYERS);
 }
 export function countResearchPaperSections(text = '') {
     const headings = String(text || '').toLowerCase().split(/\n/).filter((line) => /^#{1,3}\s+/.test(line));

package/dist/core/retention.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-import { exists, readJson, writeJsonAtomic, ensureDir, dirSize, fileSize, formatBytes, rmrf, nowIso, appendJsonlBounded, listFilesRecursive, managedSksTmpRoot, sha256 } from './fsx.js';
+import { exists, readJson, writeJsonAtomic, ensureDir, dirSize, fileSize, formatBytes, rmrf, nowIso, appendJsonlBounded, listFilesRecursive, managedSksTmpRoot, sha256, SKS_TEMP_LEASE_FILE } from './fsx.js';
 import { FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS } from './routes.js';
 export const DEFAULT_RETENTION_POLICY = Object.freeze({
     schema_version: 1,
@@ -487,6 +487,44 @@ function currentProcessOwns(stat) {
 function sharedTempEntryMatchesProject(entryName, projectHash) {
     return entryName === `sks-${projectHash}` || entryName.startsWith(`sks-${projectHash}-`);
 }
+function activeTempEnvironmentKey(target) {
+    const resolvedTarget = path.resolve(target);
+    for (const key of ['SKS_TMP_DIR', 'TMPDIR', 'TMP', 'TEMP']) {
+        const raw = process.env[key];
+        if (!raw)
+            continue;
+        const activePath = path.resolve(raw);
+        if (isWithin(resolvedTarget, activePath))
+            return key;
+    }
+    return null;
+}
+async function liveTempLease(target) {
+    const leasePath = path.join(target, SKS_TEMP_LEASE_FILE);
+    const stat = await fs.lstat(leasePath).catch(() => null);
+    if (!stat?.isFile() || stat.isSymbolicLink() || !currentProcessOwns(stat))
+        return null;
+    const lease = await readJson(leasePath, null).catch(() => null);
+    const pid = Number(lease?.pid);
+    if (lease?.schema !== 'sks.temp-lease.v1' || !processIdAlive(pid))
+        return null;
+    return {
+        path: leasePath,
+        pid,
+        kind: lease?.kind ? String(lease.kind) : null
+    };
+}
+function processIdAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
 async function pruneTmp(root, policy, dryRun, actions) {
     const tmp = path.join(root, '.sneakoscope', 'tmp');
     if (!(await exists(tmp)))
@@ -1138,6 +1176,28 @@ export async function sweepSksTempDirs(root, opts = {}) {
             const stat = await fs.lstat(target).catch(() => null);
             if (!stat || stat.isSymbolicLink() || !currentProcessOwns(stat))
                 continue;
+            const environmentKey = activeTempEnvironmentKey(target);
+            if (environmentKey) {
+                actions.push({
+                    action: 'retain_active_sks_temp',
+                    path: target,
+                    reason: 'active_temp_environment',
+                    environment_key: environmentKey
+                });
+                continue;
+            }
+            const lease = stat.isDirectory() ? await liveTempLease(target) : null;
+            if (lease) {
+                actions.push({
+                    action: 'retain_active_sks_temp',
+                    path: target,
+                    reason: 'active_temp_lease',
+                    lease_path: lease.path,
+                    owner_pid: lease.pid,
+                    lease_kind: lease.kind
+                });
+                continue;
+            }
             const inspected = await inspectTempPath(target);
             if (!inspected.complete) {
                 actions.push({ action: 'skip_unsafe_temp_entry', path: target, reason: inspected.blockers.join(',') });
@@ -1561,7 +1621,15 @@ export async function enforceRetention(root, opts = {}) {
         await rotateLargeJsonl(root, policy, dryRun, actions);
     await pruneDisposableReportLogs(root, policy, dryRun, actions, opts);
     await pruneSessionStateFiles(root, policy, dryRun, actions);
-    await sweepSksTempDirs(root, { dryRun, actions, maxAgeHours: opts.sksTempMaxAgeHours ?? policy.max_tmp_age_hours ?? 0 });
+    if (opts.skipSksTempSweep === true) {
+        actions.push({
+            action: 'skip_sks_temp_sweep',
+            reason: opts.afterRoute ? 'post_route_global_temp_isolation' : 'explicit_temp_sweep_skip'
+        });
+    }
+    else {
+        await sweepSksTempDirs(root, { dryRun, actions, maxAgeHours: opts.sksTempMaxAgeHours ?? policy.max_tmp_age_hours ?? 0 });
+    }
     if (opts.pruneWikiArtifacts || policy.prune_wiki_artifacts)
         await pruneWikiArtifacts(root, { policy, dryRun, actions, lowTrust: opts.pruneWikiLowTrust });
     let report = boundedMode || opts.skipStorageReport === true ? await lightweightStorageReport(root) : await storageReport(root);

package/dist/core/routes/dollar-manifest-lite.js

@@ -1,4 +1,4 @@
-const NARUTO_DESCRIPTION = '$Naruto is the lightweight Codex official subagent workflow. The Sol Max parent uses one child by default, two for explicit parallel work or independent risk domains, and at most three for critical multi-domain risk; explicit --agents remains authoritative. It delegates only defensible independent slices, reuses bounded TriWiki attention anchors, and requires official lifecycle events plus a trustworthy structured parent summary.';
+const NARUTO_DESCRIPTION = '$Naruto is the lightweight Codex official subagent workflow. The Sol Max parent uses two independent children for non-trivial work and at most three for critical multi-domain risk; explicit --agents remains authoritative. Child routing is fixed to Luna Max mechanical, Sol High implementation, Sol Max judgment, and Terra Medium long-context/Computer Use/Browser/ImageGen execution. It delegates only defensible independent slices, reuses bounded query-aware TriWiki attention anchors, and requires official lifecycle events plus a trustworthy structured parent summary.';
 const COMPUTER_USE_DESCRIPTION = 'Maximum-speed Codex Computer Use lane for native macOS, desktop-app, OS-settings, and non-web visual tasks only. Browser, localhost, website, webapp, and web-based app verification must route through Codex Chrome Extension readiness first.';
 export const DOLLAR_COMMANDS_LITE = [
     { command: '$DFix', route: 'fast direct fix', description: 'Tiny simple direct edits such as copy, labels, typos, wording, spacing, colors, or clearly scoped one-line changes. Bypasses the general SKS pipeline and runs an ultralight, no-record task-list path.' },

package/dist/core/routes.js

@@ -273,7 +273,7 @@ export const ROUTES = [
         command: '$Naruto',
         mode: 'NARUTO',
         route: 'Codex official subagent workflow',
-        description: '$Naruto prepares a lightweight Codex official subagent workflow. The Sol Max parent owns decomposition, delegates only defensible direct-child slices, reuses bounded TriWiki attention anchors, waits for every requested thread, integrates the results, and reports scoped verification. Automatic fan-out is one by default, two for explicit parallel work or independent risk domains, and at most three for critical multi-domain risk; explicit --agents remains authoritative.',
+        description: '$Naruto prepares a lightweight Codex official subagent workflow. The Sol Max parent owns decomposition, delegates only defensible direct-child slices, reuses bounded query-aware TriWiki attention anchors, waits for every requested thread, integrates the results, and reports scoped verification. Automatic fan-out is two for non-trivial work and at most three for critical multi-domain risk; explicit --agents remains authoritative.',
         requiredSkills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
         dollarAliases: ['$ShadowClone', '$Kagebunshin', '$Work', '$Swarm'],
         appSkillAliases: ['shadow-clone', 'kage-bunshin', 'work', 'swarm'],
@@ -671,7 +671,7 @@ export const COMMAND_CATALOG = [
     { 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: 'agent', usage: 'sks agent run|status|close|cleanup <mission-id|latest> [--agents N] [--work-items N] [--target-active-slots N] [--mock] [--apply|--dry-run] [--drain] [--stale-ms N] [--json] | sks agent rollback-patches [mission-id|latest] [--patch-entry-id id] [--dry-run|--apply] [--json]', description: 'Run, inspect, close, clean, or roll back Codex subagent missions with an explicit requested-agent/thread budget, disjoint work ownership, official event evidence, and parent-owned integration.' },
-    { name: 'naruto', usage: 'sks naruto run \"task\" [--agents N] [--max-threads N] [--json] | sks naruto status|subagents|proof [latest|M-...] [--json]', description: 'Run or inspect the Codex official subagent workflow with a Sol Max parent, Luna Max bounded workers, Sol Max experts, max_depth=1, and structured parent-thread completion evidence.' },
+    { name: 'naruto', usage: 'sks naruto run \"task\" [--agents N] [--max-threads N] [--json] | sks naruto status|subagents|proof [latest|M-...] [--json]', description: 'Run or inspect the Codex official subagent workflow with a Sol Max parent and fixed Luna Max mechanical, Sol High implementation, Sol Max judgment, and Terra Medium long-context/tool profiles, max_depth=1, and structured parent-thread completion evidence.' },
     { name: 'team', usage: 'sks team \"task\" | sks team log|tail|watch|lane|status ...', description: 'Deprecated compatibility command: new tasks redirect to Naruto; only read-only observation subcommands remain for old Team missions.' },
     { 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.' },
@@ -1084,27 +1084,80 @@ export function routeNeedsContext7(route, prompt = '') {
         return false;
     return /\b(package|library|framework|SDK|API|MCP|Supabase|React|Next|Vue|Svelte|Vite|Prisma|Drizzle|Knex|Postgres|npm|node_modules|docs?|documentation)\b/i.test(String(prompt || ''));
 }
+const NARUTO_GATE_BYPASS_ROUTE_IDS = new Set([
+    'Answer',
+    'DFix',
+    'Help',
+    'Wiki',
+    'ComputerUse',
+    'Goal',
+    'Commit',
+    'CommitAndPush',
+    'FastMode',
+    'LocalModel',
+    'Planner'
+]);
+const NARUTO_GATE_ROUTE_OWNED_IDS = new Set([
+    'Research',
+    'AutoResearch',
+    'QALoop'
+]);
+const NARUTO_GATE_SPECIALIZED_PARALLEL_ROUTE_IDS = new Set([
+    'Review',
+    'ReleaseReview',
+    'PPT',
+    'ImageUXReview',
+    'SuperSearch',
+    'SEOGEOOptimizer',
+    'DB',
+    'MadDB',
+    'MadSKS',
+    'GX'
+]);
+export function narutoDecisionForRoute(route, prompt = '', profile = classifyTaskProfile(prompt)) {
+    const routeId = route?.id ? String(route.id) : null;
+    if (!routeId) {
+        return narutoRouteDecision('none', null, profile, 'no_route_or_task_context', true);
+    }
+    if (NARUTO_GATE_ROUTE_OWNED_IDS.has(routeId)) {
+        // These routes already own their orchestration lifecycle. The common
+        // Naruto gate records that fact but must not add a second generic fanout.
+        return narutoRouteDecision('route_owned', routeId, profile, `route_owned_orchestration:${routeId}`, false);
+    }
+    if (NARUTO_GATE_BYPASS_ROUTE_IDS.has(routeId)) {
+        return narutoRouteDecision('none', routeId, profile, `lightweight_route_bypass:${routeId}`, true);
+    }
+    if ((routeId === 'Team' || routeId === 'Naruto') && route.explicit_invocation !== false) {
+        return narutoRouteDecision('generic_naruto', routeId, profile, 'explicit_official_subagent_route', false);
+    }
+    if (/(?:^|\s)--(?:agents|clones)(?:=|\s+)\d+\b/i.test(String(prompt || ''))) {
+        return narutoRouteDecision('generic_naruto', routeId, profile, 'explicit_subagent_count', false);
+    }
+    if (NARUTO_GATE_SPECIALIZED_PARALLEL_ROUTE_IDS.has(routeId)) {
+        return narutoRouteDecision('generic_naruto', routeId, profile, `specialized_route_default_parallel:${routeId}`, false);
+    }
+    if (profile === 'passthrough' || profile === 'answer' || profile === 'tiny-change') {
+        return narutoRouteDecision('none', routeId, profile, `task_profile_${profile}_bypass`, true);
+    }
+    if (profile === 'bounded-work' || profile === 'parallel-read' || profile === 'parallel-write' || profile === 'high-risk') {
+        return narutoRouteDecision('generic_naruto', routeId, profile, `task_profile_${profile}_default_parallel`, false);
+    }
+    return narutoRouteDecision('none', routeId, profile, `task_profile_${profile}_bypass`, true);
+}
 export function routeRequiresSubagents(route, prompt = '', profile = classifyTaskProfile(prompt)) {
-    if (!route)
-        return false;
-    if (['Answer', 'DFix', 'Help', 'Wiki', 'ComputerUse'].includes(String(route.id || '')))
-        return false;
-    // QA-Loop retains one route-owned native execution engine. Do not also
-    // materialize an official-subagent overlay for the same mission.
-    if (route.id === 'QALoop')
-        return false;
-    if ((route.id === 'Team' || route.id === 'Naruto') && route.explicit_invocation !== false)
-        return true;
-    if (/(?:^|\s)--(?:agents|clones)(?:=|\s+)\d+\b/i.test(String(prompt || '')))
-        return true;
-    if (profile === 'passthrough' || profile === 'answer' || profile === 'tiny-change' || profile === 'bounded-work')
-        return false;
-    if (profile === 'parallel-read' || profile === 'parallel-write')
-        return true;
-    return profile === 'high-risk' && explicitlyParallelizable(prompt);
+    return narutoDecisionForRoute(route, prompt, profile).mode === 'generic_naruto';
 }
-function explicitlyParallelizable(prompt = '') {
-    return /(?:^|\s)--(?:agents|clones)(?:=|\s+)\d+\b|\b(parallel|subagents?|one agent per|fan out|independent slices?|multiple files|audit all)\b|병렬|하위\s*에이전트|서브\s*에이전트|독립\s*(?:작업|범위)|분담|여러\s*파일|전체\s*검토/i.test(String(prompt || ''));
+function narutoRouteDecision(mode, routeId, profile, reason, trivial) {
+    const required = mode === 'generic_naruto';
+    return {
+        mode,
+        required,
+        route_id: routeId,
+        task_profile: profile,
+        reason,
+        trivial,
+        default_parallel: required
+    };
 }
 export function simpleGitOnlyRouteId(prompt = '') {
     const text = stripVisibleDecisionAnswerBlocks(String(prompt || '')).trim();
@@ -1158,7 +1211,7 @@ export function subagentExecutionPolicyText(route, prompt = '') {
     return [
         'Codex subagent workflow: required for this explicit Naruto or parallel task.',
         'The parent agent owns decomposition, integration, scoped verification, and the final answer.',
-        'Delegate only genuinely independent slices. Use worker for clear bounded work and expert for review, debugging, planning, architecture, integration, or risk-sensitive judgment.',
+        'Delegate only genuinely independent slices. Use Luna Max only for tiny short-context mechanical work, Sol High for ordinary implementation, Sol Max for review/debug/planning/architecture/integration/risk judgment, and Terra Medium for long-context or Computer Use, Browser/Chrome, and image-generation execution.',
         '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.',
         noUnrequestedFallbackCodePolicyText()

package/dist/core/subagents/agent-catalog.js

@@ -1,15 +1,37 @@
-import { MANAGED_OFFICIAL_SUBAGENT_ROLES } from '../managed-assets/managed-assets-manifest.js';
-export const DEFAULT_AUTOMATIC_SUBAGENT_COUNT = 1;
+import { MANAGED_OFFICIAL_SUBAGENT_ROLES, managedOfficialSubagentRoleByName } from '../managed-assets/managed-assets-manifest.js';
+export const DEFAULT_AUTOMATIC_SUBAGENT_COUNT = 2;
 export const MAX_AUTOMATIC_SUBAGENT_COUNT = 3;
 export const MAX_AUTOMATIC_REVIEWER_COUNT = 2;
+export const MAX_ON_DEMAND_SUBAGENT_ROLE_COUNT = MAX_AUTOMATIC_SUBAGENT_COUNT;
 export function officialSubagentRoleCatalog() {
-    return MANAGED_OFFICIAL_SUBAGENT_ROLES.map((role) => ({
+    return MANAGED_OFFICIAL_SUBAGENT_ROLES.map(roleSummary);
+}
+export function officialSubagentOnDemandRoleCatalog(roleNames) {
+    const selected = [];
+    const seen = new Set();
+    for (const name of roleNames) {
+        const role = managedOfficialSubagentRoleByName(String(name || ''));
+        if (!role || seen.has(role.codex_name))
+            continue;
+        seen.add(role.codex_name);
+        selected.push(role);
+        if (selected.length >= MAX_ON_DEMAND_SUBAGENT_ROLE_COUNT)
+            break;
+    }
+    return selected.map(roleSummary);
+}
+export function officialSubagentOnDemandRolePlan(roleNames) {
+    return Object.fromEntries(officialSubagentOnDemandRoleCatalog(roleNames).map(({ name, ...config }) => [name, config]));
+}
+function roleSummary(role) {
+    return {
         name: role.codex_name,
         description: role.description,
+        model_policy: role.model_policy,
         model: role.model,
         model_reasoning_effort: role.model_reasoning_effort,
         sandbox_mode: role.sandbox || 'inherit'
-    }));
+    };
 }
 export function officialSubagentRolePlan() {
     return Object.fromEntries(officialSubagentRoleCatalog().map(({ name, ...config }) => [name, config]));
@@ -26,11 +48,10 @@ export function recommendOfficialSubagentRoles(input = {}) {
     const scored = MANAGED_OFFICIAL_SUBAGENT_ROLES
         .map((role, index) => ({ role, index, score: roleScore(role, text, input) }))
         .filter((row) => input.readOnly !== true || row.role.sandbox === 'read-only');
-    const solSpecialistMatched = scored.some((row) => row.score > 0
-        && row.role.model === 'gpt-5.6-sol'
+    const narrowSpecialistMatched = scored.some((row) => row.score > 0
         && !['worker', 'expert'].includes(row.role.codex_name));
     const ranked = scored
-        .filter((row) => !(solSpecialistMatched && row.role.codex_name === 'worker'))
+        .filter((row) => !(narrowSpecialistMatched && row.role.codex_name === 'worker'))
         .filter((row) => row.score > 0)
         .sort((left, right) => right.score - left.score || left.index - right.index)
         .map((row) => row.role.codex_name);
@@ -46,7 +67,12 @@ export function selectOfficialSubagentRole(input = {}) {
     return recommendOfficialSubagentRoles({ ...input, limit: 1 })[0] || 'expert';
 }
 export function officialSubagentFanoutPolicy(input = {}) {
-    const explicit = input.requestedExplicit === true;
+    const countSource = input.requestedSource === 'route_contract'
+        ? 'route_contract'
+        : input.requestedExplicit === true || input.requestedSource === 'operator'
+            ? 'operator'
+            : 'automatic';
+    const explicit = countSource !== 'automatic';
     const explicitRequested = Number.isFinite(Number(input.requestedSubagents))
         ? Math.max(1, Math.floor(Number(input.requestedSubagents)))
         : DEFAULT_AUTOMATIC_SUBAGENT_COUNT;
@@ -60,13 +86,22 @@ export function officialSubagentFanoutPolicy(input = {}) {
         ? MAX_AUTOMATIC_SUBAGENT_COUNT
         : MAX_AUTOMATIC_REVIEWER_COUNT;
     return {
-        mode: explicit ? 'explicit_operator_count' : 'parent_owned_risk_based',
+        mode: countSource === 'operator'
+            ? 'explicit_operator_count'
+            : countSource === 'route_contract'
+                ? 'route_owned_contract_count'
+                : 'parent_owned_risk_based',
+        count_source: countSource,
         requested_subagents: requested,
         default_subagents: DEFAULT_AUTOMATIC_SUBAGENT_COUNT,
         automatic_selected: explicit ? null : automatic.count,
         automatic_ceiling: automatic.ceiling,
         automatic_reviewer_ceiling: automaticReviewerCeiling,
-        selection_reason: explicit ? 'explicit_operator_count_preserved' : automatic.reason,
+        selection_reason: countSource === 'operator'
+            ? 'explicit_operator_count_preserved'
+            : countSource === 'route_contract'
+                ? 'route_owned_contract_count_preserved'
+                : automatic.reason,
         risk_domains: automatic.riskDomains,
         critical_multi_domain: automatic.criticalMultiDomain,
         requires_independent_non_overlapping_slices: true,
@@ -113,7 +148,7 @@ function automaticSubagentFanout(input) {
     return {
         count: DEFAULT_AUTOMATIC_SUBAGENT_COUNT,
         ceiling: DEFAULT_AUTOMATIC_SUBAGENT_COUNT,
-        reason: 'single_bounded_or_single_domain_task',
+        reason: 'non_trivial_default_parallel',
         riskDomains,
         criticalMultiDomain: false
     };
@@ -137,6 +172,10 @@ function roleScore(role, text, input) {
     if (semanticScore <= 0)
         return 0;
     let score = semanticScore;
+    if (ROLE_PRIORITY_PATTERNS[role.codex_name]?.test(text))
+        score += 8;
+    if (JUDGMENT_PRIORITY_RE.test(text) && role.model_policy === 'sol_max_judgment')
+        score += 10;
     if (input.readOnly === true)
         score += role.sandbox === 'read-only' ? 2 : role.sandbox ? -3 : 0;
     if (input.requiresWrite === true)
@@ -159,7 +198,9 @@ function keywordScore(text, keyword) {
     return normalized.includes(' ') ? 4 : 3;
 }
 function looksClearBounded(text) {
-    return /\b(bounded|mechanical|repeatable|exact|single[- ](?:file|step|change)|rename|format|copy|fixture)\b|정해진|명확한|기계적|반복적|단일\s*파일/i.test(text);
+    const tinyMechanical = /\b(tiny|trivial|mechanical|repeatable|one[- ]line|single[- ]file|exact (?:rename|copy|replace|format)|typo|format only)\b|한\s*줄|단일\s*파일|극단적으로\s*단순|기계적|반복적|오타|이름\s*변경/i.test(text);
+    const longOrRisky = /\b(long[- ]context|large[- ](?:file|document|codebase|repository)|repository[- ]wide|browser|chrome|computer[- ]use|imagegen|review|debug|security|architecture|research)\b|긴\s*컨텍스트|장문|대규모|브라우저|컴퓨터\s*유즈|이미지\s*생성|리뷰|디버깅|보안|아키텍처|연구/i.test(text);
+    return tinyMechanical && !longOrRisky;
 }
 function normalizeText(values) {
     return values
@@ -186,6 +227,11 @@ const ROLE_LANGUAGE_HINTS = {
     debugger: ['디버깅', '원인', '실패', '재현', '회귀'],
     test_engineer: ['테스트', '회귀 테스트', '검증', '픽스처', '커버리지'],
     ui_implementer: ['화면', '터미널', '젤리', '패널', '팬', '레이아웃', '사용성'],
+    native_app_specialist: ['네이티브 앱', '메뉴바', '앱킷', '스위프트', '맥os', '데스크톱', 'tcc'],
+    toolchain_specialist: ['툴체인', '의존성', '패키지 매니저', '빌드', '설치', '닥터', '업데이트', 'ci 자동화'],
+    protocol_reviewer: ['프로토콜', '계약', '스키마', '직렬화', 'api', 'sdk', 'cli', 'mcp', '하위 호환'],
+    runtime_reliability_reviewer: ['런타임 신뢰성', '훅', '세션', '락', '데몬', '프로세스 정리', '멱등성', '복구', '경쟁 상태', '교착'],
+    triwiki_evidence_reviewer: ['트라이위키', '컨텍스트 팩', '출처 계보', '신뢰 앵커', '증명 아티팩트', 'wrongness', '소스 하이드레이션'],
     architecture_reviewer: ['아키텍처', '설계', '수명주기', '결합도', '리팩터'],
     security_reviewer: ['보안', '권한', '인증', '비밀', '신뢰 경계'],
     database_reviewer: ['데이터베이스', '디비', '마이그레이션', '롤백', '스키마'],
@@ -194,8 +240,26 @@ const ROLE_LANGUAGE_HINTS = {
     release_reviewer: ['배포', '릴리스', '출시', '퍼블리시', '버전'],
     docs_maintainer: ['문서', '리드미', '변경로그', '마이그레이션 가이드'],
     integration_reviewer: ['통합', '병합', '리베이스', '호환성', '엔드투엔드'],
-    performance_analyst: ['성능', '지연', '벤치마크', '동시성', '토큰', '메모리']
+    performance_analyst: ['성능', '지연', '벤치마크', '동시성', '토큰', '메모리'],
+    long_context_analyst: ['롱 컨텍스트', '긴 컨텍스트', '장문', '대규모 파일', '여러 문서', '긴 로그', '컨텍스트 압축'],
+    computer_use_operator: ['컴퓨터 유즈', '데스크톱 조작', '맥os 점검', '시스템 설정', '네이티브 앱 점검'],
+    browser_use_operator: ['브라우저 유즈', '브라우저', '크롬', '웹사이트', '웹앱', '로컬호스트', '플레이라이트'],
+    image_generation_operator: ['이미지 생성', '이미지젠', 'gpt image', 'gpt-image-2', '비주얼 에셋']
+};
+const ROLE_PRIORITY_PATTERNS = {
+    debugger: /\b(?:debug|diagnos|root cause|failure|flaky|regression)\b|디버깅|진단|원인|실패|회귀/i,
+    architecture_reviewer: /\b(?:architecture|architect|refactor|state ownership|coupling)\b|아키텍처|리팩터|결합도/i,
+    security_reviewer: /\b(?:security|permission|secret|auth|trust boundary|abuse)\b|보안|권한|인증|비밀|신뢰\s*경계/i,
+    database_reviewer: /\b(?:database|db|sql|migration|rls|rollback)\b|데이터베이스|디비|마이그레이션|롤백/i,
+    release_reviewer: /\b(?:release|publish|deploy|distribution|versioning)\b|릴리스|배포|출시|퍼블리시/i,
+    research_reviewer: /\b(?:research review|paper review|methodology|falsification|reproducibility)\b|논문\s*검토|방법론|반증|재현성/i,
+    browser_use_operator: /\b(?:browser|chrome|playwright|selenium|puppeteer|website|webapp|localhost)\b|브라우저|크롬|웹사이트|웹앱|로컬호스트/i,
+    computer_use_operator: /\b(?:computer[- ]use|desktop interaction|system settings|native app inspection)\b|컴퓨터\s*유즈|데스크톱\s*조작|시스템\s*설정/i,
+    image_generation_operator: /\b(?:imagegen|image generation|gpt[- ]image(?:-2)?|generate image|edit image)\b|이미지\s*생성|이미지젠/i,
+    long_context_analyst: /\b(?:long[- ]context|large[- ](?:file|document|codebase)|multi[- ]document|extensive logs|context compression)\b|긴\s*컨텍스트|장문|대규모|여러\s*문서|긴\s*로그/i,
+    triwiki_evidence_reviewer: /\b(?:triwiki|context pack|provenance|trust anchor|wrongness memory|source hydration)\b|트라이위키|컨텍스트\s*팩|출처\s*계보|신뢰\s*앵커/i
 };
+const JUDGMENT_PRIORITY_RE = /\b(?:review|audit|debug|diagnos|root cause|planning|strategy|architecture|security|database|research|release|risk|judgment|ambiguous)\b|리뷰|검토|감사|디버깅|진단|원인|기획|전략|아키텍처|보안|데이터베이스|연구|릴리스|위험|판단|모호/i;
 const CRITICAL_RISK_RE = /\b(?:critical|catastrophic|production|data loss|security incident|breaking release)\b|치명|중대|운영|데이터\s*손실|보안\s*사고/i;
 const RISK_DOMAIN_PATTERNS = [
     ['database', /\b(?:database|db|sql|postgres|supabase|migration|rls)\b|데이터베이스|디비|마이그레이션/i],
@@ -203,13 +267,21 @@ const RISK_DOMAIN_PATTERNS = [
     ['release', /\b(?:release|publish|deploy|distribution|package registry|production rollout)\b|릴리스|배포|출시|퍼블리시/i],
     ['payment', /\b(?:payment|billing|checkout|transaction)\b|결제|청구|트랜잭션/i],
     ['performance', /\b(?:performance|latency|throughput|concurrency|resource usage)\b|성능|지연|처리량|동시성/i],
-    ['integration', /\b(?:integration|compatibility|cross-module|end-to-end)\b|통합|호환성|엔드투엔드/i]
+    ['integration', /\b(?:integration|compatibility|cross-module|end-to-end)\b|통합|호환성|엔드투엔드/i],
+    ['protocol', /\b(?:protocol|mcp|sdk|api contract|schema|serialization|wire format)\b|프로토콜|계약|스키마|직렬화/i],
+    ['runtime', /\b(?:hook|session|lock|daemon|process cleanup|idempotency|recovery|race condition|deadlock)\b|훅|세션|락|데몬|프로세스\s*정리|멱등성|복구|경쟁\s*상태|교착/i],
+    ['toolchain', /\b(?:toolchain|dependency upgrade|runtime upgrade|package manager|build script|install flow|doctor flow|update flow|ci automation)\b|툴체인|의존성|패키지\s*매니저|빌드|설치|닥터|업데이트/i],
+    ['evidence', /\b(?:triwiki|context pack|provenance|trust anchor|proof artifact|wrongness memory)\b|트라이위키|컨텍스트\s*팩|출처|신뢰\s*앵커|증거|증명/i]
 ];
 const ROLE_RISK_DOMAINS = {
     security_reviewer: 'security',
     database_reviewer: 'database',
     release_reviewer: 'release',
     performance_analyst: 'performance',
-    integration_reviewer: 'integration'
+    integration_reviewer: 'integration',
+    protocol_reviewer: 'protocol',
+    runtime_reliability_reviewer: 'runtime',
+    toolchain_specialist: 'toolchain',
+    triwiki_evidence_reviewer: 'evidence'
 };
 //# sourceMappingURL=agent-catalog.js.map