contextos-agents 2.0.0 → 2.1.1

package/.agents/generated/gemini/skills/security/SKILL.md

@@ -30,7 +30,7 @@ Activate whenever writing authentication, authorization, session management, dat
 
 #### 1. Injection (SQL, NoSQL, Command)
 
-- Always use parameterized queries — never concatenate user input into SQL or shell commands.
+- Always use parameterized queries - never concatenate user input into SQL or shell commands.
 - Use ORMs (Prisma, Drizzle, SQLAlchemy) with strict schema validation.
 - Validate and sanitize all user input before processing.
 
@@ -79,14 +79,20 @@ When building AI workflows, tools, or MCP servers:
    - Never allow untrusted content to override system instructions or tool execution permissions.
 2. **Tool Execution Boundaries**:
    - Destructive operations (database drops, file deletions, payment triggers) MUST require explicit user confirmation.
-   - Restrict file system tools to the workspace root — block directory traversal (`../`).
+   - Restrict file system tools to the workspace root - block directory traversal (`../`).
 3. **Secret Masking & Output Sanitization**:
    - Scrub API keys (`sk-...`, `Bearer ...`), tokens, and credentials before writing to agent logs or step summaries.
+4. **Sandbox Execution & Write Isolation (Supply-Chain Defense)**:
+   - Target code is inspected strictly read-only; never execute target-controlled builds or tests with write access to the repository root.
+   - Restrict process write boundaries strictly to an isolated temporary `scratch/` directory.
+   - Enforce zero outbound external network access during security audits to prevent secret exfiltration via malicious scripts or dependencies.
+   - Promote verified non-secret results to retained `artifacts/` only via trusted parent-side inspection code.
 
 ---
 
 ## Code Examples
 
+
 ### Timing-Safe Secret Verification
 
 ```javascript
@@ -102,28 +108,50 @@ export function verifyWebhookSignature(payload, signature, secret) {
 }
 ```
 
-### Safe SSRF Prevention Wrapper
+### SSRF Prevention Requirements (OWASP Compliant)
 
