@holoscript/framework 6.0.3 → 6.0.4

package/src/knowledge/knowledge-consolidator.ts

@@ -94,8 +94,8 @@ export interface ConsolidatorConfig {
 }
 
 const DEFAULT_CONFIG: ConsolidatorConfig = {
-  warmDemoteAfterMs: 6 * 60 * 60 * 1000,   // 6 hours
-  coldDemoteAfterMs: 48 * 60 * 60 * 1000,  // 48 hours
+  warmDemoteAfterMs: 6 * 60 * 60 * 1000, // 6 hours
+  coldDemoteAfterMs: 48 * 60 * 60 * 1000, // 48 hours
   hotCapacity: 100,
   warmCapacity: 500,
 };
@@ -127,14 +127,16 @@ export class KnowledgeConsolidator {
         ...entry,
         tier: 'hot',
         tierChangedAt: Date.now(),
-        provenanceChain: [{
-          entryId: entry.id,
-          agentId: entry.authorAgent,
-          timestamp: new Date(entry.createdAt).getTime(),
-          action: 'created',
-          parentEntryId: undefined,
-          hash: entry.provenanceHash,
-        }],
+        provenanceChain: [
+          {
+            entryId: entry.id,
+            agentId: entry.authorAgent,
+            timestamp: new Date(entry.createdAt).getTime(),
+            action: 'created',
+            parentEntryId: undefined,
+            hash: entry.provenanceHash,
+          },
+        ],
       };
       this.tiers.set(entry.id, tiered);
       imported++;
@@ -153,14 +155,16 @@ export class KnowledgeConsolidator {
       ...entry,
       tier: 'hot',
       tierChangedAt: Date.now(),
-      provenanceChain: [{
-        entryId: entry.id,
-        agentId: entry.authorAgent,
-        timestamp: new Date(entry.createdAt).getTime(),
-        action: 'created',
-        parentEntryId,
-        hash: entry.provenanceHash,
-      }],
+      provenanceChain: [
+        {
+          entryId: entry.id,
+          agentId: entry.authorAgent,
+          timestamp: new Date(entry.createdAt).getTime(),
+          action: 'created',
+          parentEntryId,
+          hash: entry.provenanceHash,
+        },
+      ],
     };
     this.tiers.set(entry.id, tiered);
     return tiered;
