coursecode 0.1.26 → 0.1.28

package/framework/docs/FRAMEWORK_GUIDE.md

@@ -662,9 +662,9 @@ Runs **in Node.js** during build (via `vite.framework-dev.config.js` `closeBundl
 
 **Errors fail the build; warnings print but don't block.**
 
-### MCP `coursecode_lint` — Unified Results
+### MCP `coursecode_lint` — Build-Time Only
 
-The MCP `coursecode_lint` tool always runs the build linter. When the preview server is running and the headless browser is connected, it also merges runtime errors from the preview server's error log into the same response. These are the same errors shown in the debug panel's Errors tab and returned by `coursecode_state` — LMS API misuse, console errors, uncaught exceptions, and data limit warnings. Runtime-sourced items are tagged with `source: 'runtime'` and `rule: 'runtime-error'`. The `runtimeLintIncluded` flag in the response indicates whether runtime errors were included. This gives AI agents a single tool for both static lint and runtime errors without needing a separate `coursecode_state` call.
+The MCP `coursecode_lint` tool runs the build linter (config validation, CSS class verification, structure checks). It does NOT include runtime errors. For runtime errors, contrast warnings, and other dynamic issues, use `coursecode_state` which returns `frameworkLogs` and `errors` from the preview server.
 
 ### Shared Rules (`lib/validation-rules.js`)
 

package/lib/authoring-api.js

@@ -167,9 +167,8 @@ export function getAuthoringContext() {
 
 /**
  * Dynamic CSS catalog — extracts structured class data from real CSS files via PostCSS.
- * 
- * Without filterCategory: returns compact categorized index (class name → short description).
- * With filterCategory: returns full detail for that category (all declarations).
+ * Token values (spacing, font sizes, etc.) are resolved from design-tokens.css so
+ * AI sees actual values like "1rem" instead of opaque "var(--space-4)".
  * 
  * Category names are derived from file paths relative to framework/css/:
  *   utilities/borders.css → "utilities/borders"
@@ -177,8 +176,77 @@ export function getAuthoringContext() {
  *   components/hero.css → "components/hero"
  */
 
-// Module-level cache — parsed once per process
+// Module-level caches — parsed once per process
 let _cssCatalogCache = null;
+let _tokenMapCache = null;
+
+/**
+ * Parse design-tokens.css and resolve var() chains to final values.
+ * Returns a map of --variable-name → resolved-value.
+ */
+function buildTokenMap() {
+    if (_tokenMapCache) return _tokenMapCache;
+
+    const frameworkRoot = getFrameworkRoot();
+    const tokensFile = path.join(frameworkRoot, 'framework', 'css', 'design-tokens.css');
+
+    if (!fs.existsSync(tokensFile)) {
+        _tokenMapCache = {};
+        return _tokenMapCache;
+    }
+
+    const source = fs.readFileSync(tokensFile, 'utf-8');
+    const root = postcss.parse(source);
+    const tokens = {};
+
+    // Extract all custom properties from :root blocks
+    root.walk(node => {
+        if (node.type === 'decl' && node.prop.startsWith('--')) {
+            tokens[node.prop] = node.value.trim();
+        }
+    });
+
+    // Resolve var() chains iteratively (handles --space-4 → --space-4-base → 0.25rem)
+    for (let i = 0; i < 10; i++) {
+        let changed = false;
+        for (const [prop, value] of Object.entries(tokens)) {
+            const resolved = value.replace(/var\(\s*([^,)]+)\s*\)/g, (match, varName) => {
+                const trimmed = varName.trim();
+                if (tokens[trimmed] && !tokens[trimmed].includes('var(')) {
+                    changed = true;
+                    return tokens[trimmed];
+                }
+                return match;
+            });
+            tokens[prop] = resolved;
+        }
+        if (!changed) break;
+    }
+
+    _tokenMapCache = tokens;
+    return _tokenMapCache;
+}
+
+/**
+ * Replace var() references in a CSS value with resolved token values.
+ * Only resolves structural tokens (spacing, sizes, radii). Color tokens are
+ * left as var() references since semantic names like var(--bg-elevated) are
+ * more useful to AI than theme-dependent hex values like #1e293b.
+ */
+function resolveVarRefs(value, tokenMap) {
+    return value.replace(/var\(\s*([^,)]+?)(?:\s*,\s*([^)]+))?\s*\)/g, (_match, varName, fallback) => {
+        const resolved = tokenMap[varName.trim()];
+        if (resolved && !resolved.includes('var(')) {
+            // Skip color values — semantic variable names are more useful
+            if (/^#|^rgba?\(|^hsla?\(|^color-mix\(|^oklch\(/.test(resolved)) {
+                return _match;
+            }
+            return resolved;
+        }
+        if (fallback) return fallback.trim();
+        return _match;
+    });
+}
 
 function buildCssCatalog() {
     if (_cssCatalogCache) return _cssCatalogCache;
@@ -203,6 +271,9 @@ function buildCssCatalog() {
         // No course directory — framework-only mode
     }
 
+    // Resolve design tokens so declarations show real values
+    const tokenMap = buildTokenMap();
+
     const categories = {};
     let totalClasses = 0;
 
@@ -218,7 +289,7 @@ function buildCssCatalog() {
             const root = postcss.parse(source, { from: file });
             const classes = {};
 
-            extractClassCatalog(root, classes);
+            extractClassCatalog(root, classes, tokenMap);
 
             if (Object.keys(classes).length > 0) {
                 categories[category] = {
@@ -239,8 +310,9 @@ function buildCssCatalog() {
 /**
  * Extract class names with abbreviated declarations from PostCSS nodes.
  * Walks the AST and builds { className: "shortDescription" } entries.
+ * Token values are resolved so AI sees "1rem" instead of "var(--space-4)".
  */
-function extractClassCatalog(node, classes) {
+function extractClassCatalog(node, classes, tokenMap) {
     if (node.type === 'rule' && node.selector) {
         // Only process simple class selectors (e.g., .foo, .foo-bar)
         // Skip compound selectors, pseudo-classes, nested selectors
@@ -255,11 +327,12 @@ function extractClassCatalog(node, classes) {
             const className = simpleClassMatch[1];
             if (classes[className]) continue; // Already captured
 
-            // Build short description from declarations
+            // Build short description from declarations, resolving token values
             const decls = [];
             node.walk(child => {
                 if (child.type === 'decl') {
-                    decls.push(`${child.prop}: ${child.value}`);
+                    const resolved = resolveVarRefs(`${child.prop}: ${child.value}`, tokenMap);
+                    decls.push(resolved);
                 }
             });
 
@@ -276,34 +349,154 @@ function extractClassCatalog(node, classes) {
     // Recurse into @media, @supports, etc.
     if (node.nodes) {
         for (const child of node.nodes) {
-            extractClassCatalog(child, classes);
+            extractClassCatalog(child, classes, tokenMap);
         }
     }
 }
 
+// Internal categories — framework-managed CSS that authors don't write manually.
+// Filtered from TOC and search by default; always accessible via direct category drill-in.
+const INTERNAL_CATEGORY_PREFIXES = ['interactions/'];
+const INTERNAL_CATEGORIES = new Set([
+    'accessibility',
+    'components/assessments',
+    'components/audio-player',
+    'components/document-gallery',
+    'components/embed-frame',
+    'components/engagement',
+    'components/footer',
+    'components/notifications',
+    'components/sidebar',
+    'components/spinner',
+]);
+
+function isInternalCategory(category) {
+    if (INTERNAL_CATEGORY_PREFIXES.some(p => category.startsWith(p))) return true;
+    return INTERNAL_CATEGORIES.has(category);
+}
+
+// Brief descriptions for each author-facing category.
+// Shown in TOC mode so AI can navigate without drilling into every category.
+const CATEGORY_HINTS = {
+    'layout': 'Columns, splits, stacks, content widths (columns-*, split-*, content-*)',
+    'utilities/spacing': 'Margin (m-*), padding (p-*), gap (gap-*)',
+    'utilities/colors': 'Text (text-*) and background (bg-*) colors',
+    'utilities/typography': 'Font size, weight, line-height, alignment (text-sm, font-bold)',
+    'utilities/display': 'Display mode, overflow, position (d-flex, d-grid, d-none)',
+    'utilities/flexbox': 'Flex direction, alignment, wrapping, gap (flex-row, justify-center)',
+    'utilities/grid': 'CSS Grid columns, rows, spans',
+    'utilities/borders': 'Border width, radius, style (rounded-*, border-*)',
+    'utilities/animations': 'Transitions, entrance animations (fade-in, slide-up)',
+    'utilities/lists': 'List type, spacing, marker styles',
+    'utilities/visibility': 'Show/hide, opacity (visible, hidden, sr-only)',
+    'utilities/icons': 'Icon sizing, colors, alignment in text (icon-sm, icon-primary)',
+    'utilities/decorative': 'Dividers, gradients, shadows, overlays',
+    'utilities/tables': 'Table layout and cell utilities',
+    'utilities/container': 'Container width constraints',
+    'utilities/accessibility-utils': 'Screen reader, focus, skip-link helpers',
+    'components/cards': 'Card containers with headers, bodies, footers (card, card-*)',
+    'components/callouts': 'Info/warning/tip/danger callout boxes (callout, callout-*)',
+    'components/hero': 'Full-width hero banner sections',
+    'components/images': 'Image sizing, grids, rounded, shadow, captions (image-*)',
+    'components/tables': 'Table striping, borders, hover, compact variants',
+    'components/badges': 'Inline badge/label indicators (badge, badge-*)',
+    'components/buttons': 'Button variants and sizes (btn, btn-*)',
+    'components/tabs': 'Tab list and panel styling',
+    'components/accordions': 'Accordion panel structure and states',
+    'components/carousel': 'Carousel slide navigation',
+    'components/breadcrumbs': 'Breadcrumb path navigation',
+    'components/modals': 'Modal dialog overlays',
+    'components/tooltip': 'Hover tooltip styling',
+    'components/flip-cards': 'Front/back flip card containers',
+    'components/slide-header': 'Slide title and subtitle styling',
+    'components/forms': 'Form inputs, labels, validation',
+    'components/toggle': 'Toggle switch controls',
+    'components/checkbox-group': 'Grouped checkbox layouts',
+    'components/dropdown': 'Dropdown select menus',
+    'components/collapse': 'Collapsible content panels',
+    'components/lightbox': 'Fullscreen image viewer',
+    'components/video-player': 'Embedded video player',
+};
+
 /**
- * Get CSS catalog — compact list or full detail for one category.
- * @param {string} [filterCategory] - If provided, return detail for this category only
+ * Get CSS catalog — three access modes:
+ * 1. No args: compact TOC (category names + class counts)
+ * 2. category: full class list with declarations for one category
+ * 3. search: find classes by name across all categories
+ * 
+ * Internal categories (interactions, accessibility, app shell) are hidden by default.
+ * Set includeInternal: true to show them in TOC and search.
+ * Direct category access always works regardless of includeInternal.
+ * 
+ * @param {Object} [options]
+ * @param {string} [options.category] - Return full detail for this category
+ * @param {string} [options.search] - Search class names (substring match)
+ * @param {boolean} [options.includeInternal] - Include framework-internal categories (default: false)
  */
-export function getCssCatalog(filterCategory) {
+export function getCssCatalog({ category, search, includeInternal = false } = {}) {
     const catalog = buildCssCatalog();
 
-    if (filterCategory) {
-        const cat = catalog.categories[filterCategory];
+    // Mode: Category detail — always works, even for internal categories
+    if (category) {
+        const cat = catalog.categories[category];
         if (!cat) {
+            const available = Object.keys(catalog.categories)
+                .filter(c => includeInternal || !isInternalCategory(c))
+                .sort();
             return {
-                error: `Unknown category: '${filterCategory}'`,
-                available: Object.keys(catalog.categories).sort()
+                error: `Unknown category: '${category}'`,
+                available
             };
         }
-        return { category: filterCategory, ...cat };
+        return { category, ...cat };
+    }
+
+    // Mode: Search — case-insensitive substring match on class names
+    if (search) {
+        const query = search.toLowerCase();
+        const results = [];
+        for (const [cat, data] of Object.entries(catalog.categories)) {
+            if (!includeInternal && isInternalCategory(cat)) continue;
+            for (const [cls, declarations] of Object.entries(data.classes)) {
+                if (cls.toLowerCase().includes(query)) {
+                    results.push({ class: cls, category: cat, declarations });
+                }
+            }
+        }
+        const capped = results.length > 50;
+        return {
+            query: search,
+            results: results.slice(0, 50),
+            count: results.length,
+            capped,
+            message: capped
+                ? `Showing 50 of ${results.length} matches. Narrow your search or use 'category' to browse.`
+                : `${results.length} classes matching '${search}'.`
+        };
+    }
+
+    // Mode: TOC — category names, class counts, and hints
+    const categories = {};
+    let totalClasses = 0;
+    let filteredClasses = 0;
+    for (const [cat, data] of Object.entries(catalog.categories)) {
+        const count = Object.keys(data.classes).length;
+        if (!includeInternal && isInternalCategory(cat)) {
+            filteredClasses += count;
+            continue;
+        }
+        const entry = { count };
+        if (CATEGORY_HINTS[cat]) entry.hint = CATEGORY_HINTS[cat];
+        categories[cat] = entry;
+        totalClasses += count;
     }
 
     return {
-        categories: catalog.categories,
-        totalClasses: catalog.totalClasses,
-        categoryCount: Object.keys(catalog.categories).length,
-        message: `${catalog.totalClasses} CSS classes across ${Object.keys(catalog.categories).length} categories. Pass 'category' for full detail.`
+        categories,
+        totalClasses,
+        categoryCount: Object.keys(categories).length,
+        message: `${totalClasses} CSS classes across ${Object.keys(categories).length} categories. Use 'category' for full class list or 'search' to find classes by name.`
+            + (filteredClasses > 0 ? ` (${filteredClasses} internal classes hidden — use includeInternal: true to show)` : '')
     };
 }
 

package/lib/export-content.js

@@ -1139,6 +1139,10 @@ export async function getContentExport(options = {}) {
   const fullCoursePath = validateProject(coursePath, true);
   if (!fullCoursePath) return null;
 
+  // Size guard threshold — prevent unbounded context consumption.
+  // Only applies to full-course exports (no slides filter).
+  const MAX_UNFILTERED_SIZE = 40 * 1024; // 40KB
+
   try {
     const config = await loadCourseConfig(fullCoursePath);
 
@@ -1186,6 +1190,11 @@ export async function getContentExport(options = {}) {
     md += formatBranding(config);
     md += formatFeatures(config);
 
+    // Size guard: if full-course export exceeds threshold, return summary instead
+    if (!slides && md.length > MAX_UNFILTERED_SIZE) {
+      return buildExportSummary(config, structure, fullCoursePath, md.length, exportOptions);
+    }
+
     return md;
   } catch (error) {
     console.error('Failed to generate content export:', error.message);
@@ -1193,6 +1202,49 @@ export async function getContentExport(options = {}) {
   }
 }
 
+/**
+ * Build a compact summary when full export exceeds size threshold.
+ * Returns structure overview + per-slide sizes so AI can scope targeted exports.
+ */
+function buildExportSummary(config, structure, coursePath, totalSize, exportOptions) {
+  const meta = config.metadata || {};
+  let summary = `# ${meta.title || 'Untitled Course'} — Export Summary\n\n`;
+  summary += `> Full export is ${(totalSize / 1024).toFixed(0)}KB — too large for context. Use the \`slides\` parameter to export specific slides.\n\n`;
+
+  summary += '## Course Structure\n\n';
+  summary += generateStructureOverview(structure);
+  summary += '\n\n';
+
+  // Per-slide size estimates
+  summary += '## Slide Sizes\n\n';
+  summary += '| Slide ID | Title | Size |\n';
+  summary += '|----------|-------|------|\n';
+
+  function measureItems(items) {
+    for (const item of items) {
+      if (item.type === 'section') {
+        measureItems(item.children || []);
+      } else {
+        let content = '';
+        if (item.type === 'slide') {
+          content = formatSlide(item, coursePath, exportOptions);
+        } else if (item.type === 'assessment') {
+          content = formatAssessment(item, coursePath, exportOptions);
+        }
+        const sizeKB = (content.length / 1024).toFixed(1);
+        const title = item.title || item.menu?.label || item.id;
+        summary += `| \`${item.id}\` | ${title} | ${sizeKB}KB |\n`;
+      }
+    }
+  }
+
+  measureItems(structure);
+  summary += `\n**Total:** ${(totalSize / 1024).toFixed(0)}KB across all slides\n`;
+  summary += '\nUse `slides: "slide-id-1,slide-id-2"` to export specific slides, or `interactionsOnly: true` for just Q&A.\n';
+
+  return summary;
+}
+
 /**
  * Generate JSON output
  */

