chati-dev 1.2.1 → 1.3.2

package/framework/schemas/context.schema.json

@@ -0,0 +1,98 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "chati.dev Context Block",
+  "description": "Schema for <chati-context> XML block structure injected into agent prompts",
+  "type": "object",
+  "required": ["bracket", "constitution", "mode"],
+  "properties": {
+    "bracket": {
+      "enum": ["FRESH", "MODERATE", "DEPLETED", "CRITICAL"],
+      "description": "Current context bracket based on remaining context window"
+    },
+    "constitution": {
+      "type": "string",
+      "description": "Summarized constitution content (always injected, L0 layer)"
+    },
+    "mode": {
+      "enum": ["clarity", "build", "deploy"],
+      "description": "Current execution mode from session state (L1 layer)"
+    },
+    "agent": {
+      "type": "object",
+      "description": "Active agent scope information (L2 layer, active when bracket >= DEPLETED)",
+      "required": ["name", "mission"],
+      "properties": {
+        "name": { "type": "string", "description": "Agent identifier" },
+        "mission": { "type": "string", "description": "One-line agent mission statement" },
+        "inputs": { "type": "string", "description": "Expected inputs for this agent" },
+        "outputs": { "type": "string", "description": "Expected outputs from this agent" },
+        "criteria": { "type": "string", "description": "Success criteria summary" }
+      }
+    },
+    "pipeline": {
+      "type": "string",
+      "description": "Pipeline state string showing agent progression (L3 layer, active when bracket >= MODERATE)"
+    },
+    "task": {
+      "type": "string",
+      "description": "Current task description (L4 layer, active when bracket >= MODERATE)"
+    },
+    "handoff": {
+      "type": "object",
+      "description": "Previous agent handoff summary (L4 layer, active when bracket >= MODERATE)",
+      "properties": {
+        "from": { "type": "string", "description": "Source agent name" },
+        "score": { "type": "number", "minimum": 0, "maximum": 100, "description": "Source agent final score" },
+        "summary": { "type": "string", "description": "Key context from previous agent" }
+      }
+    },
+    "memory": {
+      "type": "object",
+      "description": "Memory injection based on bracket level",
+      "properties": {
+        "bracket": {
+          "enum": ["FRESH", "MODERATE", "DEPLETED", "CRITICAL"],
+          "description": "Memory retrieval bracket (mirrors context bracket)"
+        },
+        "level": {
+          "enum": ["none", "metadata", "chunks", "full"],
+          "description": "Memory retrieval level: none (FRESH), metadata (MODERATE), chunks (DEPLETED), full (CRITICAL)"
+        },
+        "entries": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "id": { "type": "string", "description": "Memory entry identifier" },
+              "title": { "type": "string", "description": "Memory title" },
+              "tier": { "enum": ["hot", "warm", "cold"], "description": "Memory attention tier" },
+              "summary": { "type": "string", "description": "Memory summary (L2 chunks level)" },
+              "content": { "type": "string", "description": "Full memory content (L3 full level)" }
+            }
+          }
+        }
+      }
+    },
+    "token_budget": {
+      "type": "object",
+      "description": "Token usage estimates",
+      "properties": {
+        "estimated_used": { "type": "integer", "minimum": 0, "description": "Estimated tokens used" },
+        "max_context": { "type": "integer", "minimum": 0, "description": "Maximum context window tokens" },
+        "remaining_percent": { "type": "number", "minimum": 0, "maximum": 100, "description": "Percentage of context remaining" },
+        "injection_budget": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Token budget for context injection (FRESH: 2500, MODERATE: 2000, DEPLETED: 1500, CRITICAL: 800)"
+        }
+      }
+    },
+    "active_layers": {
+      "type": "array",
+      "items": {
+        "enum": ["L0", "L1", "L2", "L3", "L4"]
+      },
+      "description": "Currently active injection layers based on bracket"
+    }
+  }
+}

package/framework/schemas/memory.schema.json

