chati-dev 3.3.2 → 4.0.0

package/src/context/bracket-tracker.js

@@ -2,32 +2,58 @@
  * Bracket Tracker — Pure arithmetic for context window management.
  *
  * Brackets determine how much context to inject:
- *   FRESH    (60-100%) → All 5 layers active
- *   MODERATE (40-60%)  → L0 + L1 + L2 + L3 (skip L4 task detail)
+ *   FRESH    (60-100%) → All 6 layers active (L0-L5)
+ *   MODERATE (40-60%)  → L0 + L1 + L2 + L3 + L5 (skip L4 task detail)
  *   DEPLETED (25-40%)  → L0 + L1 + L2 only
  *   CRITICAL (<25%)    → L0 + L1 only (handoff mandatory)
+ *
+ * Progressive Reinforcement Model (v4.0):
+ *   As context window depletes, the model forgets initial instructions
+ *   and needs MORE reinforcement, not less. Budget expressed as percentage
+ *   of the provider's total context window — proportional across providers.
+ *
+ *   FRESH    = 1.5% → minimal reinforcement (context is plentiful)
+ *   MODERATE = 2.5% → growing reinforcement (model starting to forget)
+ *   DEPLETED = 4.0% → heavy reinforcement (significant context loss)
+ *   CRITICAL = 5.0% → maximum reinforcement (last interactions before handoff)
  */
 