package/lib/mcp-prompts.js

@@ -39,6 +39,10 @@ Requires preview server to be running.`,
             type: 'object',
             properties: {},
             required: []
+        },
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
         }
     },
     {
@@ -71,6 +75,9 @@ Requires preview server to be running.`,
                 }
             },
             required: ['slideId']
+        },
+        annotations: {
+            idempotentHint: true
         }
     },
     {
@@ -102,6 +109,9 @@ Requires preview server to be running.`,
                 }
             },
             required: ['interactionId', 'response']
+        },
+        annotations: {
+            destructiveHint: false
         }
     },
     {
@@ -115,6 +125,10 @@ Requires preview server to be running.`,
             type: 'object',
             properties: {},
             required: []
+        },
+        annotations: {
+            destructiveHint: true,
+            idempotentHint: true
         }
     },
     {
@@ -153,6 +167,10 @@ Requires preview server to be running.`,
                 }
             },
             required: []
+        },
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
         }
     },
     {
@@ -188,9 +206,11 @@ Requires preview server to be running.`,
                 }
             },
             required: []
+        },
+        annotations: {
+            idempotentHint: true
         }
     },
-    // --- Workflow & Build Tools ---
     {
         name: 'coursecode_workflow_status',
         description: `Detect the current authoring stage and get stage-specific instructions.
@@ -215,6 +235,10 @@ Call this after completing a major milestone to get updated guidance for the nex
             type: 'object',
             properties: {},
             required: []
+        },
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
         }
     },
     {
@@ -240,27 +264,45 @@ Use in Stage 5 when the course is ready for export.`,
                 }
             },
             required: []