@@ -0,0 +1,79 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "chati.dev Memory Entry",
+  "description": "Schema for memory entry YAML frontmatter in .chati/memories/",
+  "type": "object",
+  "required": ["id", "type", "agent", "tags", "confidence", "sector", "tier", "created_at"],
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^mem-\\d{4}-\\d{2}-\\d{2}-\\d{3}$",
+      "description": "Unique memory identifier (mem-YYYY-MM-DD-NNN)"
+    },
+    "type": {
+      "enum": ["decision", "error_pattern", "resolution", "user_correction", "validated_pattern", "gotcha", "lesson"],
+      "description": "Classification of what this memory captures"
+    },
+    "agent": {
+      "type": "string",
+      "description": "Agent that created or owns this memory"
+    },
+    "tags": {
+      "type": "array",
+      "items": { "type": "string" },
+      "minItems": 1,
+      "description": "Searchable tags for similarity matching and retrieval"
+    },
+    "confidence": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1,
+      "description": "System confidence in this memory (0.0-1.0)"
+    },
+    "sector": {
+      "enum": ["episodic", "semantic", "procedural", "reflective"],
+      "description": "Cognitive sector: episodic (what happened), semantic (what we know), procedural (how to do it), reflective (what we learned)"
+    },
+    "tier": {
+      "enum": ["hot", "warm", "cold"],
+      "description": "Attention tier: hot (>0.7, auto-loaded), warm (0.3-0.7, on-demand), cold (<0.3, explicit search)"
+    },
+    "access_count": {
+      "type": "integer",
+      "minimum": 0,
+      "default": 0,
+      "description": "Number of times this memory has been accessed"
+    },
+    "evidence_count": {
+      "type": "integer",
+      "minimum": 0,
+      "default": 0,
+      "description": "Number of corroborating observations"
+    },
+    "last_accessed": {
+      "type": ["string", "null"],
+      "format": "date-time",
+      "description": "Timestamp of last access"
+    },
+    "created_at": {
+      "type": "string",
+      "format": "date-time",
+      "description": "Timestamp of memory creation"
+    },
+    "expires_at": {
+      "type": ["string", "null"],
+      "format": "date-time",
+      "description": "Expiration timestamp (null for durable memories)"
+    },
+    "storage_tier": {
+      "enum": ["session", "daily", "durable"],
+      "default": "daily",
+      "description": "Storage persistence: session (cleaned on restart), daily (archived after 30d), durable (permanent)"
+    },
+    "scope": {
+      "enum": ["shared", "private"],
+      "default": "shared",
+      "description": "Visibility: shared (all agents) or private (owning agent only)"
+    }
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "chati-dev",
-  "version": "1.2.1",
-  "description": "AI-Powered Multi-Agent Development Framework — 13 agents, 6 IDEs, 4 languages",
+  "version": "1.3.2",
+  "description": "AI-Powered Multi-Agent Orchestration System — 13 agents, 6 IDEs, 4 languages",
   "type": "module",
   "bin": {
     "chati": "bin/chati.js",
@@ -19,13 +19,15 @@
     "start": "node bin/chati.js",
     "bundle": "node scripts/bundle-framework.js",
     "prepublishOnly": "node scripts/bundle-framework.js",
-    "test": "node --test"
+    "test": "node --test test/**/*.test.js",
+    "lint": "eslint src/ bin/",
+    "lint:fix": "eslint src/ bin/ --fix"
   },
   "keywords": [
     "ai",
     "agents",
     "development",
-    "framework",
+    "system",
     "planning",
     "multi-agent",
     "cli",
@@ -46,15 +48,20 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",
+    "blessed": "^0.1.81",
     "chalk": "^5.3.0",
-    "ora": "^8.0.1",
     "cli-progress": "^3.12.0",
     "fs-extra": "^11.2.0",
     "js-yaml": "^4.1.0",
-    "semver": "^7.6.0",
-    "blessed": "^0.1.81"
+    "ora": "^8.0.1",
+    "semver": "^7.6.0"
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.0.0",
+    "globals": "^17.3.0"
   }
 }

package/scripts/bundle-framework.js