-```typescript
-import dns from 'node:dns/promises';
+Per [OWASP SSRF Prevention Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html), naive application-level DNS pre-checks followed by standard `fetch(url)` are fundamentally flawed due to DNS rebinding (TOCTOU) and unvalidated HTTP 3xx redirects.
+
+#### Mandatory Architectural Controls
+
+1. **Network-Layer Defense (Primary)**: For user-supplied arbitrary webhooks or URLs, route all outbound traffic through an isolated egress forward proxy (e.g., Smokescreen, Envoy, Squid) configured with firewall-level IP filters blocking RFC 1918, RFC 6598, link-local (`169.254.169.254`), loopback, and IPv6 local addresses at the socket handshake level.
+2. **Positive Destination Allowlist**: If fetching from known external partners, validate destination hostname against a strict positive allowlist.
+3. **Disable Automatic Redirects**: Always set `redirect: 'error'` or `'manual'`. Never follow HTTP redirects automatically without re-validating the target URL against allowlist rules.
+4. **Protocol & Credential Restrictions**: Enforce `https:` exclusively; reject embedded credentials (`user:pass@host`) and non-standard ports.
 
-export async function validateSafeUrl(urlString: string): Promise<URL> {
+```typescript
+/**
+ * Verified Allowlist-based HTTP Client (OWASP SSRF Prevention)
+ * Enforces HTTPS, strict destination allowlist, and rejects HTTP redirects.
+ */
+export async function fetchFromAllowlist(
+  urlString: string,
+  allowedHostnames: ReadonlySet<string>,
+  options: RequestInit = {}
+): Promise<Response> {
   const parsed = new URL(urlString);
+
+  // 1. Enforce HTTPS only
   if (parsed.protocol !== 'https:') {
-    throw new Error('Only HTTPS protocol is permitted');
+    throw new Error(`SSRF blocked: protocol "${parsed.protocol}" is not permitted; HTTPS required`);
   }
 
-  const { address } = await dns.lookup(parsed.hostname);
-  if (
-    address.startsWith('127.') ||
-    address.startsWith('10.') ||
-    address.startsWith('192.168.') ||
-    address === '169.254.169.254'
-  ) {
-    throw new Error('Access to private/metadata IP addresses is blocked');
+  // 2. Reject credentials in URL
+  if (parsed.username || parsed.password) {
+    throw new Error('SSRF blocked: URL credentials (user:password@host) are prohibited');
   }
 
-  return parsed;
+  // 3. Strict positive destination allowlist (prevents internal network probing)
+  const normalizedHost = parsed.hostname.toLowerCase();
+  if (!allowedHostnames.has(normalizedHost)) {
+    throw new Error(`SSRF blocked: destination host "${normalizedHost}" is not in the approved allowlist`);
+  }
+
+  // 4. Disable automatic redirects to prevent redirection to private IPs or metadata endpoints
+  return fetch(urlString, {
+    ...options,
+    redirect: 'error'
+  });
 }
 ```
 
@@ -156,115 +184,6 @@ export async function validateSafeUrl(urlString: string): Promise<URL> {
 - Pairs with `system-design` to mandate secure network boundaries and authorization layers.
 
 
-<!-- Source: security.md -->
-
-# Application Security — Best Practices
-
-## OWASP Top 10
-
-### 1. Injection (SQL, NoSQL, Command)
-
-- **Always use parameterized queries** — never concatenate user input into SQL
-- Use ORM (Prisma, SQLAlchemy, TypeORM) — they parameterize by default
-- Validate and sanitize all user input
-
-### 2. Broken Authentication
-
-- Use bcrypt/argon2 for password hashing (cost factor ≥ 12)
-- JWT: short-lived access tokens (15min), refresh tokens (7 days)
-- Rate limit login attempts
-- Implement account lockout after N failed attempts
-- MFA for sensitive operations
-
-### 3. Sensitive Data Exposure
-
-- HTTPS everywhere — redirect HTTP to HTTPS
-- Encrypt sensitive data at rest (AES-256)
-- Never log passwords, tokens, or PII
-- Use environment variables for secrets
-
-### 4. XML/XXE
-
-- Disable external entity processing
-- Use JSON instead of XML where possible
-
-### 5. Broken Access Control
-
-- Default deny — explicitly grant access
-- RBAC (Role-Based Access Control) or ABAC (Attribute-Based)
-- Check authorization on every request, not just UI
-- Don't rely on client-side validation for security
-
-### 6. Security Misconfiguration
-
-- Remove default credentials
-- Disable debug mode in production
-- Security headers (see below)
-- Keep dependencies updated
-
-### 7. XSS (Cross-Site Scripting)
-
-- Escape all output by default
-- Content-Security-Policy header
-- HttpOnly + Secure + SameSite cookies
-- Use framework's built-in XSS protection
-
-### 8. Insecure Deserialization
-
-- Validate and schema-check all input (Zod, Pydantic, class-validator)
-- Don't deserialize untrusted data
-
-### 9. Insufficient Logging
-
-- Log all authentication events
-- Log authorization failures
-- Log input validation failures
-- Include request ID for tracing
-
-### 10. SSRF (Server-Side Request Forgery)
-
-- Validate and allowlist URLs
-- Don't let users control server-side HTTP requests
-
-## Security Headers
-
-```
-Content-Security-Policy: default-src 'self'
-X-Content-Type-Options: nosniff
-X-Frame-Options: DENY
-Strict-Transport-Security: max-age=31536000; includeSubDomains
-Referrer-Policy: strict-origin-when-cross-origin
-Permissions-Policy: camera=(), microphone=(), geolocation=()
-```
-
-## Authentication Patterns
-
-### JWT Flow
-
-```
-Login → Access Token (15min) + Refresh Token (7d, HttpOnly cookie)
-Request → Authorization: Bearer <access_token>
-Expired → POST /auth/refresh (sends refresh cookie) → new access token
-```
-
-### OAuth2 Flow
-
-```
-Redirect → Provider (Google, GitHub) → Callback → Create/link user → JWT
-```
-
-## Checklist Before Deploy
-
-- [ ] All secrets in environment variables
-- [ ] HTTPS enabled
-- [ ] Security headers configured
-- [ ] Input validation on all endpoints
-- [ ] Rate limiting enabled
-- [ ] CORS configured (not `*`)
-- [ ] Error messages don't leak internals
-- [ ] Dependency audit (`npm audit`, `pip audit`)
-- [ ] Logging for security events
-
 <!-- Source: EXAMPLES.md -->
 
 # Application Security Examples — Anti-patterns vs ContextOS Standard

package/.agents/plugins.js

@@ -26,7 +26,7 @@ const https   = require('https');
 const crypto  = require('crypto');
 const { execFileSync } = require('child_process');
 const { ProjectMutationLock } = require('./filesystem/project-lock.js');
-const JournaledTransaction = require('./filesystem/journaled-transaction.js');
+const { JournaledTransaction } = require('./filesystem/journaled-transaction.js');
 const {
   calculateTreeDigest,
   validateArchiveEntry,
@@ -284,11 +284,49 @@ function isValidNpmPackage(name) {
   return /^(?:@[a-z0-9_.-]+\/)?[a-z0-9_.-]+$/.test(name);
 }
 
-function parseRef(ref) {
+function parseRef(ref, projectRoot = null) {
   if (typeof ref !== 'string' || !ref.trim()) {
     throw new Error('A plugin reference is required');
   }
 
+  // 1. Built-in package catalog skills take strict precedence for catalog names.
+  // Consumer project local files can never spoof or hijack package catalog skills.
+  const pkgCatalogPath = path.join(path.resolve(__dirname, '..'), 'catalog', 'skills', ref);
+  if (fs.existsSync(pkgCatalogPath) && fs.existsSync(path.join(pkgCatalogPath, 'SKILL.md'))) {
+    return {
+      type: 'catalog',
+      name: ref,
+      path: pkgCatalogPath,
+      isPinned: true,
+      raw: ref,
+    };
+  }
+
+  // 2. Explicit local references (must start with 'local:', './', '../', or 'file:')
+  if (ref.startsWith('local:') || ref.startsWith('./') || ref.startsWith('../') || ref.startsWith('file:')) {
+    const rawTarget = ref.startsWith('local:')
+      ? ref.slice(6)
+      : (ref.startsWith('file:') ? ref.slice(5) : ref);
+
+    const baseRoot = projectRoot || process.cwd();
+    let localDir = path.resolve(baseRoot, rawTarget);
+    if (!fs.existsSync(localDir)) {
+      localDir = path.join(baseRoot, 'catalog', 'skills', rawTarget);
+    }
+
+    if (fs.existsSync(localDir) && fs.existsSync(path.join(localDir, 'SKILL.md'))) {
+      const skillName = path.basename(localDir);
+      return {
+        type: 'catalog',
+        name: skillName,
+        path: localDir,
+        isPinned: true,
+        raw: ref,
+      };
+    }
+    throw new Error(`Local skill not found at: '${ref}'`);
+  }
+
   // Scoped packages contain a slash but are npm packages, not GitHub refs.
   if (ref.startsWith('@')) {
     if (!isValidNpmPackage(ref)) {
@@ -529,6 +567,62 @@ function installFromNpm(descriptor, skillName, dryRun, checksum, forceUnsafe = f
   return sha256;
 }
 
+// ── Catalog installer ─────────────────────────────────────────────────────────
+function installFromCatalog(descriptor, skillName, dryRun, checksum, forceUnsafe = false, tx = null) {
+  const sourceDir = descriptor.path;
+  const targetDir = path.join(PLUGINS_DIR, skillName);
+  const relTargetDir = toPosix(path.relative(ROOT, targetDir));
+
+  if (dryRun) {
+    console.log(c.dim(`  [DRY-RUN] Would copy catalog skill from: ${sourceDir}`));
+    return 'sha256:0000000000000000000000000000000000000000000000000000000000000000';
+  }
+
+  function copyRecursive(src, dest, relDest) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      const relPath = toPosix(path.join(relDest, entry.name));
+
+      if (entry.isDirectory()) {
+        copyRecursive(srcPath, destPath, relPath);
+      } else {
+        const content = fs.readFileSync(srcPath, 'utf8');
+        if (tx) {
+          tx.stageWrite(relPath, content);
+        } else {
+          fs.writeFileSync(destPath, content, 'utf8');
+        }
+      }
+    }
+  }
+
+  copyRecursive(sourceDir, targetDir, relTargetDir);
+
+  const primarySkillMd = path.join(sourceDir, 'SKILL.md');
+  const sha256 = fs.existsSync(primarySkillMd) ? crypto.createHash('sha256').update(fs.readFileSync(primarySkillMd)).digest('hex') : null;
+
+  const sourceMeta = {
+    source: 'catalog',
+    name: skillName,
+    path: toPosix(path.relative(ROOT, sourceDir)),
+    sha256,
+    installedAt: new Date().toISOString(),
+  };
+  if (tx) {
+    tx.stageWrite(`${relTargetDir}/.source`, JSON.stringify(sourceMeta, null, 2) + '\n');
+  } else {
+    fs.writeFileSync(path.join(targetDir, '.source'), JSON.stringify(sourceMeta, null, 2) + '\n');
+  }
+
+  console.log(c.green(`  ✓ Installed from built-in catalog: ${skillName}`));
+  return sha256;
+}
+
 // ── Derive skill name from ref ────────────────────────────────────────────────
 function deriveSkillName(ref) {
   // username/repo/path/to/my-skill → my-skill
@@ -570,7 +664,7 @@ async function add(ref, options = {}) {
   }
 
   // Supply-chain source pinning check (Wave 6)
-  if (!dryRun) {
+  if (!dryRun && descriptor.type !== 'catalog') {
     const pinning = validatePluginPinning(
       {
         type: descriptor.type,
@@ -637,7 +731,9 @@ async function add(ref, options = {}) {
     lockToken = projectLock.acquire({ command: 'skill:add' });
 
     let installedSha256 = null;
-    if (descriptor.type === 'github') {
+    if (descriptor.type === 'catalog') {
+      installedSha256 = installFromCatalog(descriptor, skillName, dryRun, checksum, forceUnsafe, tx);
+    } else if (descriptor.type === 'github') {
       installedSha256 = await installFromGitHub(descriptor, skillName, dryRun, checksum, forceUnsafe, tx);
     } else {
       installedSha256 = installFromNpm(descriptor, skillName, dryRun, checksum, forceUnsafe, tx);
@@ -901,17 +997,18 @@ async function search(query) {
  * Adapters call this instead of reading CORE_SKILLS directly.
  */
 function collectAllSkillDirs(targetRoot) {
+  const isTargetExplicit = Boolean(targetRoot);
   const root = targetRoot || process.cwd();
   const agentsDir = path.join(root, '.agents');
   const localCore = path.join(agentsDir, 'core', 'skills');
   const localPlugins = path.join(agentsDir, 'plugins');
 
-  const coreDir = fs.existsSync(localCore) ? localCore : CORE_SKILLS;
-  const pluginsDir = fs.existsSync(localPlugins) ? localPlugins : PLUGINS_DIR;
+  const coreDir = fs.existsSync(localCore) ? localCore : (isTargetExplicit ? null : CORE_SKILLS);
+  const pluginsDir = fs.existsSync(localPlugins) ? localPlugins : (isTargetExplicit ? null : PLUGINS_DIR);
   const dirs = [];
 
   // Core skills
-  if (fs.existsSync(coreDir)) {
+  if (coreDir && fs.existsSync(coreDir)) {
     for (const name of fs.readdirSync(coreDir)) {
       const d = path.join(coreDir, name);
       if (fs.statSync(d).isDirectory()) dirs.push(d);
@@ -919,7 +1016,7 @@ function collectAllSkillDirs(targetRoot) {
   }
 
   // Plugin skills (supports both standalone skill dirs and plugin bundles with skills/)
-  if (fs.existsSync(pluginsDir)) {
+  if (pluginsDir && fs.existsSync(pluginsDir)) {
     for (const name of fs.readdirSync(pluginsDir)) {
       const d = path.join(pluginsDir, name);
       if (!fs.statSync(d).isDirectory()) continue;

package/.agents/profiles.js

@@ -298,14 +298,26 @@ function validateProfile(profile, registry = null) {
 }
 
 /**
- * Lists all available project profiles defined in core/profiles.
+ * Lists all available project profiles defined in core/profiles and optionally consumer project.
+ * Searches built-in profiles in packageRoot, and if projectRoot is supplied, searches
+ * consumer project .agents/profiles, .agents/core/profiles, and profiles directories.
  *
+ * @param {string|null} [projectRoot=null] - Optional consumer project root
  * @returns {ProfileConfig[]} Array of profile configurations
  */
-function listProfiles() {
+function listProfiles(projectRoot = null) {
   const profiles = [];
   const searchDirs = [PROFILES_DIR, path.join(AGENTS_DIR, 'catalog', 'presets')];
 
+  if (projectRoot) {
+    const absConsumer = path.resolve(projectRoot);
+    searchDirs.push(
+      path.join(absConsumer, '.agents', 'profiles'),
+      path.join(absConsumer, '.agents', 'core', 'profiles'),
+      path.join(absConsumer, 'profiles')
+    );
+  }
+
   for (const dir of searchDirs) {
     if (!fs.existsSync(dir)) continue;
     const files = fs.readdirSync(dir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
@@ -314,22 +326,31 @@ function listProfiles() {
       const parsed = parseYamlProfile(content);
       if (!parsed.id) parsed.id = path.basename(file, path.extname(file));
       if (!parsed.name) parsed.name = parsed.id;
-      profiles.push(parsed);
+
+      // Consumer profiles can override or extend built-in profiles; deduplicate by id
+      const normId = parsed.id.toLowerCase();
+      const existingIdx = profiles.findIndex(p => p.id.toLowerCase() === normId);
+      if (existingIdx !== -1) {
+        profiles[existingIdx] = parsed;
+      } else {
+        profiles.push(parsed);
+      }
     }
   }
   return profiles;
 }
 
 /**
- * Finds a profile by its slug ID or title.
+ * Finds a profile by its slug ID or title across package and consumer roots.
  *
  * @param {string} name - Profile identifier or name
+ * @param {string|null} [projectRoot=null] - Optional consumer project root
  * @returns {ProfileConfig|null} Found profile or null
  */
-function getProfile(name) {
+function getProfile(name, projectRoot = null) {
   if (!name) return null;
   const clean = name.toLowerCase().trim();
-  const all = listProfiles();
+  const all = listProfiles(projectRoot);
   return all.find(p => p.id.toLowerCase() === clean || p.name.toLowerCase() === clean) || null;
 }
 
@@ -398,7 +419,7 @@ function getActiveProfile(projectDir = process.cwd(), targetFileOrScope = null)
     }
 
     if (matchedProfileName) {
-      const overrideProf = getProfile(matchedProfileName);
+      const overrideProf = getProfile(matchedProfileName, projectDir);
       if (overrideProf) {
         return {
           ...overrideProf,
@@ -424,9 +445,9 @@ function getActiveProfile(projectDir = process.cwd(), targetFileOrScope = null)
  * @returns {Object} Updated profile lock data
  */
 function applyProfile(profileName, projectDir = process.cwd(), options = {}) {
-  const profile = getProfile(profileName);
+  const profile = getProfile(profileName, projectDir);
   if (!profile) {
-    throw new Error(`Profile '${profileName}' not found. Available profiles: ${listProfiles().map(p => p.id).join(', ')}`);
+    throw new Error(`Profile '${profileName}' not found. Available profiles: ${listProfiles(projectDir).map(p => p.id).join(', ')}`);
   }
 
   validateProfile(profile);
@@ -563,9 +584,9 @@ function removeActiveProfile(projectDir = process.cwd(), options = {}) {
  * @returns {Object} Explanation structure
  */
 function explainProfile(profileName, projectDir = process.cwd()) {
-  const profile = getProfile(profileName);
+  const profile = getProfile(profileName, projectDir);
   if (!profile) {
-    throw new Error(`Profile '${profileName}' not found. Available profiles: ${listProfiles().map(p => p.id).join(', ')}`);
+    throw new Error(`Profile '${profileName}' not found. Available profiles: ${listProfiles(projectDir).map(p => p.id).join(', ')}`);
   }
 
   return {

package/.agents/resolver/canonical-resolver.js

@@ -23,15 +23,15 @@ const { WorkspaceGraphBuilder } = require('../workspace/workspace-graph');
 // Prompt budget limits (Section 14.4)
 const BUDGET_TIERS = {
   BOOTSTRAP: 1200,      // always-on bootstrap budget
-  SKILL_SUMMARY: 150,   // single skill summary limit
-  SKILL_BODY: 1200,     // single skill body limit
-  ROUTINE: 2000,        // routine context limit
-  STANDARD: 4000,       // standard normal compiled context limit
-  HIGH: 7500,           // high-risk compiled context limit
-  DESTRUCTIVE: 10000,   // destructive compiled context limit
+  SKILL_SUMMARY: 300,   // single skill summary limit
+  SKILL_BODY: 10000,    // single skill body limit (supports rich code examples and rules)
+  ROUTINE: 16000,       // routine context limit
+  STANDARD: 32000,      // standard normal compiled context limit (supports 8-10 full skills)
+  HIGH: 64000,          // high-risk compiled context limit
+  DESTRUCTIVE: 128000,  // destructive compiled context limit
 };
 
-const DEFAULT_CONTEXT_BUDGET_TOKENS = 8000;
+const DEFAULT_CONTEXT_BUDGET_TOKENS = 64000;
 
 // Risk-based workflows (Section 14.3)
 const WORKFLOW_TEMPLATES = {

package/.agents/validate.js

@@ -641,10 +641,74 @@ function checkRegistryV2() {
   }
 }
 
+// ═════════════════════════════════════════════════════════════════════════════
+//  CHECK 13 — Catalog Skills Validation (Optional, gated by --catalog)
+// ═════════════════════════════════════════════════════════════════════════════
+function checkCatalogSkills() {
+  const catalogSkillsDir = path.join(ROOT, 'catalog', 'skills');
+  if (!fs.existsSync(catalogSkillsDir)) {
+    error(`[catalog] Catalog skills directory not found: ${catalogSkillsDir}`);
+    return;
+  }
+
+  let validated = 0;
+  const entries = fs.readdirSync(catalogSkillsDir);
+
+  for (const name of entries) {
+    const dir = path.join(catalogSkillsDir, name);
+    if (!fs.statSync(dir).isDirectory()) continue;
+
+    const skillMd = path.join(dir, 'SKILL.md');
+    const yaml = path.join(dir, 'skill.yaml');
+    const validationJson = path.join(dir, 'VALIDATION.json');
+
+    if (!fs.existsSync(skillMd)) {
+      error(`[catalog] ${name}: missing SKILL.md`);
+      continue;
+    }
+
+    const content = fs.readFileSync(skillMd, 'utf8');
+    const fm = parseFrontmatter(content);
+    if (!fm || fm.malformed) {
+      error(`[catalog] ${name}: malformed YAML frontmatter in SKILL.md`);
+    } else {
+      if (!yamlField(fm.raw, 'name')) {
+        error(`[catalog] ${name}: missing 'name' in SKILL.md frontmatter`);
+      }
+      if (!yamlField(fm.raw, 'description')) {
+        error(`[catalog] ${name}: missing 'description' in SKILL.md frontmatter`);
+      }
+    }
+
+    if (!fs.existsSync(yaml)) {
+      error(`[catalog] ${name}: missing skill.yaml`);
+    } else {
+      const yamlText = fs.readFileSync(yaml, 'utf8');
+      if (!yamlField(yamlText, 'name') && !yamlField(yamlText, 'id')) {
+        error(`[catalog] ${name}: missing 'name' or 'id' in skill.yaml`);
+      }
+    }
+
+    if (fs.existsSync(validationJson)) {
+      try {
+        JSON.parse(fs.readFileSync(validationJson, 'utf8'));
+      } catch (err) {
+        error(`[catalog] ${name}: invalid JSON in VALIDATION.json: ${err.message}`);
+      }
+    }
+
+    validated++;
+  }
+
+  info(`[catalog] ${validated} catalog skills validated (frontmatter, skill.yaml, validation metadata)`);
+}
+
 // ═════════════════════════════════════════════════════════════════════════════
 //  MAIN
 // ═════════════════════════════════════════════════════════════════════════════
-function run() {
+function run(options = {}) {
+  const checkCatalog = Boolean(options.checkCatalog || process.argv.includes('--catalog'));
+
   console.log(c.cyan('\nContextOS Validator — scanning skills...\n'));
 
   if (!fs.existsSync(CORE_SKILLS)) {
@@ -670,6 +734,10 @@ function run() {
   checkProfilesIntegrity(sourceSkills);
   checkRegistryV2();
 
+  if (checkCatalog) {
+    checkCatalogSkills();
+  }
+
   const passed = printReport();
   process.exit(passed ? 0 : 1);
 }