@massu/core 0.7.0 → 0.8.1

package/src/hooks/classify-failure.ts

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 Massu. All rights reserved.
+// Licensed under BSL 1.1 - see LICENSE file for details.
+
+// ============================================================
+// PostToolUse Hook: Failure Classification
+// Classifies bug fixes against known failure patterns before
+// demanding the full incident loop. Prevents rule bloat by
+// recognizing known patterns vs genuinely novel failures.
+//
+// Part of the Auto-Learning Pipeline:
+//   [Fix Detected] → [CLASSIFY] → Incident Report → Rule → Enforcement
+//
+// Classification:
+//   SCORE >= known threshold  → KNOWN   — Reference existing rules, no new deliverables
+//   SCORE >= similar threshold → SIMILAR — Check existing rules first
+//   SCORE < similar threshold  → NEW     — Full incident loop mandatory
+//
+// Triggers on: Edit|Write to code files
+// Must complete in <1000ms.
+// ============================================================
+
+import { existsSync, readFileSync, readdirSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join, basename } from 'path';
+import { getProjectRoot, getConfig } from '../config.ts';
+import { getMemoryDb, scoreFailureClasses } from '../memory-db.ts';
+
+interface HookInput {
+  session_id: string;
+  tool_name: string;
+  tool_input: {
+    file_path?: string;
+    old_string?: string;
+    new_string?: string;
+    content?: string;
+  };
+}
+
+// Bug fix detection heuristics
+const BUG_FIX_INDICATORS = [
+  /\b(catch|error|throw|fail|fix|bug|broken|missing|crash|wrong|typo|incorrect)\b/i,
+];
+
+const CODE_EXTENSIONS = /\.(ts|tsx|js|jsx|py|swift|rs|go|rb|sh)$/;
+
+function getDedupeMarkerPath(sessionId: string, filePath: string): string {
+  // One reminder per file per calendar day
+  const day = new Date().toISOString().slice(0, 10);
+  const hash = simpleHash(filePath);
+  return join(tmpdir(), `massu-classify-${day}-${sessionId.slice(0, 8)}-${hash}`);
+}
+
+function simpleHash(str: string): string {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    h = ((h << 5) - h + str.charCodeAt(i)) | 0;
+  }
+  return Math.abs(h).toString(36);
+}
+
+function readFailureContextFiles(): string {
+  const dir = tmpdir();
+  let context = '';
+  try {
+    const files = readdirSync(dir).filter(f => f.startsWith('massu-failure-context-'));
+    for (const file of files) {
+      try {
+        context += ' ' + readFileSync(join(dir, file), 'utf-8');
+      } catch { /* ignore */ }
+    }
+  } catch { /* ignore */ }
+  return context.trim();
+}
+
+function cleanupFailureContextFiles(): void {
+  const dir = tmpdir();
+  try {
+    const files = readdirSync(dir).filter(f => f.startsWith('massu-failure-context-'));
+    for (const file of files) {
+      try { unlinkSync(join(dir, file)); } catch { /* ignore */ }
+    }
+  } catch { /* ignore */ }
+}
+
+async function main(): Promise<void> {
+  try {
+    const input = await readStdin();
+    const hookInput = JSON.parse(input) as HookInput;
+    const filePath = hookInput.tool_input?.file_path;
+
+    if (!filePath) {
+      process.exit(0);
+      return;
+    }
+
+    const config = getConfig();
+
+    // Check if feature is enabled
+    if (config.autoLearning?.enabled === false ||
+        config.autoLearning?.failureClassification?.enabled === false) {
+      process.exit(0);
+      return;
+    }
+
+    // Only check code files
+    if (!CODE_EXTENSIONS.test(filePath)) {
+      process.exit(0);
+      return;
+    }
+
+    // Skip incident/memory/doc files (those are pipeline output)
+    const root = getProjectRoot();
+    const incidentDir = config.autoLearning?.incidentDir ?? 'docs/incidents';
+    const memoryDir = config.autoLearning?.memoryDir ?? 'memory';
+    const relPath = filePath.startsWith(root + '/') ? filePath.slice(root.length + 1) : filePath;
+    if (relPath.startsWith(incidentDir) || relPath.includes(memoryDir) || relPath.includes('MEMORY.md')) {
+      process.exit(0);
+      return;
+    }
+
+    // Detect if this edit looks like a bug fix
+    const oldString = hookInput.tool_input?.old_string ?? '';
+    const newString = hookInput.tool_input?.new_string ?? '';
+    const content = hookInput.tool_input?.content ?? '';
+    const matchText = `${oldString} ${newString} ${content}`;
+
+    let isBugFix = false;
+
+    // Check for failure context markers (from UserPromptSubmit)
+    const promptContext = readFailureContextFiles();
+    if (promptContext) {
+      isBugFix = true;
+    }
+
+    // Check for bug fix indicators in the edit text
+    if (!isBugFix) {
+      for (const pattern of BUG_FIX_INDICATORS) {
+        if (pattern.test(matchText)) {
+          isBugFix = true;
+          break;
+        }
+      }
+    }
+
+    // Check for column/key name changes (common fix pattern)
+    if (!isBugFix && oldString && newString) {
+      const oldKeys = oldString.match(/[a-z_]+:/g)?.sort().join(',');
+      const newKeys = newString.match(/[a-z_]+:/g)?.sort().join(',');
+      if (oldKeys && newKeys && oldKeys !== newKeys) {
+        isBugFix = true;
+      }
+    }
+
+    if (!isBugFix) {
+      process.exit(0);
+      return;
+    }
+
+    // De-duplicate: skip if already reminded for this file today
+    const dedupeMarker = getDedupeMarkerPath(hookInput.session_id, filePath);
+    if (existsSync(dedupeMarker)) {
+      process.exit(0);
+      return;
+    }
+
+    // Mark that we've classified this file
+    try {
+      require('fs').writeFileSync(dedupeMarker, '1');
+    } catch { /* ignore */ }
+
+    // Score against failure taxonomy in database
+    const db = getMemoryDb();
+    try {
+      const scoringConfig = config.autoLearning?.failureClassification?.scoring;
+      const thresholds = config.autoLearning?.failureClassification?.thresholds ?? { known: 5, similar: 3 };
+      const bestMatch = scoreFailureClasses(db, matchText, filePath, promptContext, scoringConfig);
+
+      if (!bestMatch || bestMatch.score === 0) {
+        // No taxonomy entries yet, or no match — full enforcement
+        outputNewPattern(basename(filePath), bestMatch);
+      } else if (bestMatch.score >= thresholds.known) {
+        outputKnownPattern(bestMatch);
+      } else if (bestMatch.score >= thresholds.similar) {
+        outputSimilarPattern(bestMatch);
+      } else {
+        outputNewPattern(basename(filePath), bestMatch);
+      }
+    } finally {
+      db.close();
+    }
+
+    // Clean up consumed context files to prevent cross-bug contamination
+    cleanupFailureContextFiles();
+  } catch {
+    // Best-effort: never block Claude Code
+  }
+  process.exit(0);
+}
+
+function outputKnownPattern(match: FailureClassMatch): void {
+  const lines: string[] = [];
+  lines.push('');
+  lines.push(`[KNOWN PATTERN] ${match.name} (score: ${match.score}, ${match.incidentCount} prior incident(s))`);
+  if (match.knownMessage) {
+    lines.push(`  ${match.knownMessage}`);
+  }
+  if (match.rules.length > 0) {
+    lines.push(`  Covered by: ${match.rules.join(', ')}`);
+  }
+  lines.push('  No new rules needed. Reference existing incident if logging.');
+  console.log(lines.join('\n'));
+}
+
+function outputSimilarPattern(match: FailureClassMatch): void {
+  const lines: string[] = [];
+  lines.push('');
+  lines.push(`[POSSIBLE MATCH] Resembles ${match.name} (score: ${match.score})`);
+  if (match.rules.length > 0) {
+    lines.push(`  Check if existing rules cover this case: ${match.rules.join(', ')}`);
+  }
+  lines.push('  If genuinely new: create incident + prevention rule + enforcement.');
+  console.log(lines.join('\n'));
+}
+
+function outputNewPattern(fileName: string, match: FailureClassMatch | null): void {
+  const lines: string[] = [];
+  lines.push('');
+  if (match && match.score > 0) {
+    lines.push(`[NEW PATTERN] No known failure class matches this fix in ${fileName} (best: ${match.name}, score: ${match.score}).`);
+  } else {
+    lines.push(`[NEW PATTERN] Bug fix detected in ${fileName} — no failure classes in taxonomy yet.`);
+  }
+  lines.push('  Full incident loop required:');
+  lines.push('    1. INCIDENT REPORT');
+  lines.push('    2. PREVENTION RULE (if new failure pattern)');
+  lines.push('    3. ENFORCEMENT (hook or static check)');
+  console.log(lines.join('\n'));
+}
+
+interface FailureClassMatch {
+  name: string;
+  score: number;
+  incidentCount: number;
+  rules: string[];
+  knownMessage: string;
+}
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk: string) => { data += chunk; });
+    process.stdin.on('end', () => resolve(data));
+    setTimeout(() => resolve(data), 3000);
+  });
+}
+
+main();