@@ -176,7 +180,7 @@ export class KnowledgeConsolidator {
   sleepCycle(): ConsolidationStats {
     const now = Date.now();
     let demoted = 0;
-    let evicted = 0;
+    const evicted = 0;
 
     for (const entry of this.tiers.values()) {
       const lastActivity = Math.max(
@@ -295,15 +299,40 @@ export class KnowledgeConsolidator {
    */
   surfaceCrossDomainPatterns(domains?: string[]): CrossDomainPattern[] {
     const entries = domains
-      ? Array.from(this.tiers.values()).filter(e => domains.includes(e.domain))
+      ? Array.from(this.tiers.values()).filter((e) => domains.includes(e.domain))
       : Array.from(this.tiers.values());
 
     // Extract keyword → domain+entry mapping
     const keywordMap = new Map<string, Array<{ id: string; domain: string; snippet: string }>>();
     const STOP_WORDS = new Set([
-      'the', 'and', 'for', 'that', 'this', 'with', 'from', 'are', 'was', 'were',
-      'not', 'but', 'have', 'has', 'had', 'will', 'would', 'could', 'should',
-      'can', 'may', 'its', 'all', 'each', 'any', 'use', 'used', 'using',
+      'the',
+      'and',
+      'for',
+      'that',
+      'this',
+      'with',
+      'from',
+      'are',
+      'was',
+      'were',
+      'not',
+      'but',
+      'have',
+      'has',
+      'had',
+      'will',
+      'would',
+      'could',
+      'should',
+      'can',
+      'may',
+      'its',
+      'all',
+      'each',
+      'any',
+      'use',
+      'used',
+      'using',
     ]);
 
     for (const entry of entries) {
@@ -311,7 +340,7 @@ export class KnowledgeConsolidator {
         .toLowerCase()
         .replace(/[^a-z0-9\s-]/g, '')
         .split(/\s+/)
-        .filter(w => w.length > 3 && !STOP_WORDS.has(w));
+        .filter((w) => w.length > 3 && !STOP_WORDS.has(w));
 
       // Use unique words per entry
       const unique = [...new Set(words)];
@@ -328,7 +357,7 @@ export class KnowledgeConsolidator {
     // Find keywords that span multiple domains
     const patterns: CrossDomainPattern[] = [];
     for (const [keyword, refs] of keywordMap) {
-      const uniqueDomains = [...new Set(refs.map(r => r.domain))];
+      const uniqueDomains = [...new Set(refs.map((r) => r.domain))];
       if (uniqueDomains.length >= 2) {
         patterns.push({
           pattern: keyword,
@@ -340,8 +369,7 @@ export class KnowledgeConsolidator {
     }
 
     // Sort by strength (most entries), then by domain count
-    return patterns
-      .sort((a, b) => b.domains.length - a.domains.length || b.strength - a.strength);
+    return patterns.sort((a, b) => b.domains.length - a.domains.length || b.strength - a.strength);
   }
 
   // ── Contradiction Detection ──
@@ -381,7 +409,7 @@ export class KnowledgeConsolidator {
         .toLowerCase()
         .replace(/[^a-z0-9\s]/g, '')
         .split(/\s+/)
-        .filter(w => w.length > 4);
+        .filter((w) => w.length > 4);
       const unique = [...new Set(words)];
       for (const w of unique) {
         if (!keywordIndex.has(w)) keywordIndex.set(w, []);
@@ -464,7 +492,7 @@ export class KnowledgeConsolidator {
   // ── Inspection ──
 
   getByTier(tier: KnowledgeTier): TieredEntry[] {
-    return Array.from(this.tiers.values()).filter(e => e.tier === tier);
+    return Array.from(this.tiers.values()).filter((e) => e.tier === tier);
   }
 
   getEntry(id: string): TieredEntry | undefined {
@@ -476,7 +504,9 @@ export class KnowledgeConsolidator {
   }
 
   stats(): { hot: number; warm: number; cold: number; total: number } {
-    let hot = 0, warm = 0, cold = 0;
+    let hot = 0,
+      warm = 0,
+      cold = 0;
     for (const entry of this.tiers.values()) {
       if (entry.tier === 'hot') hot++;
       else if (entry.tier === 'warm') warm++;

package/src/knowledge/knowledge-store.ts

@@ -12,7 +12,11 @@ import type { KnowledgeConfig, KnowledgeInsight } from '../types';
 import { applyHalfLifeDecay, computeExcitability } from './brain';
 import type { KnowledgeDomain, ExcitabilityMetadata } from './brain';
 import { KnowledgeMarketplace } from '../economy/KnowledgeMarketplace';
-import type { KnowledgeListing, PurchaseResult, ListingResult } from '../economy/KnowledgeMarketplace';
+import type {
+  KnowledgeListing,
+  PurchaseResult,
+  ListingResult,
+} from '../economy/KnowledgeMarketplace';
 
 export interface StoredEntry extends KnowledgeInsight {
   id: string;
@@ -61,17 +65,28 @@ export class KnowledgeStore {
 
   /** Publish a knowledge entry. Deduplicates by normalized content. */
   publish(
-    insight: KnowledgeInsight, 
-    authorAgent: string, 
+    insight: KnowledgeInsight,
+    authorAgent: string,
     provenance?: { taskId?: string; cycleId?: string; verifierId?: string; provenanceHash?: string }
   ): StoredEntry {
     const prefix = insight.type === 'wisdom' ? 'W' : insight.type === 'pattern' ? 'P' : 'G';
-    const domain = insight.domain.toUpperCase().replace(/[^A-Z0-9]/g, '').slice(0, 8);
+    const domain = insight.domain
+      .toUpperCase()
+      .replace(/[^A-Z0-9]/g, '')
+      .slice(0, 8);
     const id = `${prefix}.${domain}.${String(this.nextId++).padStart(3, '0')}`;
 
-    const norm = insight.content.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().slice(0, 100);
+    const norm = insight.content
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, ' ')
+      .trim()
+      .slice(0, 100);
     for (const existing of this.entries.values()) {
-      const existingNorm = existing.content.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim().slice(0, 100);
+      const existingNorm = existing.content
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .trim()
+        .slice(0, 100);
       if (existingNorm === norm) return existing;
     }
 
@@ -94,7 +109,10 @@ export class KnowledgeStore {
 
   /** Search entries by keyword with excitability + half-life decay ranking. */
   search(query: string, limit = 10): StoredEntry[] {
-    const keywords = query.toLowerCase().split(/\s+/).filter(w => w.length > 2);
+    const keywords = query
+      .toLowerCase()
+      .split(/\s+/)
+      .filter((w) => w.length > 2);
     if (keywords.length === 0) return this.recent(limit);
 
     const now = Date.now();
@@ -136,7 +154,7 @@ export class KnowledgeStore {
     return scored
       .sort((a, b) => b.score - a.score)
       .slice(0, limit)
-      .map(s => s.entry);
+      .map((s) => s.entry);
   }
 
   /** Search remote knowledge store (MCP Orchestrator). */
@@ -153,8 +171,8 @@ export class KnowledgeStore {
         signal: AbortSignal.timeout(10_000),
       });
       if (!res.ok) return [];
-      const data = await res.json() as Array<Record<string, unknown>>;
-      return (Array.isArray(data) ? data : []).map(e => this.mapRemoteEntry(e));
+      const data = (await res.json()) as Array<Record<string, unknown>>;
+      return (Array.isArray(data) ? data : []).map((e) => this.mapRemoteEntry(e));
     } catch {
       return [];
     }
@@ -163,19 +181,19 @@ export class KnowledgeStore {
   /** Sync local entries to remote knowledge store. */
   async syncToRemote(): Promise<number> {
     if (!this.config.remoteUrl || !this.config.remoteApiKey) return 0;
-    const entries = this.all().map(e => ({
+    const entries = this.all().map((e) => ({
       id: e.id,
       workspace_id: 'ai-ecosystem',
       type: e.type,
       content: e.content,
       provenanceHash: e.provenanceHash || '',
-      metadata: { 
-        domain: e.domain, 
-        confidence: e.confidence, 
+      metadata: {
+        domain: e.domain,
+        confidence: e.confidence,
         source: e.authorAgent,
         taskId: e.taskId,
         cycleId: e.cycleId,
-        verifierId: e.verifierId
+        verifierId: e.verifierId,
       },
     }));
     if (entries.length === 0) return 0;
@@ -190,7 +208,7 @@ export class KnowledgeStore {
         signal: AbortSignal.timeout(15_000),
       });
       if (!res.ok) return 0;
-      const data = await res.json() as { synced?: number };
+      const data = (await res.json()) as { synced?: number };
       return data.synced ?? entries.length;
     } catch {
       return 0;
@@ -224,21 +242,23 @@ export class KnowledgeStore {
     try {
       const payload = {
         workspace_id: 'ai-ecosystem',
-        entries: [{
-          id: entry.id,
-          workspace_id: 'ai-ecosystem',
-          type: entry.type,
-          content: entry.content,
-          provenanceHash: entry.provenanceHash || '',
-          metadata: {
-            domain: entry.domain,
-            confidence: entry.confidence,
-            source: entry.authorAgent,
-            taskId: entry.taskId,
-            cycleId: entry.cycleId,
-            verifierId: entry.verifierId,
+        entries: [
+          {
+            id: entry.id,
+            workspace_id: 'ai-ecosystem',
+            type: entry.type,
+            content: entry.content,
+            provenanceHash: entry.provenanceHash || '',
+            metadata: {
+              domain: entry.domain,
+              confidence: entry.confidence,
+              source: entry.authorAgent,
+              taskId: entry.taskId,
+              cycleId: entry.cycleId,
+              verifierId: entry.verifierId,
+            },
           },
-        }],
+        ],
       };
 
       const res = await fetch(`${this.config.remoteUrl}/knowledge/sync`, {
@@ -255,7 +275,7 @@ export class KnowledgeStore {
         return { entryId: entry.id, synced: false };
       }
 
-      const data = await res.json() as { synced?: number; ids?: string[] };
+      const data = (await res.json()) as { synced?: number; ids?: string[] };
       return {
         entryId: entry.id,
         synced: (data.synced ?? 0) > 0,
@@ -302,12 +322,14 @@ export class KnowledgeStore {
         });
 
         if (res.ok) {
-          const data = await res.json() as Array<Record<string, unknown>>;
-          remoteResults = (Array.isArray(data) ? data : []).map(e => this.mapRemoteEntry(e));
+          const data = (await res.json()) as Array<Record<string, unknown>>;
+          remoteResults = (Array.isArray(data) ? data : []).map((e) => this.mapRemoteEntry(e));
 
           // Apply confidence filter
           if (options?.minConfidence !== undefined) {
-            remoteResults = remoteResults.filter(e => e.confidence >= (options.minConfidence ?? 0));
+            remoteResults = remoteResults.filter(
+              (e) => e.confidence >= (options.minConfidence ?? 0)
+            );
           }
         }
       } catch {
@@ -362,10 +384,18 @@ export class KnowledgeStore {
       reuseCount: Number(e.reuseCount || 0),
       createdAt: String(e.createdAt || new Date().toISOString()),
       authorAgent: String(e.authorName || meta.source || 'remote'),
-      taskId: e.taskId ? String(e.taskId) : (meta.taskId ? String(meta.taskId) : undefined),
-      cycleId: e.cycleId ? String(e.cycleId) : (meta.cycleId ? String(meta.cycleId) : undefined),
-      verifierId: e.verifierId ? String(e.verifierId) : (meta.verifierId ? String(meta.verifierId) : undefined),
-      provenanceHash: e.provenanceHash ? String(e.provenanceHash) : (meta.provenanceHash ? String(meta.provenanceHash) : undefined),
+      taskId: e.taskId ? String(e.taskId) : meta.taskId ? String(meta.taskId) : undefined,
+      cycleId: e.cycleId ? String(e.cycleId) : meta.cycleId ? String(meta.cycleId) : undefined,
+      verifierId: e.verifierId
+        ? String(e.verifierId)
+        : meta.verifierId
+          ? String(meta.verifierId)
+          : undefined,
+      provenanceHash: e.provenanceHash
+        ? String(e.provenanceHash)
+        : meta.provenanceHash
+          ? String(meta.provenanceHash)
+          : undefined,
     };
   }
 
@@ -376,12 +406,12 @@ export class KnowledgeStore {
   }
 
   byType(type: 'wisdom' | 'pattern' | 'gotcha'): StoredEntry[] {
-    return Array.from(this.entries.values()).filter(e => e.type === type);
+    return Array.from(this.entries.values()).filter((e) => e.type === type);
   }
 
   byDomain(domain: string): StoredEntry[] {
     const d = domain.toLowerCase();
-    return Array.from(this.entries.values()).filter(e => e.domain.toLowerCase() === d);
+    return Array.from(this.entries.values()).filter((e) => e.domain.toLowerCase() === d);
   }
 
   markReused(id: string): void {
@@ -489,7 +519,7 @@ export class KnowledgeStore {
         const updated = [...existing, ...archived];
         fs.writeFileSync(archivePath, JSON.stringify(updated, null, 2), 'utf8');
         // Remove from hot buffer
-        archived.forEach(e => this.entries.delete(e.id));
+        archived.forEach((e) => this.entries.delete(e.id));
       } catch {
         // Cold store unavailable; keep in hot buffer
       }
@@ -508,7 +538,10 @@ export class KnowledgeStore {
       const fs = require('fs') as typeof import('fs');
       if (!fs.existsSync(archivePath)) return [];
       const archived = JSON.parse(fs.readFileSync(archivePath, 'utf8')) as StoredEntry[];
-      const keywords = query.toLowerCase().split(/\s+/).filter(w => w.length > 2);
+      const keywords = query
+        .toLowerCase()
+        .split(/\s+/)
+        .filter((w) => w.length > 2);
 
       const restored: StoredEntry[] = [];
       for (const entry of archived) {
@@ -525,7 +558,7 @@ export class KnowledgeStore {
 
       // Update cold store (remove restored)
       if (restored.length > 0) {
-        const remaining = archived.filter(e => !restored.find(r => r.id === e.id));
+        const remaining = archived.filter((e) => !restored.find((r) => r.id === e.id));
         fs.writeFileSync(archivePath, JSON.stringify(remaining, null, 2), 'utf8');
       }
 
@@ -554,7 +587,7 @@ export class KnowledgeStore {
    * Evict: Permanently remove an entry from both hot and cold stores.
    * Called during cleanup or when an entry is marked as stale/wrong.
    */
-  evict(id: string, archivePath?: string): boolean {
+  evict(id: string, _archivePath?: string): boolean {
     const existed = this.entries.delete(id);
     if (existed) {
       this.persistIfEnabled();
@@ -593,7 +626,12 @@ export class KnowledgeStore {
   }
 
   /** List a knowledge entry for sale on the marketplace. */
-  listForSale(id: string, seller: string, price?: number, currency?: 'USDC' | 'credits'): ListingResult {
+  listForSale(
+    id: string,
+    seller: string,
+    price?: number,
+    currency?: 'USDC' | 'credits'
+  ): ListingResult {
     const entry = this.entries.get(id);
     if (!entry) return { success: false, listingId: '', error: 'Entry not found' };
     const finalPrice = price ?? this.marketplace.priceKnowledge(entry);

package/src/learning/ProceduralCompiler.ts

@@ -1,4 +1,9 @@
-export interface ProceduralSkill { id: string; name: string; description?: string; code?: string; }
+export interface ProceduralSkill {
+  id: string;
+  name: string;
+  description?: string;
+  code?: string;
+}
 
 /**
  * ProceduralCompiler

package/src/learning/learning/MemoryConsolidator.ts

@@ -0,0 +1,102 @@
+import { logger } from '../logger';
+
+export interface EpisodicMemory {
+  id: string;
+  timestamp: number;
+  action: string;
+  outcome: string;
+  entitiesInvolved: string[];
+  semanticVector?: number[]; // Mock embedding
+}
+
+export interface SemanticFact {
+  id: string;
+  fact: string;
+  confidence: number;
+  sourceEpisodes: string[];
+}
+
+/**
+ * MemoryConsolidator
+ *
+ * Compresses raw episodic events into structured semantic facts
+ * via idle background cycles, mirroring human sleep consolidation.
+ */
+export class MemoryConsolidator {
+  /**
+   * Identifies conceptually similar episodic memories based on shared entities and actions.
+   */
+  private static clusterEpisodes(episodes: EpisodicMemory[]): EpisodicMemory[][] {
+    const clusters: Record<string, EpisodicMemory[]> = {};
+
+    // Basic heuristic: Cluster by primary action and first entity
+    for (const ep of episodes) {
+      const key = `${ep.action}_${ep.entitiesInvolved[0] || 'generic'}`;
+      if (!clusters[key]) clusters[key] = [];
+      clusters[key].push(ep);
+    }
+
+    return Object.values(clusters);
+  }
+
+  /**
+   * Mocks an LLM-based summarization pass converting a cluster of raw events
+   * into a single concrete semantic truth.
+   */
+  private static summarizeCluster(cluster: EpisodicMemory[]): SemanticFact | null {
+    if (cluster.length < 3) return null; // Only consolidate recurring patterns
+
+    const sample = cluster[0];
+    const successCount = cluster.filter((ep) => ep.outcome.includes('success')).length;
+    const successRate = successCount / cluster.length;
+
+    let rule = '';
+    if (successRate > 0.7) {
+      rule = `${sample.action} applied to ${sample.entitiesInvolved[0]} is generally effective.`;
+    } else {
+      rule = `${sample.action} applied to ${sample.entitiesInvolved[0]} has high failure risk.`;
+    }
+
+    return {
+      id: `fact_${Date.now()}_${Math.random().toString(36).substring(7)}`,
+      fact: rule,
+      confidence: successRate,
+      sourceEpisodes: cluster.map((c) => c.id),
+    };
+  }
+
+  /**
+   * Executes the background consolidation pass.
+   * Takes raw episodes, clusters them, extracts truths, and returns the facts
+   * while reporting which raw episodes can be safely garbage collected.
+   */
+  static compressEpisodes(rawEpisodes: EpisodicMemory[]): {
+    newFacts: SemanticFact[];
+    prunedEpisodes: string[];
+  } {
+    if (rawEpisodes.length < 5) return { newFacts: [], prunedEpisodes: [] };
+
+    logger.info(
+      `[Consolidation] Running idle memory compression on ${rawEpisodes.length} episodes.`
+    );
+
+    const clusters = this.clusterEpisodes(rawEpisodes);
+    const newFacts: SemanticFact[] = [];
+    const prunedEpisodes: string[] = [];
+
+    for (const cluster of clusters) {
+      const fact = this.summarizeCluster(cluster);
+      if (fact) {
+        newFacts.push(fact);
+        // Mark these source episodes for pruning since we extracted the semantic truth
+        prunedEpisodes.push(...fact.sourceEpisodes);
+      }
+    }
+
+    logger.info(
+      `[Consolidation] Distilled ${prunedEpisodes.length} raw episodes into ${newFacts.length} semantic facts.`
+    );
+
+    return { newFacts, prunedEpisodes };
+  }
+}

package/src/learning/learning/MemoryScorer.ts

@@ -0,0 +1,69 @@
+/**
+ * MemoryScorer
+ *
+ * Generates an 'importance' dimensional scalar for Episodic memories.
+ * Allows the aggregation engine to aggressively prune trivial loops (like 'Idle')
+ * and permanently archive high-value bounds (like 'Combat' or 'Crafting').
+ */
+
+export interface EpisodicEvent {
+  agentId: string;
+  timestamp: number;
+  action: string;
+  context: Record<string, any>;
+  outcome: string;
+}
+
+export class MemoryScorer {
+  /**
+   * Scores an event from -100 (Absolute Noise) to 100 (Critical Experience).
+   */
+  static computeImportance(event: EpisodicEvent): number {
+    let score = 0;
+
+    // 1. Action Density Weighting
+    const action = event.action.toLowerCase();
+    if (action.includes('idle') || action.includes('wait') || action.includes('sleep')) {
+      score -= 50;
+    } else if (action.includes('move') || action.includes('look') || action.includes('walk')) {
+      score -= 10;
+    } else if (action.includes('craft') || action.includes('build') || action.includes('analyze')) {
+      score += 30;
+    } else if (
+      action.includes('combat') ||
+      action.includes('attack') ||
+      action.includes('defense') ||
+      action.includes('damage')
+    ) {
+      score += 50;
+    }
+
+    // 2. Context Entropy (More complex context = higher density value)
+    const contextKeys = Object.keys(event.context || {}).length;
+    score += Math.min(20, contextKeys * 2);
+
+    // 3. Outcome Variance (Is the outcome signifying a concrete change?)
+    const outcome = event.outcome.toLowerCase();
+    if (outcome.includes('failed') || outcome.includes('error')) {
+      score += 25; // Agent failures are important for negative reinforcement
+    } else if (
+      outcome.includes('success') ||
+      outcome.includes('crafted') ||
+      outcome.includes('killed')
+    ) {
+      score += 25; // Major achievements are important for positive reinforcement
+    } else if (outcome.includes('nothing') || outcome.includes('none')) {
+      score -= 20; // Zero variance
+    }
+
+    // Clamp between -100 and 100
+    return Math.max(-100, Math.min(100, score));
+  }
+
+  /**
+   * Filters arrays natively discarding negative arrays
+   */
+  static cullLowImportance(events: EpisodicEvent[], threshold: number = 0): EpisodicEvent[] {
+    return events.filter((e) => this.computeImportance(e) >= threshold);
+  }
+}

package/src/learning/learning/ProceduralCompiler.ts

@@ -0,0 +1,45 @@
+import { ProceduralSkill } from '../types';
+
+/**
+ * ProceduralCompiler
+ *
+ * Takes JSON-based AI logic trees extracted from temporal LLM generation natively
+ * and compiles them strictly down into raw executable `.holo` syntax bounds.
+ */
+export class ProceduralCompiler {
+  /**
+   * Translates an Abstract Skill representation into native text executing within the VM.
+   */
+  static compile(skill: ProceduralSkill): string {
+    let compiled = `// Auto-generated skill: ${skill.name}\n`;
+    compiled += `// Desc: ${(skill as unknown as { description?: string }).description || 'N/A'}\n\n`;
+
+    compiled += `agent ${skill.id.replace(/-/g, '_')} {\n`;
+
+    // Generate behavior node
+    compiled += `  behavior execute() {\n`;
+
+    const codeBlock = (skill as unknown as { code?: string }).code || '';
+
+    // MVP: The LLM outputs pseudo-code or raw JS/HoloScript lines directly in string
+    // The procedural compiler validates and formats the raw string cleanly
+    const parsedLines = codeBlock.split('\n');
+
+    for (let line of parsedLines) {
+      line = line.trim();
+      if (!line) continue;
+
+      // Map some logical conversions if needed, here we just enforce safety wrappers
+      if (line.includes('move(') || line.includes('attack(') || line.includes('craft(')) {
+        compiled += `    ensure_safety() {\n      ${line}\n    }\n`;
+      } else {
+        compiled += `    ${line}\n`;
+      }
+    }
+
+    compiled += `  }\n`;
+    compiled += `}\n`;
+
+    return compiled;
+  }
+}