contextos-agents 1.6.0 → 1.7.0

package/.agents/resolver.js

@@ -20,6 +20,7 @@ const CORE_SKILLS_DIR = path.join(AGENTS_DIR, 'core', 'skills');
 const SKILL_RULES = [
   {
     skill: 'nextjs',
+    category: 'stack',
     strong: [/\bnext(?:\.js)?\b/i, /\bapp\s*router\b/i, /\bserver\s*actions?\b/i, /\brsc\b/i, /некст/i],
     medium: [/\bpage\.tsx\b/i, /\blayout\.tsx\b/i],
     weak: [],
@@ -27,6 +28,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'react',
+    category: 'stack',
     strong: [/\breact\b/i, /\buseOptimistic\b/i, /компонент/i, /хук/i],
     medium: [/\bcomponent\b/i, /\bhooks?\b/i, /\buseState\b/i, /\buseEffect\b/i, /\buseMemo\b/i, /\bprops\b/i, /модал\w*/i],
     weak: [],
@@ -34,6 +36,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'typescript',
+    category: 'stack',
     strong: [/\btypescript\b/i, /\btype-?safe\b/i, /\bgenerics?\b/i, /\binterface\b/i, /\btsconfig\b/i, /тайпскрипт/i, /типизац/i],
     medium: [],
     weak: [/\btypes?\b/i],
@@ -41,6 +44,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'ui-ux-pro',
+    category: 'ui',
     strong: [/\bui\b/i, /\bux\b/i, /\btailwind\b/i, /\bstyling\b/i, /дизайн/i, /верстк/i, /макет/i, /интерфейс/i],
     medium: [/\bcss\b/i, /\btheme\b/i, /\bmodal\b/i, /\bbutton\b/i, /модал\w*/i, /кнопк/i],
     weak: [/\bdesign\b/i],
@@ -48,6 +52,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'web-accessibility',
+    category: 'ui',
     strong: [/\baccessib\w*\b/i, /\ba11y\b/i, /\baria\b/i, /\bfocus\s*trap\b/i, /\bkeyboard\s*nav/i, /\bwcag\b/i, /\bscreen\s*reader\b/i, /доступност/i, /скринридер/i],
     medium: [],
     weak: [],
@@ -55,6 +60,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'impeccable-design',
+    category: 'ui',
     strong: [/\bvisual\s*qa\b/i, /\bmicro-?animation\b/i, /\bglassmorphism\b/i, /\btypography\b/i, /анимац/i, /полировк/i],
     medium: [/\bpolish\b/i],
     weak: [],
@@ -62,6 +68,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'database',
+    category: 'intent',
     strong: [/\bdatabase\b/i, /\bsql\b/i, /\bpostgres(?:ql)?\b/i, /\bprisma\b/i, /\bdrizzle\b/i, /\bmigration\b/i, /\borm\b/i, /баз.*данн/i, /миграц/i, /таблиц/i],
     medium: [/\bschema\b/i],
     weak: [/\bquery\b/i, /\bindex(?:ing)?\b/i],
@@ -69,6 +76,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'security',
+    category: 'intent',
     strong: [/\bauth\b/i, /\bjwt\b/i, /\blogin\b/i, /\bcsrf\b/i, /\bxss\b/i, /\brate\s*limit\b/i, /авториз/i, /аутентифик/i, /парол/i, /безопасност/i],
     medium: [/\bpermission\b/i, /\bsession\b/i, /\btoken\b/i, /токен/i],
     weak: [],
@@ -76,6 +84,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'performance',
+    category: 'intent',
     strong: [/\bperformance\b/i, /\blatency\b/i, /\blcp\b/i, /\bcls\b/i, /\binp\b/i, /\bcore\s*web\s*vitals\b/i, /\bwaterfall\b/i, /\bbundle\s*size\b/i, /производительн/i, /ускор/i],
     medium: [/\boptimize\b/i, /\bslow\b/i, /оптимиз/i, /медленн/i],
     weak: [],
@@ -83,6 +92,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'testing',
+    category: 'intent',
     strong: [/\bvitest\b/i, /\bjest\b/i, /\bplaywright\b/i, /\btdd\b/i, /\bbdd\b/i, /\be2e\b/i, /тестирован/i, /покрыти/i, /юнит/i],
     medium: [/\btest(?:s|ing)?\b/i, /\bmock\b/i, /тест/i],
     weak: [],
@@ -90,6 +100,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'docker',
+    category: 'intent',
     strong: [/\bdocker\b/i, /\bdockerfile\b/i, /\bcompose\b/i, /\bkubernetes\b/i, /\bk8s\b/i, /докер/i],
     medium: [],
     weak: [/\bcontainer\b/i, /контейнер/i],
@@ -97,6 +108,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'fastapi',
+    category: 'stack',
     strong: [/\bfastapi\b/i, /\bpydantic\b/i, /\buvicorn\b/i, /\bpytest\b/i, /питон/i],
     medium: [/\bpython\b/i],
     weak: [],
@@ -104,6 +116,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'nestjs',
+    category: 'stack',
     strong: [/\bnestjs\b/i, /\b@nestjs\b/i, /нест/i],
     medium: [],
     weak: [/\bmodule\b/i, /\bcontroller\b/i, /\binjectable\b/i],
@@ -111,6 +124,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'node',
+    category: 'stack',
     strong: [/\bnode(?:\.js)?\b/i, /\bexpress\b/i, /\bfastify\b/i],
     medium: [/\bbackend\b/i, /\bapi\s*route\b/i, /бэкенд/i, /эндпоинт/i],
     weak: [],
@@ -118,6 +132,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'ddd',
+    category: 'intent',
     strong: [/\bddd\b/i, /\bdomain-?driven\b/i, /\baggregate\b/i, /\bvalue\s*object\b/i, /\bbounded\s*context\b/i],
     medium: [/\bentity\b/i, /домен/i, /агрегат/i],
     weak: [],
@@ -125,6 +140,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'microservices',
+    category: 'intent',
     strong: [/\bmicroservices?\b/i, /\bevent-?driven\b/i, /\brabbitmq\b/i, /\bkafka\b/i, /\bgrpc\b/i, /микросервис/i],
     medium: [/\bpub\/?sub\b/i, /очеред/i],
     weak: [],
@@ -132,6 +148,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'system-design',
+    category: 'intent',
     strong: [/\bsystem\s*design\b/i, /\bhigh\s*concurrency\b/i, /\bcircuit\s*breaker\b/i, /масштабируем/i],
     medium: [/\barchitecture\b/i, /\bscalab(?:le|ility)\b/i, /архитектур/i],
     weak: [],
@@ -139,6 +156,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'graphify',
+    category: 'intent',
     strong: [/\bgraphify\b/i, /\bknowledge\s*graph\b/i, /\bcodebase\s*graph\b/i, /\bproject\s*graph\b/i, /\bblast\s*radius\b/i, /\bmap\s*(?:the\s*)?codebase\b/i, /граф\s*проект/i, /граф\s*зависимост/i],
     medium: [],
     weak: [],
@@ -146,6 +164,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'architecture-diagrams',
+    category: 'intent',
     strong: [/\bflowchart\b/i, /\bsequence\s*diagram\b/i],
     medium: [/\bdiagrams?\b/i, /диаграмм/i, /схем/i, /нарисуй/i],
     weak: [],
@@ -153,6 +172,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'subagent-orchestrator',
+    category: 'intent',
     strong: [/\bsubagent\b/i, /\bparallel\s*tasks\b/i, /субагент/i, /распараллел/i],
     medium: [/\bdelegate\b/i, /делегируй/i],
     weak: [],
@@ -160,6 +180,7 @@ const SKILL_RULES = [
   },
   {
     skill: 'interview-me',
+    category: 'intent',
     strong: [/\binterview\b/i, /интервью/i, /расспроси/i],
     medium: [/\bclarify\b/i, /\bquestions\b/i, /уточни\b/i],
     weak: [],
@@ -335,72 +356,171 @@ function analyzeImportGraph(projectDir = process.cwd()) {
  */
 function resolveSkills({ prompt = '', files = [], phase = 'Build', domain = '', projectDir = process.cwd() } = {}) {
   const promptText = (prompt || '').toLowerCase();
-  const scores = new Map();
+  const ruleMap = new Map();
+  const promptScores = new Map();
+  const fileScores = new Map();
 
   for (const rule of SKILL_RULES) {
-    let score = 0;
+    ruleMap.set(rule.skill, rule);
+    let pScore = 0;
+    let fScore = 0;
 
     // Strong triggers (10 points each match)
     for (const pat of rule.strong || []) {
-      if (pat.test(promptText)) score += 10;
+      if (pat.test(promptText)) pScore += 10;
     }
 
     // Medium triggers (5 points each match)
     for (const pat of rule.medium || []) {
-      if (pat.test(promptText)) score += 5;
+      if (pat.test(promptText)) pScore += 5;
     }
 
     // Weak triggers (2 points each match)
     for (const pat of rule.weak || []) {
-      if (pat.test(promptText)) score += 2;
+      if (pat.test(promptText)) pScore += 2;
     }
 
     // File matches (10 points per matching file)
     for (const file of files) {
       const normalized = file.replace(/\\/g, '/');
       for (const pat of rule.fileGlobs || []) {
-        if (pat.test(normalized)) score += 10;
+        if (pat.test(normalized)) fScore += 10;
       }
     }
 
-    // Minimum score threshold for domain skill activation
-    if (score >= 5) {
-      scores.set(rule.skill, score);
-    }
+    if (pScore > 0) promptScores.set(rule.skill, pScore);
+    if (fScore > 0) fileScores.set(rule.skill, fScore);
   }
 
   // Phase 2: Merge AST & Project Dependency Graph Signals
-  if (projectDir) {
-    const astSignals = analyzeImportGraph(projectDir);
-    for (const [skill, astScore] of astSignals) {
-      scores.set(skill, (scores.get(skill) || 0) + astScore);
+  const astSignals = projectDir ? analyzeImportGraph(projectDir) : new Map();
+
+  // Active Profile Resolution Enforcement
+  const profiles = require('./profiles.js');
+  const activeProfile = projectDir ? profiles.getActiveProfile(projectDir) : null;
+  const profileExcluded = new Set(activeProfile?.exclude_skills || []);
+  const profilePreferred = new Set(activeProfile?.prefer_skills || []);
+  const profileEnforce = activeProfile?.enforce || {};
+  const profileDefaults = activeProfile?.defaults || {};
+
+  const MAX_DOMAIN_SKILLS = 4;
+  const selectedSkills = [];
+
+  // 1. INTENT SLOTS & INTENT PRECEDENCE (Immunity against eviction)
+  // Direct user intent in prompt MUST NOT be evicted by ambient stack/file signals.
+  // Profile-excluded skills are strictly omitted from candidate intents.
+  const candidateIntents = [];
+  for (const rule of SKILL_RULES) {
+    const s = rule.skill;
+    if (profileExcluded.has(s)) continue;
+
+    const p = promptScores.get(s) || 0;
+    const f = fileScores.get(s) || 0;
+    if (rule.category === 'intent' && (p >= 5 || (p > 0 && f >= 10))) {
+      candidateIntents.push({ skill: s, score: p * 2 + f, priority: 2 });
+    } else if (p >= 10) {
+      candidateIntents.push({ skill: s, score: p, priority: 1 });
+    }
+  }
+
+  candidateIntents.sort((a, b) => b.priority - a.priority || b.score - a.score);
+
+  // Reserve up to 2 guaranteed intent slots for directly requested capabilities
+  for (const item of candidateIntents) {
+    if (selectedSkills.length < 2 && !selectedSkills.includes(item.skill)) {
+      selectedSkills.push(item.skill);
+    }
+  }
+
+  // 2. CONTEXT SUPPRESSION
+  // If task is purely infrastructure (e.g. docker) or pure backend/architecture,
+  // suppress ambient UI skills from AST to avoid polluting non-UI tasks.
+  const hasPureInfraIntent = selectedSkills.includes('docker');
+  const hasBackendOnlyIntent = selectedSkills.some(s => ['database', 'fastapi', 'nestjs', 'ddd'].includes(s)) &&
+    !files.some(f => /\.(tsx|jsx|css|scss|html)$/.test(f)) &&
+    !/\b(ui|react|css|tailwind|frontend|макет|дизайн|кнопк|стил|компонент)/i.test(promptText);
+
+  const suppressAmbientUI = hasPureInfraIntent || hasBackendOnlyIntent;
+
+  // 3. REMAINING SLOTS: Rank candidate skills with user-intent weighting and profile preferences
+  const candidateScores = new Map();
+  for (const rule of SKILL_RULES) {
+    const s = rule.skill;
+    if (selectedSkills.includes(s) || profileExcluded.has(s)) continue;
+
+    const p = promptScores.get(s) || 0;
+    const f = fileScores.get(s) || 0;
+    const a = astSignals.get(s) || 0;
+
+    // If ambient UI is suppressed, skip UI skills unless explicitly requested in prompt
+    if (suppressAmbientUI && (rule.category === 'ui' || s === 'react') && p < 5 && f === 0) {
+      continue;
+    }
+
+    // Require minimum unweighted threshold of 5 points to filter casual weak mentions,
+    // then apply multiplier for strong/medium prompt matches to prioritize user intent over ambient signals.
+    const rawSum = p + f + a;
+    if (rawSum >= 5 || profilePreferred.has(s)) {
+      let weightedScore = (p >= 5 ? p * 3 : p) + f + a;
+      if (profilePreferred.has(s)) {
+        weightedScore += 20; // Profile prefer boost
+      }
+      candidateScores.set(s, weightedScore);
     }
   }
 
-  // Sort matched domain skills by score descending
-  const sortedDomainSkills = Array.from(scores.entries())
+  const remainingSorted = Array.from(candidateScores.entries())
     .sort((a, b) => b[1] - a[1])
     .map(([skill]) => skill);
 
-  // Cap domain skills to top 4 max to prevent context bloat
-  const MAX_DOMAIN_SKILLS = 4;
-  const topDomainSkills = sortedDomainSkills.slice(0, MAX_DOMAIN_SKILLS);
+  for (const s of remainingSorted) {
+    if (selectedSkills.length >= MAX_DOMAIN_SKILLS) break;
+    if (!selectedSkills.includes(s)) {
+      selectedSkills.push(s);
+    }
+  }
+
+  // 4. Synergy rules (from AGENTS.md matrix)
+  const hasSynergyPrereq = selectedSkills.includes('database') ||
+    selectedSkills.includes('microservices') ||
+    selectedSkills.includes('ddd') ||
+    selectedSkills.includes('graphify');
+
+  if (hasSynergyPrereq && !selectedSkills.includes('system-design') && !profileExcluded.has('system-design')) {
+    if (selectedSkills.length < MAX_DOMAIN_SKILLS + 1) {
+      selectedSkills.push('system-design');
+    }
+  }
 
-  // Synergy rules (from AGENTS.md matrix)
-  const hasSynergyPrereq = topDomainSkills.includes('database') ||
-    topDomainSkills.includes('microservices') ||
-    topDomainSkills.includes('ddd') ||
-    topDomainSkills.includes('graphify');
+  // 5. Enforce profile invariants (e.g. enterprise or startup compliance)
+  const normPhase = (phase || '').toLowerCase();
+  if (profileEnforce.testing === true && ['build', 'verify', 'test'].includes(normPhase)) {
+    if (!selectedSkills.includes('testing') && !profileExcluded.has('testing')) {
+      selectedSkills.push('testing');
+    }
+  }
+
+  if (profileEnforce.security_audit === true && (selectedSkills.includes('database') || selectedSkills.includes('node') || selectedSkills.includes('fastapi') || selectedSkills.includes('nestjs'))) {
+    if (!selectedSkills.includes('security') && !profileExcluded.has('security')) {
+      selectedSkills.push('security');
+    }
+  }
+
+  if (profileEnforce.adr === true && (normPhase === 'plan' || selectedSkills.includes('system-design') || selectedSkills.includes('microservices'))) {
+    if (!selectedSkills.includes('decisions') && !profileExcluded.has('decisions')) {
+      selectedSkills.push('decisions');
+    }
+  }
 
-  if (hasSynergyPrereq && !topDomainSkills.includes('system-design')) {
-    if (topDomainSkills.length < MAX_DOMAIN_SKILLS + 1) {
-      topDomainSkills.push('system-design');
+  if (profileEnforce.accessibility_audit === true && (selectedSkills.includes('react') || selectedSkills.includes('ui-ux-pro'))) {
+    if (!selectedSkills.includes('web-accessibility') && !profileExcluded.has('web-accessibility')) {
+      selectedSkills.push('web-accessibility');
     }
   }
 
-  // Foundational skills (always active)
-  const allSkills = ['ponytail-mindset', 'engineering-workflow', ...topDomainSkills];
-  const finalSkills = Array.from(new Set(allSkills));
+  // Foundational skills (always active unless explicitly excluded)
+  const allSkills = ['ponytail-mindset', 'engineering-workflow', ...selectedSkills];
+  const finalSkills = Array.from(new Set(allSkills)).filter(s => !profileExcluded.has(s));
 
   // Infer Domain if not specified
   let inferredDomain = domain;

package/.agents/stats.js

@@ -64,8 +64,18 @@ function calculateContextStats(projectDir = process.cwd()) {
     }
   }
 
-  // Resolved context: 2 foundational skills + average 2 domain skills (e.g. react + ui-ux-pro)
-  const typicalResolvedSkills = ['engineering-workflow', 'ponytail-mindset', 'react', 'ui-ux-pro'];
+  // Resolved context: dynamically resolved skills for this project's stack
+  let typicalResolvedSkills = ['engineering-workflow', 'ponytail-mindset'];
+  try {
+    const resolver = require('./resolver.js');
+    const resolved = resolver.resolveSkills({ prompt: 'Implement standard feature', projectDir });
+    if (resolved && Array.isArray(resolved.skills)) {
+      typicalResolvedSkills = resolved.skills;
+    }
+  } catch (_) {
+    typicalResolvedSkills = ['engineering-workflow', 'ponytail-mindset', 'react', 'ui-ux-pro'];
+  }
+
   let resolvedChars = agentsMdChars;
   let resolvedSkillCount = 0;
   for (const s of typicalResolvedSkills) {
@@ -86,6 +96,7 @@ function calculateContextStats(projectDir = process.cwd()) {
     totalSkillCount,
     profiledSkillCount,
     resolvedSkillCount,
+    resolvedSkillList: typicalResolvedSkills,
     profileName,
     full: { chars: fullChars, tokens: fullTokens },
     profile: { chars: profileChars, tokens: profileTokens, savings: profileSavings },
@@ -96,28 +107,30 @@ function calculateContextStats(projectDir = process.cwd()) {
 function runStats(projectDir = process.cwd()) {
   const stats = calculateContextStats(projectDir);
 
-  console.log('\nContextOS — Context Savings Report\n');
+  console.log('\nContextOS — Context Savings Report & Payload Reduction\n');
   console.log('┌──────────────────────────────────────┬─────────────┬──────────┐');
-  console.log('│ Mode                                 │   Tokens    │  Savings │');
+  console.log('│ Context Mode                         │ Est. Tokens │  Savings │');
   console.log('├──────────────────────────────────────┼─────────────┼──────────┤');
 
-  const fullLabel = `Full (${stats.totalSkillCount} skills)`;
+  const fullLabel = `Full (${stats.totalSkillCount} skills catalog)`;
   const fullTok = stats.full.tokens.toLocaleString().padStart(9);
-  console.log(`│ ${fullLabel.padEnd(36)} │ ${fullTok}   │     —    │`);
+  console.log(`│ ${fullLabel.slice(0, 36).padEnd(36)} │ ${fullTok}   │ baseline │`);
 
   const profLabel = `Profile: ${stats.profileName} (${stats.profiledSkillCount} skills)`;
   const profTok = stats.profile.tokens.toLocaleString().padStart(9);
   const profSav = `${stats.profile.savings}%`.padStart(7);
   console.log(`│ ${profLabel.slice(0, 36).padEnd(36)} │ ${profTok}   │  ${profSav} │`);
 
-  const resLabel = `Resolved: typical task (${stats.resolvedSkillCount} skills)`;
+  const resLabel = `Dynamic: resolved task (${stats.resolvedSkillCount} skills)`;
   const resTok = stats.resolved.tokens.toLocaleString().padStart(9);
   const resSav = `${stats.resolved.savings}%`.padStart(7);
   console.log(`│ ${resLabel.slice(0, 36).padEnd(36)} │ ${resTok}   │  ${resSav} │`);
 
   console.log('└──────────────────────────────────────┴─────────────┴──────────┘');
-  console.log('\nToken estimation: ~4 chars/token (GPT-4 / Claude / Gemini approximation)');
-  console.log('Dynamic skill resolution prevents prompt bloat and cuts LLM API costs.\n');
+  console.log(`Resolved skills for project: ${stats.resolvedSkillList.join(', ')}`);
+  console.log('\nNote: Character-based token estimation (~4 chars/token heuristic).');
+  console.log('Measures static rule payload reduction against an uncurated full-catalog dump.');
+  console.log('Real workflow cost savings depend on prompt turns, model tokenizer, and task complexity.\n');
 
   return stats;
 }

package/.agents/validate.js

@@ -17,15 +17,26 @@ const fs   = require('fs');
 const path = require('path');
 const { collectAllSkillDirs } = require('./plugins.js');
 
-// ── Paths ─────────────────────────────────────────────────────────────────────
 const ROOT        = process.cwd();
 const AGENTS_DIR  = path.join(ROOT, '.agents');
 const CORE_SKILLS = path.join(AGENTS_DIR, 'core', 'skills');
+const CORE_PROFILES = path.join(AGENTS_DIR, 'core', 'profiles');
 const GENERATED   = path.join(AGENTS_DIR, 'generated');
 
 // Adapters that compile to generated/<name>/skills/
 const COMPILED_ADAPTERS = ['gemini', 'claude'];
 
+// Well-known external frameworks/tools valid in conflicts/optional/profiles but not internal ContextOS skills
+const EXTERNAL_NAMES = new Set([
+  'vue', 'angular', 'svelte', 'remix', 'express', 'koa', 'hapi', 'sails',
+  'tailwind', 'prisma', 'drizzle', 'mongoose', 'sequelize', 'typeorm',
+  'next-auth', 'react-query', 'zustand', 'redux', 'mobx', 'jotai', 'valtio',
+  'vitest', 'jest', 'mocha', 'cypress', 'playwright', 'storybook',
+  'graphql', 'trpc', 'apollo', 'relay', 'urql',
+  'sqlite', 'simple-auth', 'kubernetes', 'monitoring', 'cicd', 'cqrs',
+  'redis', 'postgres', 'postgresql', 'jwt', 'auth'
+]);
+
 // ── Tiny ANSI helpers (no deps) ───────────────────────────────────────────────
 const NO_COLOR = process.env.NO_COLOR || !process.stdout.isTTY;
 const c = {
@@ -68,7 +79,7 @@ function yamlList(text, field) {
   const re = new RegExp(`^${field}:\\s*\\[([^\\]]*)]`, 'm');
   const m  = text.match(re);
   if (!m || !m[1].trim()) return [];
-  return m[1].split(',').map(s => s.trim()).filter(Boolean);
+  return m[1].split(',').map(s => s.replace(/\s*#.*$/, '').trim()).filter(Boolean);
 }
 
 /**
@@ -83,7 +94,7 @@ function yamlBlockList(text, field) {
   if (!m) return [];
   return m[1]
     .split('\n')
-    .map(l => l.replace(/^[ \t]+-\s*/, '').trim())
+    .map(l => l.replace(/^[ \t]+-\s*/, '').replace(/\s*#.*$/, '').trim())
     .filter(Boolean);
 }
 
@@ -102,6 +113,8 @@ function parseSkillYaml(yamlText) {
     name:        yamlField(yamlText, 'name'),
     description: yamlField(yamlText, 'description'),
     version:     yamlField(yamlText, 'version'),
+    type:        yamlField(yamlText, 'type'),
+    resources:   yamlList(yamlText, 'resources').concat(yamlBlockList(yamlText, 'resources')),
     requires:    yamlList(yamlText, 'requires').concat(yamlBlockList(yamlText, 'requires')),
     conflicts:   yamlList(yamlText, 'conflicts').concat(yamlBlockList(yamlText, 'conflicts')),
     optional:    yamlList(yamlText, 'optional').concat(yamlBlockList(yamlText, 'optional')),
@@ -204,6 +217,12 @@ function checkSkillYaml(sourceSkills) {
       error(`[yaml] ${name}/skill.yaml — missing 'name:' field`);
       continue;
     }
+    const VALID_TYPES = new Set(['instruction-only', 'compiler', 'runtime', 'experimental']);
+    if (!parsed.type) {
+      error(`[yaml] ${name}/skill.yaml — missing 'type:' field (expected instruction-only | compiler | runtime | experimental)`);
+    } else if (!VALID_TYPES.has(parsed.type)) {
+      error(`[yaml] ${name}/skill.yaml — invalid type '${parsed.type}' (expected instruction-only | compiler | runtime | experimental)`);
+    }
     if (false && !parsed.description) {
       // Some skills use block scalars — allow it, just warn
       warn(`[yaml] ${name}/skill.yaml — 'description:' not found or uses multiline block (check manually)`);
@@ -284,16 +303,6 @@ function checkDependencies(sourceSkills) {
     }
   }
 
-  // externalNames: well-known external frameworks/tools that are valid in
-  // conflicts:/optional: but are NOT ContextOS skills. We never error on these.
-  const EXTERNAL_NAMES = new Set([
-    'vue', 'angular', 'svelte', 'remix', 'express', 'koa', 'hapi', 'sails',
-    'tailwind', 'prisma', 'drizzle', 'mongoose', 'sequelize', 'typeorm',
-    'next-auth', 'react-query', 'zustand', 'redux', 'mobx', 'jotai', 'valtio',
-    'vitest', 'jest', 'mocha', 'cypress', 'playwright', 'storybook',
-    'graphql', 'trpc', 'apollo', 'relay', 'urql',
-  ]);
-
   let depChecked = 0;
 
   for (const [name, skill] of Object.entries(sourceSkills)) {
@@ -414,6 +423,133 @@ function checkValidationJson(sourceSkills) {
   info(`[validation] ${pass} VALIDATION.json files are valid`);
 }
 
+// ═════════════════════════════════════════════════════════════════════════════
+//  CHECK 9 — MCP Bundle Synchronization
+// ═════════════════════════════════════════════════════════════════════════════
+function checkMcpBundleSync() {
+  const mcpSrcDir = path.join(ROOT, 'contextos-mcp', 'src');
+  const bundlePath = path.join(AGENTS_DIR, 'mcp', 'server.mjs');
+
+  if (!fs.existsSync(mcpSrcDir)) {
+    return;
+  }
+
+  if (!fs.existsSync(bundlePath)) {
+    warn(`[mcp-sync] Missing compiled MCP server bundle at .agents/mcp/server.mjs. Run: cd contextos-mcp && npm run build:bundle`);
+    return;
+  }
+
+  const bundleStat = fs.statSync(bundlePath);
+  const bundleMtime = bundleStat.mtimeMs;
+
+  let newestSrcFile = null;
+  let newestSrcMtime = 0;
+
+  function walk(dir) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        const stat = fs.statSync(full);
+        if (stat.mtimeMs > newestSrcMtime) {
+          newestSrcMtime = stat.mtimeMs;
+          newestSrcFile = path.relative(ROOT, full);
+        }
+      }
+    }
+  }
+
+  walk(mcpSrcDir);
+
+  if (newestSrcMtime > bundleMtime) {
+    warn(`[mcp-sync] Compiled MCP bundle (.agents/mcp/server.mjs) is older than source file ${newestSrcFile}. Run: cd contextos-mcp && npm run build:bundle`);
+  } else {
+    info(`[mcp-sync] Compiled MCP bundle (.agents/mcp/server.mjs) is up to date with contextos-mcp/src/`);
+  }
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+//  CHECK 10 — Resources Manifest Integrity
+// ═════════════════════════════════════════════════════════════════════════════
+function checkResourcesManifest(sourceSkills) {
+  let totalResources = 0;
+  let skillsWithResources = 0;
+
+  for (const [name, skill] of Object.entries(sourceSkills)) {
+    if (!skill.hasYaml) continue;
+
+    const text   = fs.readFileSync(skill.yamlPath, 'utf8');
+    const parsed = parseSkillYaml(text);
+
+    if (!parsed.resources || parsed.resources.length === 0) {
+      warn(`[resources] ${name}/skill.yaml — no resource files declared in manifest`);
+      continue;
+    }
+
+    skillsWithResources++;
+    for (const res of parsed.resources) {
+      const fullPath = path.join(skill.dir, res);
+      if (!fs.existsSync(fullPath)) {
+        error(`[resources] ${name}/skill.yaml — declared resource not found on disk: '${res}'`);
+      } else {
+        totalResources++;
+      }
+    }
+  }
+
+  info(`[resources] ${totalResources} resource files verified across ${skillsWithResources} skills`);
+}
+
+// ═════════════════════════════════════════════════════════════════════════════
+//  CHECK 11 — Profiles Integrity
+// ═════════════════════════════════════════════════════════════════════════════
+function checkProfilesIntegrity(sourceSkills) {
+  if (!fs.existsSync(CORE_PROFILES)) return;
+
+  const knownIds = new Set();
+  for (const [name, skill] of Object.entries(sourceSkills)) {
+    knownIds.add(name);
+    if (skill.hasYaml) {
+      const text = fs.readFileSync(skill.yamlPath, 'utf8');
+      const id   = yamlField(text, 'id');
+      if (id) knownIds.add(id);
+    }
+  }
+
+  let profilesValidated = 0;
+  const files = fs.readdirSync(CORE_PROFILES).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+
+  for (const file of files) {
+    const filePath = path.join(CORE_PROFILES, file);
+    const text = fs.readFileSync(filePath, 'utf8');
+
+    const referenced = [
+      ...yamlList(text, 'skills'),
+      ...yamlBlockList(text, 'skills'),
+      ...yamlList(text, 'prefer_skills'),
+      ...yamlBlockList(text, 'prefer_skills'),
+      ...yamlList(text, 'exclude_skills'),
+      ...yamlBlockList(text, 'exclude_skills'),
+    ];
+
+    for (const skillName of referenced) {
+      if (!knownIds.has(skillName) && !EXTERNAL_NAMES.has(skillName)) {
+        error(`[profiles] ${file} — references unknown skill '${skillName}'`);
+      }
+    }
+    profilesValidated++;
+  }
+
+  info(`[profiles] ${profilesValidated} core profiles validated against skill registry`);
+}
+
 // ═════════════════════════════════════════════════════════════════════════════
 //  REPORT
 // ═════════════════════════════════════════════════════════════════════════════
@@ -487,6 +623,9 @@ function run() {
   checkContentQuality(sourceSkills);
   checkCostarHeaders(sourceSkills);
   checkValidationJson(sourceSkills);
+  checkMcpBundleSync();
+  checkResourcesManifest(sourceSkills);
+  checkProfilesIntegrity(sourceSkills);
 
   const passed = printReport();
   process.exit(passed ? 0 : 1);