+        },
+        annotations: {
+            idempotentHint: true
         }
     },
-    // --- Catalog & Validation Tools (filesystem, no preview needed) ---
     {
         name: 'coursecode_css_catalog',
-        description: `Get CSS class information extracted from real CSS source files.
+        description: `Browse or search CSS classes available for slide authoring.
 
-Without 'category': returns all classes grouped by category with abbreviated declarations.
-With 'category': returns full detail for that category only.
+Three modes:
+- No args: compact table of contents (category names + class counts)
+- category: full class list with abbreviated declarations for one category
+- search: find classes by name across all categories
 
-Categories are derived from CSS file paths (e.g., "utilities/borders", "layout", "patterns").
-Use to discover available CSS classes before authoring slides. Lint catches invalid classes.`,
+Author-facing categories (layout, utilities, common components) shown by default.
+Framework-internal categories (interactions, accessibility, app shell) hidden — set includeInternal: true to include them.
+
+Use to discover available CSS classes before authoring slides. Lint catches invalid classes with fix suggestions.`,
         inputSchema: {
             type: 'object',
             properties: {
                 category: {
                     type: 'string',
-                    description: 'Optional category to get full details for (e.g., "utilities/colors", "layout", "patterns")'
+                    description: 'Get full class details for this category (e.g., "utilities/spacing", "layout", "components/cards")'
+                },
+                search: {
+                    type: 'string',
+                    description: 'Search class names (e.g., "gap", "card", "text-"). Returns matching classes with declarations.'
+                },
+                includeInternal: {
+                    type: 'boolean',
+                    description: 'Include framework-internal categories (interactions, accessibility, app shell). Default: false.'
                 }
             },
             required: []
+        },
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
         }
     },
     {
@@ -281,6 +323,10 @@ Use to discover available components before authoring slides.`,
                 }
             },
             required: []
+        },
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
         }
     },
     {
@@ -301,20 +347,22 @@ Use to discover available interactions before creating assessments.`,
                 }
             },
             required: []