@@ -35,7 +35,7 @@ const dirs = [
   'agents/clarity', 'agents/quality', 'agents/build', 'agents/deploy',
   'templates', 'workflows', 'quality-gates',
   'schemas', 'frameworks', 'intelligence', 'patterns',
-  'i18n', 'migrations',
+  'i18n', 'migrations', 'data',
 ];
 
 for (const dir of dirs) {

package/src/dashboard/data-reader.js

@@ -1,11 +1,11 @@
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { readFileSync, existsSync, readdirSync } from 'fs';
 import { join } from 'path';
 import yaml from 'js-yaml';
 
 /**
  * Read all dashboard data from project directory
  */
-export function readDashboardData(targetDir) {
+export async function readDashboardData(targetDir) {
   const data = {
     session: null,
     config: null,
@@ -15,6 +15,9 @@ export function readDashboardData(targetDir) {
     recentActivity: [],
     blockers: [],
     gotchas: [],
+    memoryStats: null,
+    contextStatus: null,
+    registryStats: null,
   };
 
   // Read session.yaml
@@ -95,5 +98,27 @@ export function readDashboardData(targetDir) {
     });
   }
 
+  // Intelligence Layer data (graceful degradation)
+  try {
+    const { getMemoryStats } = await import('../intelligence/memory-manager.js');
+    data.memoryStats = getMemoryStats(targetDir);
+  } catch {
+    // Intelligence module not available
+  }
+
+  try {
+    const { getContextStatus } = await import('../intelligence/context-status.js');
+    data.contextStatus = getContextStatus(targetDir);
+  } catch {
+    // Intelligence module not available
+  }
+
+  try {
+    const { getRegistryStats } = await import('../intelligence/registry-manager.js');
+    data.registryStats = getRegistryStats(targetDir);
+  } catch {
+    // Intelligence module not available
+  }
+
   return data;
 }

package/src/dashboard/layout.js

@@ -135,6 +135,27 @@ export function buildValidateSection(data) {
   ];
 }
 
+/**
+ * Build INTELLIGENCE section
+ */
+export function buildIntelligenceSection(data) {
+  const mem = data.memoryStats;
+  const ctx = data.contextStatus;
+  const reg = data.registryStats;
+
+  const memText = mem ? `${mem.total} total (H:${mem.byTier.hot} W:${mem.byTier.warm} C:${mem.byTier.cold})` : gray('N/A');
+  const ctxText = ctx ? `${ctx.bracket} [${ctx.activeLayers.join(',')}]` : gray('N/A');
+  const regText = reg && reg.exists ? `${reg.totalEntities} entities (${reg.countMatch ? green('match') : yellow('mismatch')})` : gray('N/A');
+
+  return [
+    brand('│') + `  ${brand('── INTELLIGENCE')} ${'─'.repeat(41)}` + brand('│'),
+    brand('│') + `  │ ${dim('Memory:')}   ${memText}` + ' '.repeat(Math.max(1, 35 - String(memText).length)) + brand('│'),
+    brand('│') + `  │ ${dim('Context:')}  ${ctxText}` + ' '.repeat(Math.max(1, 35 - String(ctxText).length)) + brand('│'),
+    brand('│') + `  │ ${dim('Registry:')} ${regText}` + ' '.repeat(Math.max(1, 35 - String(regText).length)) + brand('│'),
+    brand('│') + `  ${'─'.repeat(57)}` + brand('│'),
+  ];
+}
+
 /**
  * Build footer with recent activity, blockers, gotchas
  */

package/src/dashboard/renderer.js

@@ -5,6 +5,7 @@ import {
   buildClaritySection,
   buildBuildSection,
   buildValidateSection,
+  buildIntelligenceSection,
   buildFooter,
 } from './layout.js';
 import { dim } from '../utils/colors.js';
@@ -12,8 +13,8 @@ import { dim } from '../utils/colors.js';
 /**
  * Render dashboard once (static mode)
  */