+/** Provider context window limits (tokens). */
+const PROVIDER_LIMITS = {
+  claude: 200_000,
+  gemini: 1_000_000,
+  codex: 128_000,
+};
+
 const BRACKETS = {
-  FRESH:    { min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4'], tokenBudget: 8000 },
-  MODERATE: { min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3'],       tokenBudget: 5000 },
-  DEPLETED: { min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],             tokenBudget: 3000 },
-  CRITICAL: { min: 0,  max: 25,  layers: ['L0', 'L1'],                   tokenBudget: 1500 },
+  FRESH:    { min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4', 'L5'], budgetRatio: 0.015 },
+  MODERATE: { min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3', 'L5'],       budgetRatio: 0.025 },
+  DEPLETED: { min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],                   budgetRatio: 0.040 },
+  CRITICAL: { min: 0,  max: 25,  layers: ['L0', 'L1'],                         budgetRatio: 0.050 },
 };
 
+/**
+ * Memory injection level per bracket.
+ * As context degrades, memory becomes MORE important:
+ *   FRESH    = none     (context abundant, no memory needed)
+ *   MODERATE = metadata (light reminders of relevant memories)
+ *   DEPLETED = chunks   (recovery via memory summaries)
+ *   CRITICAL = full     (full memory dump for handoff continuity)
+ */
 const MEMORY_LEVELS = {
-  FRESH:    'full',
-  MODERATE: 'chunks',
-  DEPLETED: 'metadata',
-  CRITICAL: 'none',
+  FRESH:    'none',
+  MODERATE: 'metadata',
+  DEPLETED: 'chunks',
+  CRITICAL: 'full',
 };
 
 /**
  * Calculate bracket from remaining context percentage.
  * @param {number} remainingPercent - 0 to 100
- * @returns {{ bracket: string, activeLayers: string[], tokenBudget: number, memoryLevel: string, handoffRequired: boolean }}
+ * @param {string} [provider='claude'] - Provider name for context window scaling
+ * @returns {{ bracket: string, activeLayers: string[], tokenBudget: number, budgetRatio: number, memoryLevel: string, handoffRequired: boolean, provider: string }}
  */
-export function calculateBracket(remainingPercent) {
+export function calculateBracket(remainingPercent, provider = 'claude') {
   const pct = Math.max(0, Math.min(100, remainingPercent));
 
   let name = 'CRITICAL';
@@ -36,13 +62,18 @@ export function calculateBracket(remainingPercent) {
   else if (pct >= 25) name = 'DEPLETED';
 
   const def = BRACKETS[name];
+  const providerLimit = PROVIDER_LIMITS[provider] || PROVIDER_LIMITS.claude;
+  const tokenBudget = Math.round(def.budgetRatio * providerLimit);
+
   return {
     bracket: name,
     activeLayers: [...def.layers],
-    tokenBudget: def.tokenBudget,
+    tokenBudget,
+    budgetRatio: def.budgetRatio,
     memoryLevel: MEMORY_LEVELS[name],
     handoffRequired: pct < 15,
     remainingPercent: pct,
+    provider,
   };
 }
 

package/src/context/domain-loader.js

@@ -91,6 +91,28 @@ export function loadGlobalDomain(domainsDir) {
   return result.loaded ? result.data : null;
 }
 
+/**
+ * Load all keyword domain files from chati.dev/domains/keywords/.
+ * @param {string} domainsDir - Path to chati.dev/domains/
+ * @returns {Map<string, object>} Map of topicName → domain data (keywords + rules)
+ */
+export function loadKeywordDomains(domainsDir) {
+  const keywordsDir = join(domainsDir, 'keywords');
+  const domains = new Map();
+
+  if (!existsSync(keywordsDir)) return domains;
+
+  const files = readdirSync(keywordsDir).filter(f => f.endsWith('.yaml'));
+  for (const file of files) {
+    const name = basename(file, '.yaml');
+    const result = loadDomainFile(join(keywordsDir, file));
+    if (result.loaded) {
+      domains.set(name, result.data);
+    }
+  }
+  return domains;
+}
+
 /**
  * Extract rules array from a domain object.
  * Domain files have a `rules` key with an array of rule objects.

package/src/context/engine.js

@@ -1,7 +1,7 @@
 /**
- * PRISM Context Engine — 5-layer context injection pipeline.
+ * PRISM Context Engine — 6-layer context injection pipeline.
  *
- * Orchestrates L0-L4 layers, respects bracket constraints,
+ * Orchestrates L0-L5 layers, respects bracket constraints,
  * and produces formatted XML context for agent prompts.
  *
  * Pipeline: bracket calculation → layer processing → formatting → output
@@ -13,6 +13,7 @@ import { processL1 } from './layers/l1-global.js';
 import { processL2 } from './layers/l2-agent.js';
 import { processL3 } from './layers/l3-workflow.js';
 import { processL4 } from './layers/l4-task.js';
+import { processL5 } from './layers/l5-keywords.js';
 import { formatContext } from './formatter.js';
 
 const LAYER_TIMEOUT_MS = 100;
@@ -31,14 +32,16 @@ const LAYER_TIMEOUT_MS = 100;
  * @param {object} [input.handoff] - Handoff data from previous agent
  * @param {string[]} [input.artifacts] - Relevant artifact paths
  * @param {string[]} [input.taskCriteria] - Active task criteria
+ * @param {string} [input.userPrompt] - User prompt text for L5 keyword matching
+ * @param {string} [input.provider] - CLI provider for context window scaling (claude, gemini, codex)
  * @returns {{ xml: string, bracket: object, layers: object[], errors: string[] }}
  */
 export function runPrism(input) {
   const errors = [];
   const layers = [];
 
-  // 1. Calculate bracket
-  const bracket = calculateBracket(input.remainingPercent);
+  // 1. Calculate bracket (provider-aware for proportional budgets)
+  const bracket = calculateBracket(input.remainingPercent, input.provider || 'claude');
 
   // 2. Build context for layer processors
   const ctx = {
@@ -52,6 +55,7 @@ export function runPrism(input) {
     handoff: input.handoff || {},
     artifacts: input.artifacts || [],
     taskCriteria: input.taskCriteria || [],
+    userPrompt: input.userPrompt || null,
   };
 
   // 3. Process each active layer with timeout protection
@@ -85,6 +89,12 @@ export function runPrism(input) {
     if (l4) { layers.push(l4); layerResults.l4 = l4; }
   }
 
+  // L5 — Keyword recall layer (dynamic rules based on user prompt)
+  if (isLayerActive(bracket.bracket, 'L5') && ctx.userPrompt) {
+    const l5 = safeProcess('L5', () => processL5(ctx), errors);
+    if (l5 && l5.matchCount > 0) { layers.push(l5); layerResults.l5 = l5; }
+  }
+
   // 4. Format output
   const xml = formatContext({
     bracket: bracket.bracket,
@@ -129,9 +139,9 @@ function safeProcess(layerName, processFn, errors) {
 export function getPrismInfo() {
   return {
     name: 'PRISM',
-    version: '1.0.0',
-    layers: 5,
-    layerNames: ['L0 Constitution', 'L1 Global', 'L2 Agent', 'L3 Workflow', 'L4 Task'],
+    version: '1.1.0',
+    layers: 6,
+    layerNames: ['L0 Constitution', 'L1 Global', 'L2 Agent', 'L3 Workflow', 'L4 Task', 'L5 Keywords'],
     brackets: ['FRESH', 'MODERATE', 'DEPLETED', 'CRITICAL'],
     features: [
       'Priority-based context truncation',
@@ -139,6 +149,7 @@ export function getPrismInfo() {
       'Graceful degradation on layer failure',
       'XML structured output',
       'Bracket-aware layer activation',
+      'Provider-aware proportional budgets',
     ],
   };
 }

package/src/context/formatter.js

@@ -15,10 +15,11 @@
  * @param {object} [options.l2] - L2 Agent result
  * @param {object} [options.l3] - L3 Workflow result
  * @param {object} [options.l4] - L4 Task result
+ * @param {object} [options.l5] - L5 Keywords result
  * @returns {string} XML context block
  */
 export function formatContext(options) {
-  const { bracket, tokenBudget, l0, l1, l2, l3, l4 } = options;
+  const { bracket, tokenBudget, l0, l1, l2, l3, l4, l5 } = options;
   const sections = [];
 
   // L0 — Constitution (always present)
@@ -46,6 +47,11 @@ export function formatContext(options) {
     sections.push(formatTask(l4));
   }
 
+  // L5 — Keywords
+  if (l5 && l5.matchCount > 0) {
+    sections.push(formatKeywords(l5));
+  }
+
   let body = sections.join('\n\n');
 
   // Truncate if over budget (rough estimate: 1 token ≈ 4 chars)
@@ -154,6 +160,20 @@ function formatTask(l4) {
   return lines.join('\n');
 }
 
+function formatKeywords(l5) {
+  const lines = [];
+  lines.push(`  <keyword-rules matches="${l5.matchCount}">`);
+  for (const match of l5.matches) {
+    lines.push(`    <topic name="${esc(match.topic)}">`);
+    for (const r of match.rules) {
+      lines.push(`      <rule id="${esc(r.id)}" priority="${esc(r.priority)}">${esc(r.text)}</rule>`);
+    }
+    lines.push(`    </topic>`);
+  }
+  lines.push(`  </keyword-rules>`);
+  return lines.join('\n');
+}
+
 /**
  * Truncate sections by removing lower-priority layers first (L4 → L3 → L2).
  * L0 and L1 are never truncated.

package/src/context/layers/l5-keywords.js

@@ -0,0 +1,53 @@
+/**
+ * L5 Keyword Recall Layer — Dynamic rule injection based on user prompt content.
+ *
+ * Scans the user prompt for topic keywords and loads matching rules from
+ * domains/keywords/*.yaml. This adds the WHAT dimension to PRISM context:
+ *   L0-L4 handle WHO (agent) and WHERE (workflow/task)
+ *   L5 handles WHAT (topic detection from user prompt)
+ *
+ * Only active in FRESH and MODERATE brackets (expensive layer).
+ */
+
+import { loadKeywordDomains } from '../domain-loader.js';
+
+/**
+ * Process L5: scan user prompt for keywords, return matching rules.
+ *
+ * @param {object} ctx - Pipeline context
+ * @param {string} ctx.domainsDir - Path to chati.dev/domains/
+ * @param {string} [ctx.userPrompt] - The user's prompt text to scan for keywords
+ * @returns {{ layer: string, matches: Array<{ topic: string, rules: object[] }>, matchCount: number }}
+ */
+export function processL5(ctx) {
+  const result = {
+    layer: 'L5',
+    matches: [],
+    matchCount: 0,
+  };
+
+  if (!ctx.userPrompt || !ctx.domainsDir) {
+    return result;
+  }
+
+  const promptLower = ctx.userPrompt.toLowerCase();
+  const keywordDomains = loadKeywordDomains(ctx.domainsDir);
+
+  for (const [topic, domain] of keywordDomains) {
+    const keywords = domain.keywords || [];
+    const matched = keywords.some(kw => promptLower.includes(kw.toLowerCase()));
+
+    if (matched) {
+      const rules = (domain.rules || []).map(r => ({
+        id: r.id || `${topic}-unknown`,
+        text: r.text || '',
+        priority: r.priority || 'normal',
+      }));
+
+      result.matches.push({ topic, rules });
+      result.matchCount += rules.length;
+    }
+  }
+
+  return result;
+}

package/src/intelligence/context-status.js

@@ -1,16 +1,23 @@
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 
+/** Provider context window limits (tokens). */
+const PROVIDER_LIMITS = {
+  claude: 200_000,
+  gemini: 1_000_000,
+  codex: 128_000,
+};
+
 const BRACKETS = [
-  { name: 'FRESH',    min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4'], budget: 8000 },
-  { name: 'MODERATE', min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3'],       budget: 5000 },
-  { name: 'DEPLETED', min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],             budget: 3000 },
-  { name: 'CRITICAL', min: 0,  max: 25,  layers: ['L0', 'L1'],                   budget: 1500 },
+  { name: 'FRESH',    min: 60, max: 100, layers: ['L0', 'L1', 'L2', 'L3', 'L4', 'L5'], budgetRatio: 0.015 },
+  { name: 'MODERATE', min: 40, max: 60,  layers: ['L0', 'L1', 'L2', 'L3', 'L5'],       budgetRatio: 0.025 },
+  { name: 'DEPLETED', min: 25, max: 40,  layers: ['L0', 'L1', 'L2'],                   budgetRatio: 0.040 },
+  { name: 'CRITICAL', min: 0,  max: 25,  layers: ['L0', 'L1'],                         budgetRatio: 0.050 },
 ];
 // NOTE: This BRACKETS array is intentionally duplicated from src/context/bracket-tracker.js
 // for module isolation. bracket-tracker.js is the canonical source of truth.
-// If bracket ranges or budgets change, update BOTH files.
-// Format differs: here = array with `budget`, there = object with `tokenBudget`.
+// Progressive Reinforcement Model (v4.0): budgets as ratio of provider context window.
+// If bracket ranges or ratios change, update BOTH files.
 
 /**
  * Get context status based on session state
@@ -19,10 +26,12 @@ const BRACKETS = [
 export function getContextStatus(targetDir) {
   const sessionPath = join(targetDir, '.chati', 'session.yaml');
   if (!existsSync(sessionPath)) {
+    const providerLimit = PROVIDER_LIMITS.claude;
     return {
       bracket: 'FRESH',
       activeLayers: BRACKETS[0].layers,
-      tokenBudget: BRACKETS[0].budget,
+      tokenBudget: Math.round(BRACKETS[0].budgetRatio * providerLimit),
+      budgetRatio: BRACKETS[0].budgetRatio,
       memoryLevel: 'none',
       advisory: 'No active session — default FRESH bracket',
     };
@@ -44,12 +53,14 @@ export function getContextStatus(targetDir) {
 
   const bracket = BRACKETS.find(b => remainingPercent >= b.min && remainingPercent <= b.max) || BRACKETS[0];
 
-  const memoryLevels = { FRESH: 'full', MODERATE: 'chunks', DEPLETED: 'metadata', CRITICAL: 'none' };
+  const memoryLevels = { FRESH: 'none', MODERATE: 'metadata', DEPLETED: 'chunks', CRITICAL: 'full' };
+  const providerLimit = PROVIDER_LIMITS.claude;
 
   return {
     bracket: bracket.name,
     activeLayers: bracket.layers,
-    tokenBudget: bracket.budget,
+    tokenBudget: Math.round(bracket.budgetRatio * providerLimit),
+    budgetRatio: bracket.budgetRatio,
     memoryLevel: memoryLevels[bracket.name],
     remainingPercent,
     estimatedUsage,

package/src/intelligence/decision-engine.js

@@ -0,0 +1,253 @@
+/**
+ * IDS Decision Engine — Intelligent Deduplication & Similarity scoring.
+ *
+ * Before creating any new artifact, scores existing registry entities
+ * for similarity. Enforces Constitution Article XIV: REUSE > ADAPT > CREATE.
+ *
+ * Algorithm:
+ *   similarity = (keywordOverlap * 0.6) + (purposeSimilarity * 0.4)
+ *   >= 90% → REUSE, 60-89% → ADAPT, < 60% → CREATE
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * @typedef {object} DecisionIntent
+ * @property {string[]} keywords - Keywords describing what we want to create
+ * @property {string} purpose - One-line description of the intended artifact
+ */
+
+/**
+ * @typedef {object} DecisionResult
+ * @property {string} decision - 'REUSE' | 'ADAPT' | 'CREATE'
+ * @property {string|null} matchId - The best matching entity ID (null for CREATE)
+ * @property {number} similarity - 0-100 similarity score
+ * @property {string} reasoning - Human-readable explanation
+ * @property {object|null} match - The best matching entity data
+ */
+
+/**
+ * Evaluate a creation intent against the entity registry.
+ *
+ * @param {DecisionIntent} intent - What we want to create
+ * @param {string} registryPath - Absolute path to entity-registry.yaml
+ * @returns {DecisionResult}
+ */
+export function evaluateDecision(intent, registryPath) {
+  if (!intent || !intent.keywords || !intent.purpose) {
+    return {
+      decision: 'CREATE',
+      matchId: null,
+      similarity: 0,
+      reasoning: 'No intent provided, defaulting to CREATE.',
+      match: null,
+    };
+  }
+
+  const entities = loadRegistryEntities(registryPath);
+  if (entities.length === 0) {
+    return {
+      decision: 'CREATE',
+      matchId: null,
+      similarity: 0,
+      reasoning: 'Registry empty or not found, defaulting to CREATE.',
+      match: null,
+    };
+  }
+
+  let bestMatch = null;
+  let bestScore = 0;
+  let bestId = null;
+
+  for (const entity of entities) {
+    const score = calculateSimilarity(intent, entity);
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = entity;
+      bestId = entity.id;
+    }
+  }
+
+  const similarity = Math.round(bestScore * 100);
+  let decision;
+  let reasoning;
+
+  if (similarity >= 90) {
+    decision = 'REUSE';
+    reasoning = `Entity "${bestId}" is ${similarity}% similar. Reuse as-is (Article XIV).`;
+  } else if (similarity >= 60) {
+    decision = 'ADAPT';
+    reasoning = `Entity "${bestId}" is ${similarity}% similar. Adapt for current needs (adaptability: ${bestMatch?.adaptability ?? 'unknown'}).`;
+  } else {
+    decision = 'CREATE';
+    reasoning = bestId
+      ? `Best match "${bestId}" is only ${similarity}% similar. Create new artifact.`
+      : 'No sufficiently similar entity found. Create new artifact.';
+  }
+
+  return {
+    decision,
+    matchId: similarity >= 60 ? bestId : null,
+    similarity,
+    reasoning,
+    match: similarity >= 60 ? bestMatch : null,
+  };
+}
+
+/**
+ * Calculate combined similarity between an intent and an entity.
+ *
+ * similarity = (keywordOverlap * 0.6) + (purposeSimilarity * 0.4)
+ *
+ * @param {DecisionIntent} intent
+ * @param {{ keywords: string[], purpose: string }} entity
+ * @returns {number} 0.0 to 1.0
+ */
+export function calculateSimilarity(intent, entity) {
+  const kwScore = keywordOverlap(intent.keywords, entity.keywords || []);
+  const purposeScore = purposeSimilarity(intent.purpose, entity.purpose || '');
+  return (kwScore * 0.6) + (purposeScore * 0.4);
+}
+
+/**
+ * Calculate keyword overlap using token-based Jaccard similarity.
+ *
+ * @param {string[]} a - Intent keywords
+ * @param {string[]} b - Entity keywords
+ * @returns {number} 0.0 to 1.0
+ */
+export function keywordOverlap(a, b) {
+  if (!a || !b || a.length === 0 || b.length === 0) return 0;
+
+  const setA = new Set(a.map(k => k.toLowerCase().trim()));
+  const setB = new Set(b.map(k => k.toLowerCase().trim()));
+
+  let intersection = 0;
+  for (const k of setA) {
+    if (setB.has(k)) intersection++;
+  }
+
+  const union = new Set([...setA, ...setB]).size;
+  return union === 0 ? 0 : intersection / union;
+}
+
+/**
+ * Calculate purpose similarity using token overlap (bag-of-words).
+ *
+ * @param {string} a - Intent purpose
+ * @param {string} b - Entity purpose
+ * @returns {number} 0.0 to 1.0
+ */
+export function purposeSimilarity(a, b) {
+  if (!a || !b) return 0;
+
+  const tokenize = (text) => {
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\s]/g, '')
+      .split(/\s+/)
+      .filter(t => t.length > 2); // Skip tiny words
+  };
+
+  const tokensA = new Set(tokenize(a));
+  const tokensB = new Set(tokenize(b));
+
+  if (tokensA.size === 0 || tokensB.size === 0) return 0;
+
+  let intersection = 0;
+  for (const t of tokensA) {
+    if (tokensB.has(t)) intersection++;
+  }
+
+  const union = new Set([...tokensA, ...tokensB]).size;
+  return union === 0 ? 0 : intersection / union;
+}
+
+/**
+ * Load and flatten entity registry into a searchable array.
+ *
+ * @param {string} registryPath - Absolute path to entity-registry.yaml
+ * @returns {Array<{ id: string, keywords: string[], purpose: string, path: string, type: string, adaptability: number }>}
+ */
+export function loadRegistryEntities(registryPath) {
+  if (!registryPath || !existsSync(registryPath)) return [];
+
+  try {
+    const raw = readFileSync(registryPath, 'utf-8');
+    return parseRegistryEntities(raw);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Parse registry YAML into flat entity array.
+ * Uses simple regex parsing consistent with the codebase pattern.
+ *
+ * @param {string} raw - Raw YAML content
+ * @returns {Array<{ id: string, keywords: string[], purpose: string, path: string, type: string, adaptability: number }>}
+ */
+export function parseRegistryEntities(raw) {
+  const entities = [];
+  const lines = raw.split('\n');
+
+  let currentCategory = null;
+  let currentEntity = null;
+  let currentData = {};
+
+  for (const line of lines) {
+    // Category header (agents:, templates:, etc.) — 2-space indent under entities:
+    const categoryMatch = line.match(/^  (\w[\w-]*):\s*$/);
+    if (categoryMatch && !line.match(/^\s{4}/)) {
+      // Save previous entity
+      if (currentEntity && currentData.purpose) {
+        entities.push({ id: `${currentCategory}/${currentEntity}`, ...currentData });
+      }
+      currentCategory = categoryMatch[1];
+      currentEntity = null;
+      currentData = {};
+      continue;
+    }
+
+    // Entity header (e.g., "    orchestrator:") — 4-space indent
+    const entityMatch = line.match(/^    ([\w][\w-]*):\s*$/);
+    if (entityMatch) {
+      // Save previous entity
+      if (currentEntity && currentData.purpose) {
+        entities.push({ id: `${currentCategory}/${currentEntity}`, ...currentData });
+      }
+      currentEntity = entityMatch[1];
+      currentData = { keywords: [], purpose: '', path: '', type: '', adaptability: 0.5 };
+      continue;
+    }
+
+    if (!currentEntity) continue;
+
+    // Entity fields (6-space indent)
+    const pathMatch = line.match(/^\s{6}path:\s*(.+)/);
+    if (pathMatch) { currentData.path = pathMatch[1].trim(); continue; }
+
+    const typeMatch = line.match(/^\s{6}type:\s*(.+)/);
+    if (typeMatch) { currentData.type = typeMatch[1].trim(); continue; }
+
+    const purposeMatch = line.match(/^\s{6}purpose:\s*"?([^"]*)"?\s*$/);
+    if (purposeMatch) { currentData.purpose = purposeMatch[1].trim(); continue; }
+
+    const adaptMatch = line.match(/^\s{6}adaptability:\s*([\d.]+)/);
+    if (adaptMatch) { currentData.adaptability = parseFloat(adaptMatch[1]); continue; }
+
+    const kwMatch = line.match(/^\s{6}keywords:\s*\[(.+)\]/);
+    if (kwMatch) {
+      currentData.keywords = kwMatch[1].split(',').map(k => k.trim().replace(/^['"]|['"]$/g, ''));
+      continue;
+    }
+  }
+
+  // Save last entity
+  if (currentEntity && currentData.purpose) {
+    entities.push({ id: `${currentCategory}/${currentEntity}`, ...currentData });
+  }
+
+  return entities;
+}