package/src/hooks/incident-pipeline.ts

@@ -17,6 +17,7 @@
 import { existsSync, readFileSync, readdirSync } from 'fs';
 import { basename, dirname, resolve } from 'path';
 import { getProjectRoot, getConfig } from '../config.ts';
+import { getMemoryDb, scoreFailureClasses, appendIncidentToFailureClass, addFailureClass } from '../memory-db.ts';
 
 interface HookInput {
   session_id: string;
@@ -129,6 +130,47 @@ async function main(): Promise<void> {
     lines.push('');
 
     console.log(lines.join('\n'));
+
+    // ============================================================
+    // Taxonomy Update: Score incident against failure classes
+    // If KNOWN match → append incident to existing class
+    // If NEW → create stub entry with needs_review=true
+    // ============================================================
+    try {
+      const taxonomyConfig = config.autoLearning?.failureClassification;
+      if (taxonomyConfig?.enabled !== false) {
+        const db = getMemoryDb();
+        try {
+          const thresholds = taxonomyConfig?.thresholds ?? { known: 5, similar: 3 };
+          const scoringWeights = taxonomyConfig?.scoring;
+
+          // Extract incident number from filename (e.g., "incident-042.md" → "42")
+          const incidentNumMatch = basename(filePath, '.md').match(/(\d+)/);
+          const incidentId = incidentNumMatch ? incidentNumMatch[1] : basename(filePath, '.md');
+
+          // Score incident content against taxonomy
+          const bestMatch = scoreFailureClasses(db, content, filePath, title, scoringWeights);
+
+          if (bestMatch && bestMatch.score >= thresholds.similar) {
+            // Known or similar — append incident to existing class
+            appendIncidentToFailureClass(db, bestMatch.name, incidentId);
+          } else {
+            // New pattern — create stub entry for review
+            const stubName = `auto_${slug.replace(/[^a-z0-9_]/g, '_').slice(0, 50)}`;
+            addFailureClass(db, {
+              name: stubName,
+              description: `Auto-created from incident ${incidentId}: ${title.slice(0, 100)}`,
+              incidents: [incidentId],
+              needsReview: true,
+            });
+          }
+        } finally {
+          db.close();
+        }
+      }
+    } catch {
+      // Best-effort: taxonomy update failure must not block the pipeline
+    }
   } catch {
     // Best-effort: never block Claude Code
   }

package/src/hooks/rule-enforcement-pipeline.ts

@@ -55,7 +55,8 @@ async function main(): Promise<void> {
     }
 
     // Must be in a memory-like directory
-    if (!relPath.includes(memoryDir) && !relPath.includes('memory/') && !relPath.includes('.claude/')) {
+    const claudeDir = config.conventions?.claudeDirName ?? '.claude';
+    if (!relPath.includes(memoryDir) && !relPath.includes('memory/') && !relPath.includes(claudeDir + '/')) {
       process.exit(0);
       return;
     }

package/src/hooks/session-start.ts

@@ -52,7 +52,7 @@ async function main(): Promise<void> {
         process.stdout.write(
           '=== MASSU AI: Active ===\n' +
           'Session memory, code intelligence, and governance are now active.\n' +
-          `11 hooks monitoring this session. Type "${getConfig().toolPrefix ?? 'massu'}_sync" to index your codebase.\n` +
+          `15 hooks monitoring this session. Type "${getConfig().toolPrefix ?? 'massu'}_sync" to index your codebase.\n` +
           '=== END MASSU ===\n\n'
         );
       }

package/src/hooks/user-prompt.ts

@@ -8,7 +8,9 @@
 // ============================================================
 
 import { getMemoryDb, createSession, addUserPrompt, linkSessionToTask, autoDetectTaskId, addObservation } from '../memory-db.ts';
-import { existsSync } from 'fs';
+import { existsSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
 import { getResolvedPaths } from '../config.ts';
 
 interface HookInput {
@@ -107,6 +109,24 @@ async function main(): Promise<void> {
       } catch (_memoryNagErr) {
         // Best-effort: never block prompt capture
       }
+
+      // 7. Failure context markers: write detected failure keywords to temp file
+      //    so classify-failure.ts can use them for scoring
+      try {
+        const failureKeywords = [
+          'bug', 'broken', 'crash', 'error', 'fail', 'fix', 'wrong', 'missing',
+          'undefined', 'null', 'exception', 'stack trace', 'regression', 'revert',
+          'doesn\'t work', 'not working', 'stopped working', 'broke',
+        ];
+        const promptLower = prompt.toLowerCase();
+        const matched = failureKeywords.filter(kw => promptLower.includes(kw));
+        if (matched.length > 0) {
+          const contextFile = join(tmpdir(), `massu-failure-context-${session_id.slice(0, 8)}-${Date.now()}`);
+          writeFileSync(contextFile, matched.join(' '), 'utf-8');
+        }
+      } catch {
+        // Best-effort: never block prompt capture
+      }
     } finally {
       db.close();
     }

package/src/license.ts

@@ -54,7 +54,7 @@ export function tierLevel(tier: ToolTier): number {
  * Enterprise: audit, security, dependency
  */
 export const TOOL_TIER_MAP: Record<string, ToolTier> = {
-  // --- Free tier (12 tools: core navigation + basic memory + regression + license) ---
+  // --- Free tier (13 tools: core navigation + basic memory + regression + license) ---
   sync: 'free',
   context: 'free',
   impact: 'free',
@@ -64,6 +64,7 @@ export const TOOL_TIER_MAP: Record<string, ToolTier> = {
   coupling_check: 'free',
   memory_search: 'free',
   memory_ingest: 'free',
+  memory_backfill: 'free',
   regression_risk: 'free',
   feature_health: 'free',
   license_status: 'free',

package/src/mcp-bridge-tools.ts

@@ -50,7 +50,6 @@ process.on('exit', () => {
 });
 process.on('SIGTERM', () => {
   for (const [name] of connections) disconnectServer(name);
-  process.exit(0);
 });
 
 // Environment variables safe to forward to MCP subprocesses.
@@ -68,7 +67,7 @@ const ENV_DENY_PATTERNS = [
 function buildSubprocessEnv(): Record<string, string> {
   const env: Record<string, string> = {};
   // Derive safe env prefixes from the project name in massu.config.yaml.
-  // e.g., project name "hedge" -> allow HEDGE_CONFIG_, HEDGE_LOG_ etc.
+  // e.g., project name "myapp" -> allow MYAPP_CONFIG_, MYAPP_LOG_ etc.
   // This makes the bridge work for any Massu user's project without hardcoding.
   const projectName = getConfig().project?.name?.toUpperCase() || '';
   const safePrefixes = projectName

package/src/memory-db.ts

@@ -587,6 +587,29 @@ export function initMemorySchema(db: Database.Database): void {
       features TEXT DEFAULT '[]'
     );
   `);
+
+  // ============================================================
+  // Failure Classification: Taxonomy of known failure patterns
+  // ============================================================
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS failure_classes (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      description TEXT NOT NULL,
+      diff_patterns TEXT NOT NULL DEFAULT '[]',
+      file_patterns TEXT NOT NULL DEFAULT '[]',
+      prompt_keywords TEXT NOT NULL DEFAULT '[]',
+      incidents TEXT NOT NULL DEFAULT '[]',
+      rules TEXT NOT NULL DEFAULT '[]',
+      scanner_checks TEXT NOT NULL DEFAULT '[]',
+      known_message TEXT NOT NULL DEFAULT '',
+      needs_review INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_fc_name ON failure_classes(name);
+    CREATE INDEX IF NOT EXISTS idx_fc_needs_review ON failure_classes(needs_review);
+  `);
 }
 
 // ============================================================
@@ -1387,3 +1410,181 @@ export function getObservabilityDbSize(db: Database.Database): {
     estimated_size_mb: Math.round((pageCount * pageSize) / (1024 * 1024) * 100) / 100,
   };
 }
+
+// ============================================================
+// Failure Classification: CRUD functions
+// ============================================================
+
+export interface FailureClass {
+  id: number;
+  name: string;
+  description: string;
+  diff_patterns: string[];
+  file_patterns: string[];
+  prompt_keywords: string[];
+  incidents: string[];
+  rules: string[];
+  scanner_checks: string[];
+  known_message: string;
+  needs_review: boolean;
+}
+
+export interface AddFailureClassOpts {
+  name: string;
+  description: string;
+  diffPatterns?: string[];
+  filePatterns?: string[];
+  promptKeywords?: string[];
+  incidents?: string[];
+  rules?: string[];
+  scannerChecks?: string[];
+  knownMessage?: string;
+  needsReview?: boolean;
+}
+
+/**
+ * Add a new failure class to the taxonomy.
+ */
+export function addFailureClass(db: Database.Database, opts: AddFailureClassOpts): number {
+  const result = db.prepare(`
+    INSERT OR IGNORE INTO failure_classes (name, description, diff_patterns, file_patterns, prompt_keywords, incidents, rules, scanner_checks, known_message, needs_review)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    opts.name,
+    opts.description,
+    JSON.stringify(opts.diffPatterns ?? []),
+    JSON.stringify(opts.filePatterns ?? []),
+    JSON.stringify(opts.promptKeywords ?? []),
+    JSON.stringify(opts.incidents ?? []),
+    JSON.stringify(opts.rules ?? []),
+    JSON.stringify(opts.scannerChecks ?? []),
+    opts.knownMessage ?? '',
+    opts.needsReview ? 1 : 0
+  );
+  return Number(result.lastInsertRowid);
+}
+
+/**
+ * Get all failure classes from the taxonomy.
+ */
+export function getFailureClasses(db: Database.Database): FailureClass[] {
+  const rows = db.prepare('SELECT * FROM failure_classes ORDER BY name').all() as Array<Record<string, unknown>>;
+  return rows.map(row => ({
+    id: row.id as number,
+    name: row.name as string,
+    description: row.description as string,
+    diff_patterns: JSON.parse((row.diff_patterns as string) || '[]'),
+    file_patterns: JSON.parse((row.file_patterns as string) || '[]'),
+    prompt_keywords: JSON.parse((row.prompt_keywords as string) || '[]'),
+    incidents: JSON.parse((row.incidents as string) || '[]'),
+    rules: JSON.parse((row.rules as string) || '[]'),
+    scanner_checks: JSON.parse((row.scanner_checks as string) || '[]'),
+    known_message: row.known_message as string,
+    needs_review: !!(row.needs_review as number),
+  }));
+}
+
+/**
+ * Append an incident identifier to an existing failure class.
+ */
+export function appendIncidentToFailureClass(db: Database.Database, className: string, incidentId: string): void {
+  const row = db.prepare('SELECT incidents FROM failure_classes WHERE name = ?').get(className) as { incidents: string } | undefined;
+  if (!row) return;
+  const incidents: string[] = JSON.parse(row.incidents || '[]');
+  if (!incidents.includes(incidentId)) {
+    incidents.push(incidentId);
+    db.prepare('UPDATE failure_classes SET incidents = ?, updated_at = datetime(\'now\') WHERE name = ?')
+      .run(JSON.stringify(incidents), className);
+  }
+}
+
+export interface FailureClassMatch {
+  name: string;
+  score: number;
+  incidentCount: number;
+  rules: string[];
+  knownMessage: string;
+}
+
+/**
+ * Score all failure classes against provided match text, file path, and prompt context.
+ * Returns the best match with its score.
+ *
+ * Scoring:
+ *   +diffPatternWeight (default 3) per diff_pattern match
+ *   +filePatternWeight (default 2) per file_pattern match
+ *   +promptKeywordWeight (default 2) per prompt_keyword match
+ */
+export function scoreFailureClasses(
+  db: Database.Database,
+  matchText: string,
+  filePath: string,
+  promptContext: string,
+  weights?: { diffPatternWeight?: number; filePatternWeight?: number; promptKeywordWeight?: number }
+): FailureClassMatch | null {
+  const classes = getFailureClasses(db);
+  if (classes.length === 0) return null;
+
+  const diffWeight = weights?.diffPatternWeight ?? 3;
+  const fileWeight = weights?.filePatternWeight ?? 2;
+  const promptWeight = weights?.promptKeywordWeight ?? 2;
+
+  let bestMatch: FailureClassMatch | null = null;
+
+  for (const fc of classes) {
+    let score = 0;
+
+    for (const pattern of fc.diff_patterns) {
+      if (!pattern) continue;
+      try {
+        if (new RegExp(pattern, 'i').test(matchText)) {
+          score += diffWeight;
+        }
+      } catch {
+        if (matchText.toLowerCase().includes(pattern.toLowerCase())) {
+          score += diffWeight;
+        }
+      }
+    }
+
+    for (const pattern of fc.file_patterns) {
+      if (!pattern) continue;
+      try {
+        if (new RegExp(pattern).test(filePath)) {
+          score += fileWeight;
+        }
+      } catch {
+        if (filePath.includes(pattern)) {
+          score += fileWeight;
+        }
+      }
+    }
+
+    if (promptContext) {
+      for (const keyword of fc.prompt_keywords) {
+        if (!keyword) continue;
+        try {
+          if (new RegExp(keyword, 'i').test(promptContext)) {
+            score += promptWeight;
+          }
+        } catch {
+          if (promptContext.toLowerCase().includes(keyword.toLowerCase())) {
+            score += promptWeight;
+          }
+        }
+      }
+    }
+
+    if (!bestMatch || score > bestMatch.score) {
+      bestMatch = {
+        name: fc.name,
+        score,
+        incidentCount: fc.incidents.length,
+        rules: fc.rules,
+        knownMessage: fc.known_message,
+      };
+    }
+  }
+
+  return bestMatch;
+}

package/src/memory-file-ingest.ts

@@ -11,7 +11,6 @@
 import type Database from 'better-sqlite3';
 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { join } from 'path';
-import { parse as parseYaml } from 'yaml';
 import { addObservation } from './memory-db.ts';
 
 export type IngestResult = 'inserted' | 'updated' | 'skipped';
@@ -42,13 +41,21 @@ export function ingestMemoryFile(
 
   if (frontmatterMatch) {
     try {
-      const fm = parseYaml(frontmatterMatch[1]) as Record<string, unknown>;
-      name = (fm.name as string) ?? basename;
-      description = (fm.description as string) ?? '';
-      type = (fm.type as string) ?? 'discovery';
+      // Simple key: value parser for memory file frontmatter
+      // (avoids importing yaml library — frontmatter is flat key-value pairs)
+      const fm: Record<string, string> = {};
+      for (const line of frontmatterMatch[1].split('\n')) {
+        const sep = line.indexOf(':');
+        if (sep > 0) {
+          fm[line.slice(0, sep).trim()] = line.slice(sep + 1).trim();
+        }
+      }
+      name = fm.name ?? basename;
+      description = fm.description ?? '';
+      type = fm.type ?? 'discovery';
       confidence = fm.confidence != null ? Number(fm.confidence) : undefined;
     } catch {
-      // Use defaults if YAML parsing fails
+      // Use defaults if frontmatter parsing fails
     }
   }