-export function renderDashboard(targetDir) {
-  const data = readDashboardData(targetDir);
+export async function renderDashboard(targetDir) {
+  const data = await readDashboardData(targetDir);
 
   if (!data.session) {
     console.log('No chati.dev session found. Run `npx chati-dev init` first.');
@@ -30,6 +31,8 @@ export function renderDashboard(targetDir) {
     '',
     ...buildValidateSection(data),
     '',
+    ...buildIntelligenceSection(data),
+    '',
     ...buildFooter(data),
   ];
 
@@ -43,16 +46,16 @@ export function renderDashboard(targetDir) {
 /**
  * Render dashboard in watch mode (auto-refresh)
  */
-export function renderDashboardWatch(targetDir, intervalMs = 5000) {
+export async function renderDashboardWatch(targetDir, intervalMs = 5000) {
   // Initial render
   console.clear();
-  renderDashboard(targetDir);
+  await renderDashboard(targetDir);
   console.log(dim(`  Auto-refreshing every ${intervalMs / 1000}s. Press Ctrl+C to exit.`));
 
   // Set up interval
-  const timer = setInterval(() => {
+  const timer = setInterval(async () => {
     console.clear();
-    renderDashboard(targetDir);
+    await renderDashboard(targetDir);
     console.log(dim(`  Auto-refreshing every ${intervalMs / 1000}s. Press Ctrl+C to exit.`));
     console.log(dim(`  Last update: ${new Date().toLocaleTimeString()}`));
   }, intervalMs);
@@ -70,8 +73,8 @@ export function renderDashboardWatch(targetDir, intervalMs = 5000) {
 /**
  * Render plain text fallback (for terminals without TUI support)
  */
-export function renderPlainDashboard(targetDir) {
-  const data = readDashboardData(targetDir);
+export async function renderPlainDashboard(targetDir) {
+  const data = await readDashboardData(targetDir);
 
   if (!data.session) {
     console.log('No chati.dev session found. Run `npx chati-dev init` first.');

package/src/installer/core.js

@@ -1,7 +1,6 @@
-import { mkdirSync, writeFileSync, copyFileSync, existsSync, readFileSync } from 'fs';
+import { mkdirSync, writeFileSync, copyFileSync, existsSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import yaml from 'js-yaml';
 import { IDE_CONFIGS } from '../config/ide-configs.js';
 import { generateClaudeMCPConfig } from '../config/mcp-configs.js';
 import { generateSessionYaml, generateConfigYaml, generateClaudeMd } from './templates.js';
@@ -38,7 +37,7 @@ export async function installFramework(config) {
     'agents/clarity', 'agents/quality', 'agents/build', 'agents/deploy',
     'templates', 'workflows', 'quality-gates',
     'schemas', 'frameworks', 'intelligence', 'patterns',
-    'i18n', 'migrations',
+    'i18n', 'migrations', 'data',
     'artifacts/0-WU', 'artifacts/1-Brief', 'artifacts/2-PRD',
     'artifacts/3-Architecture', 'artifacts/4-UX', 'artifacts/5-Phases',
     'artifacts/6-Tasks', 'artifacts/7-QA-Planning', 'artifacts/8-Validation',
@@ -49,6 +48,27 @@ export async function installFramework(config) {
     createDir(join(frameworkDir, dir));
   }
 
+  // Create .chati/memories/ directory tree for Memory Layer
+  const memoriesBase = join(targetDir, '.chati', 'memories');
+  const memoryDirs = [
+    'shared/durable', 'shared/daily', 'shared/session',
+    'greenfield-wu/durable', 'greenfield-wu/daily',
+    'brownfield-wu/durable', 'brownfield-wu/daily',
+    'brief/durable', 'brief/daily',
+    'detail/durable', 'detail/daily',
+    'architect/durable', 'architect/daily',
+    'ux/durable', 'ux/daily',
+    'phases/durable', 'phases/daily',
+    'tasks/durable', 'tasks/daily',
+    'qa-planning/durable', 'qa-planning/daily',
+    'qa-implementation/durable', 'qa-implementation/daily',
+    'dev/durable', 'dev/daily',
+    'devops/durable', 'devops/daily',
+  ];
+  for (const dir of memoryDirs) {
+    createDir(join(memoriesBase, dir));
+  }
+
   // Copy framework files from source
   copyFrameworkFiles(frameworkDir);
 
@@ -115,6 +135,8 @@ function copyFrameworkFiles(destDir) {
     'schemas/session.schema.json',
     'schemas/config.schema.json',
     'schemas/task.schema.json',
+    'schemas/context.schema.json',
+    'schemas/memory.schema.json',
     // Frameworks
     'frameworks/quality-dimensions.yaml',
     'frameworks/decision-heuristics.yaml',
@@ -122,6 +144,9 @@ function copyFrameworkFiles(destDir) {
     'intelligence/gotchas.yaml',
     'intelligence/patterns.yaml',
     'intelligence/confidence.yaml',
+    'intelligence/context-engine.md',
+    'intelligence/memory-layer.md',
+    'intelligence/decision-engine.md',
     // Patterns
     'patterns/elicitation.md',
     // i18n
@@ -131,6 +156,8 @@ function copyFrameworkFiles(destDir) {
     'i18n/fr.yaml',
     // Migrations
     'migrations/v1.0-to-v1.1.yaml',
+    // Data
+    'data/entity-registry.yaml',
   ];
 
   for (const file of filesToCopy) {
@@ -182,11 +209,11 @@ This is a thin router. All logic lives in the orchestrator.
     }
   } else {
     // For other IDEs, create a rules file pointing to chati.dev/
-    const rulesContent = `# chati.dev Framework Rules
+    const rulesContent = `# chati.dev System Rules
 # This file configures ${config.name} to work with chati.dev
 
-## Framework Location
-All framework content is in the \`chati.dev/\` directory.
+## System Location
+All system content is in the \`chati.dev/\` directory.
 
 ## Session State
 Runtime session state is in \`.chati/session.yaml\` (IDE-agnostic).

package/src/installer/validator.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, readdirSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 
 /**
@@ -13,6 +13,9 @@ export async function validateInstallation(targetDir) {
     schemas: { pass: false, details: [] },
     workflows: { pass: false, details: [] },
     templates: { pass: false, details: [] },
+    intelligence: { pass: false, details: [] },
+    registry: { pass: false, details: [] },
+    memories: { pass: false, details: [] },
     total: 0,
     passed: 0,
   };
@@ -56,7 +59,7 @@ export async function validateInstallation(targetDir) {
   if (existsSync(constitutionPath)) {
     const content = readFileSync(constitutionPath, 'utf-8');
     const articleCount = (content.match(/^## Article/gm) || []).length;
-    results.constitution.pass = articleCount >= 10;
+    results.constitution.pass = articleCount >= 15;
     results.constitution.details.push({ articleCount });
   }
   results.total += 1;
@@ -68,15 +71,18 @@ export async function validateInstallation(targetDir) {
   results.total += 1;
   if (results.session.pass) results.passed += 1;
 
-  // Check schemas
-  const schemaFiles = ['session.schema.json', 'config.schema.json', 'task.schema.json'];
+  // Check schemas (5 total: session, config, task, context, memory)
+  const schemaFiles = [
+    'session.schema.json', 'config.schema.json', 'task.schema.json',
+    'context.schema.json', 'memory.schema.json',
+  ];
   let schemaCount = 0;
   for (const file of schemaFiles) {
     if (existsSync(join(targetDir, 'chati.dev', 'schemas', file))) {
       schemaCount++;
     }
   }
-  results.schemas.pass = schemaCount === 3;
+  results.schemas.pass = schemaCount === 5;
   results.total += 1;
   if (results.schemas.pass) results.passed += 1;
 
@@ -110,5 +116,38 @@ export async function validateInstallation(targetDir) {
   results.total += 1;
   if (results.templates.pass) results.passed += 1;
 
+  // Check intelligence files (6: 3 specs + 3 yaml)
+  const intelligenceFiles = [
+    'intelligence/context-engine.md',
+    'intelligence/memory-layer.md',
+    'intelligence/decision-engine.md',
+    'intelligence/gotchas.yaml',
+    'intelligence/patterns.yaml',
+    'intelligence/confidence.yaml',
+  ];
+  let intelCount = 0;
+  for (const file of intelligenceFiles) {
+    if (existsSync(join(targetDir, 'chati.dev', file))) {
+      intelCount++;
+    }
+  }
+  results.intelligence.pass = intelCount === 6;
+  results.intelligence.details.push({ found: intelCount, expected: 6 });
+  results.total += 1;
+  if (results.intelligence.pass) results.passed += 1;
+
+  // Check entity registry
+  const registryPath = join(targetDir, 'chati.dev', 'data', 'entity-registry.yaml');
+  results.registry.pass = existsSync(registryPath);
+  results.total += 1;
+  if (results.registry.pass) results.passed += 1;
+
+  // Check .chati/memories/ directory tree
+  const memoriesPath = join(targetDir, '.chati', 'memories');
+  const memoriesShared = join(memoriesPath, 'shared', 'durable');
+  results.memories.pass = existsSync(memoriesPath) && existsSync(memoriesShared);
+  results.total += 1;
+  if (results.memories.pass) results.passed += 1;
+
   return results;
 }

package/src/intelligence/context-status.js

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const BRACKETS = [
+  { name: 'FRESH',    min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4'], budget: 2500 },
+  { name: 'MODERATE', min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3', 'L4'], budget: 2000 },
+  { name: 'DEPLETED', min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],             budget: 1500 },
+  { name: 'CRITICAL', min: 0,  max: 25,  layers: ['L0', 'L1'],                   budget: 800 },
+];
+
+/**
+ * Get context status based on session state
+ * (Advisory — actual bracket is calculated at runtime by the orchestrator)
+ */
+export function getContextStatus(targetDir) {
+  const sessionPath = join(targetDir, '.chati', 'session.yaml');
+  if (!existsSync(sessionPath)) {
+    return {
+      bracket: 'FRESH',
+      activeLayers: BRACKETS[0].layers,
+      tokenBudget: BRACKETS[0].budget,
+      memoryLevel: 'none',
+      advisory: 'No active session — default FRESH bracket',
+    };
+  }
+
+  // Read session to determine pipeline state
+  const sessionContent = readFileSync(sessionPath, 'utf-8');
+  const currentAgent = extractYamlValue(sessionContent, 'current_agent');
+  const state = extractYamlValue(sessionContent, 'state');
+
+  // Count completed agents as a rough proxy for context usage
+  const completedCount = (sessionContent.match(/status: completed/g) || []).length;
+  const inProgressCount = (sessionContent.match(/status: in_progress/g) || []).length;
+
+  // Estimate context usage based on pipeline progress
+  // More agents completed = more context consumed
+  const estimatedUsage = Math.min(95, completedCount * 8 + inProgressCount * 5);
+  const remainingPercent = 100 - estimatedUsage;
+
+  const bracket = BRACKETS.find(b => remainingPercent >= b.min && remainingPercent <= b.max) || BRACKETS[0];
+
+  const memoryLevels = { FRESH: 'none', MODERATE: 'metadata', DEPLETED: 'chunks', CRITICAL: 'full' };
+
+  return {
+    bracket: bracket.name,
+    activeLayers: bracket.layers,
+    tokenBudget: bracket.budget,
+    memoryLevel: memoryLevels[bracket.name],
+    remainingPercent,
+    estimatedUsage,
+    currentAgent: currentAgent || 'none',
+    pipelineState: state || 'unknown',
+    completedAgents: completedCount,
+    advisory: `Estimated bracket based on pipeline progress (${completedCount} agents completed)`,
+  };
+}
+
+/**
+ * Estimate context usage for display purposes
+ */
+export function estimateContextUsage(targetDir) {
+  const status = getContextStatus(targetDir);
+  return {
+    bracket: status.bracket,
+    remainingPercent: status.remainingPercent,
+    tokenBudget: status.tokenBudget,
+    layers: status.activeLayers,
+  };
+}
+
+/**
+ * Simple YAML value extractor (avoids js-yaml dependency)
+ */
+function extractYamlValue(content, key) {
+  const regex = new RegExp(`^\\s*${key}:\\s*(.+)$`, 'm');
+  const match = content.match(regex);
+  if (!match) return null;
+  return match[1].trim().replace(/^["']|["']$/g, '');
+}