+        },
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
         }
     },
-
     {
         name: 'coursecode_lint',
         description: `Run the course linter and get structured results.
 
-Always runs build-time lint (config, CSS classes, structure). When the preview server is running and the headless browser is connected, also includes runtime errors from the preview server (same errors shown in coursecode_state and the debug panel Errors tab).
+Always runs build-time lint (config, CSS classes, structure). Does NOT include runtime errors — use coursecode_state for runtime errors and contrast warnings when the preview server is running.
 
 Returns:
-- errors: [{slideId?, rule, message, severity, source?, hint?}]
-- warnings: [{slideId?, rule, message, severity, source?, class?, suggestion?, hint?}]
+- errors: [{slideId?, rule, message, severity, hint?}]
+- warnings: [{slideId?, rule, message, severity, hint?}]
 - passed: boolean
-- runtimeLintIncluded: boolean (true when runtime errors were included)
 
 Build-time rules (always checked):
 - undefined-css-class: hallucinated or stale class names (with fix suggestions)
@@ -325,23 +373,15 @@ Build-time rules (always checked):
 - assessment-id-mismatch: config ID doesn't match assessment ID
 - invalid-gating: bad gating condition configuration
 
-Runtime errors (included when preview is running, source='runtime'):
-- LMS API misuse (GetValue before Initialize, SetValue after Terminate, etc.)
-- Console errors and warnings from the course
-- Uncaught exceptions and unhandled promise rejections
-- Suspend data size warnings
-
-Suppression: Add data-lint-ignore to any HTML element to suppress warnings for it and children.
-  data-lint-ignore           — suppress all warnings
-  data-lint-ignore="spacing" — suppress only spacing warnings
-  data-lint-ignore="spacing,contrast" — suppress multiple categories
-Categories: spacing, contrast, target-size, proximity, overlap, list-style, css-class
-
 Use AFTER making changes to validate the course.`,
         inputSchema: {
             type: 'object',
             properties: {},
             required: []
+        },
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
         }
     },
     {
@@ -361,6 +401,10 @@ Use to discover available icons before authoring slides or configuring menus.`,
                 }
             },
             required: []
+        },
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
         }
     },
     {
@@ -381,6 +425,8 @@ Filtering options keep output manageable:
 - excludeInteractions: content only, no Q&A
 - format: 'md' (default) or 'json' for structured data
 
+For large courses (>40KB), full exports automatically return a summary with per-slide sizes instead. Use the slides parameter to export specific content.
+
 Does not require preview server.`,
         inputSchema: {
             type: 'object',
@@ -416,6 +462,10 @@ Does not require preview server.`,
                 }
             },
             required: []
+        },
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true
         }
     },
 ];

package/lib/mcp-server.js

@@ -105,14 +105,23 @@ export async function startMcpServer(options = {}) {
                             lmsState: api.getLmsState()
                         };
                     });
-                    // Read last 20 API log entries from parent window (stub player diagnostic)
-                    result.apiLog = await headless.evaluateParent(() => {
-                        return window._stubPlayerState?.apiLog?.slice(0, 20) || [];
-                    });
-                    // Read error log from parent window (stub player diagnostic)
-                    result.errors = await headless.evaluateParent(() => {
-                        return window._stubPlayerState?.errorLog || [];
-                    });
+                    // Read API log and error log from preview server (same data user sees in debug panel)
+                    try {
+                        const [logResp, errResp] = await Promise.all([
+                            fetch(`http://localhost:${port}/__lms/log`),
+                            fetch(`http://localhost:${port}/__lms/errors`)
+                        ]);
+                        result.apiLog = logResp.ok ? (await logResp.json()).entries?.slice(0, 20) || [] : [];
+                        if (errResp.ok) {
+                            const errData = await errResp.json();
+                            result.errors = [...(errData.errors || []), ...(errData.warnings || [])];
+                        } else {
+                            result.errors = [];
+                        }
+                    } catch {
+                        result.apiLog = [];
+                        result.errors = [];
+                    }
                     // Append console errors/warnings captured from the page
                     result.consoleLogs = headless.getConsoleLogs();
                     break;
@@ -233,7 +242,7 @@ export async function startMcpServer(options = {}) {
 
                 // === Catalog & validation tools (filesystem, no preview needed) ===
                 case 'coursecode_css_catalog':
-                    result = getCssCatalog(args?.category);
+                    result = getCssCatalog(args || {});
                     break;
 
                 case 'coursecode_component_catalog':
@@ -247,48 +256,6 @@ export async function startMcpServer(options = {}) {
                     break;
                 case 'coursecode_lint':
                     result = await lintCourse();
-                    // Merge runtime errors if headless browser is already connected
-                    if (headless.isRunning()) {
-                        try {
-                            const runtimeErrors = await headless.evaluateParent(() => {
-                                return window._stubPlayerState?.errorLog || [];
-                            });
-                            result.runtimeLintIncluded = true;
-                            if (runtimeErrors.length > 0) {
-                                const runtimeWarnings = runtimeErrors.filter(e => e.isWarning);
-                                const runtimeErrs = runtimeErrors.filter(e => !e.isWarning);
-                                if (runtimeWarnings.length > 0) {
-                                    result.warnings = (result.warnings || []).concat(
-                                        runtimeWarnings.map(e => ({
-                                            severity: 'warning',
-                                            type: e.type,
-                                            message: e.message,
-                                            hint: e.hint,
-                                            rule: 'runtime-error',
-                                            source: 'runtime'
-                                        }))
-                                    );
-                                    result.warningCount = result.warnings.length;
-                                }
-                                if (runtimeErrs.length > 0) {
-                                    result.errors = (result.errors || []).concat(
-                                        runtimeErrs.map(e => ({
-                                            severity: 'error',
-                                            type: e.type,
-                                            message: e.message,
-                                            hint: e.hint,
-                                            rule: 'runtime-error',
-                                            source: 'runtime'
-                                        }))
-                                    );
-                                    result.errorCount = result.errors.length;
-                                    result.passed = result.errors.length === 0;
-                                }
-                            }
-                        } catch {
-                            // Headless browser may have disconnected — non-fatal, build lint still valid
-                        }
-                    }
                     break;
 
                 case 'coursecode_export_content':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coursecode",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "Multi-format course authoring framework with CLI tools (SCORM 2004, SCORM 1.2, cmi5, LTI 1.3)",
   "type": "module",
   "bin": {