@holoscript/framework 6.0.3 → 6.0.4

package/src/knowledge/__tests__/knowledge-consolidator.test.ts

@@ -71,8 +71,14 @@ describe('KnowledgeConsolidator', () => {
   describe('importFromStore', () => {
     it('imports all entries from a KnowledgeStore', () => {
       const store = new KnowledgeStore({ persist: false });
-      store.publish({ type: 'wisdom', content: 'Entry A', domain: 'security', confidence: 0.9, source: 'test' }, 'agent-a');
-      store.publish({ type: 'pattern', content: 'Entry B', domain: 'agents', confidence: 0.8, source: 'test' }, 'agent-b');
+      store.publish(
+        { type: 'wisdom', content: 'Entry A', domain: 'security', confidence: 0.9, source: 'test' },
+        'agent-a'
+      );
+      store.publish(
+        { type: 'pattern', content: 'Entry B', domain: 'agents', confidence: 0.8, source: 'test' },
+        'agent-b'
+      );
 
       const imported = consolidator.importFromStore(store);
       expect(imported).toBe(2);
@@ -81,7 +87,10 @@ describe('KnowledgeConsolidator', () => {
 
     it('skips already-imported entries', () => {
       const store = new KnowledgeStore({ persist: false });
-      store.publish({ type: 'wisdom', content: 'Entry A', domain: 'general', confidence: 0.9, source: 'test' }, 'agent-a');
+      store.publish(
+        { type: 'wisdom', content: 'Entry A', domain: 'general', confidence: 0.9, source: 'test' },
+        'agent-a'
+      );
 
       consolidator.importFromStore(store);
       const second = consolidator.importFromStore(store);
@@ -219,40 +228,50 @@ describe('KnowledgeConsolidator', () => {
 
   describe('surfaceCrossDomainPatterns', () => {
     it('finds patterns shared across domains', () => {
-      consolidator.addEntry(makeEntry({
-        id: 'W.SEC.001',
-        content: 'WebSocket connections require authentication tokens',
-        domain: 'security',
-      }));
-      consolidator.addEntry(makeEntry({
-        id: 'W.AGENT.001',
-        content: 'Agent WebSocket connections drop after timeout',
-        domain: 'agents',
-      }));
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.SEC.001',
+          content: 'WebSocket connections require authentication tokens',
+          domain: 'security',
+        })
+      );
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.AGENT.001',
+          content: 'Agent WebSocket connections drop after timeout',
+          domain: 'agents',
+        })
+      );
 
       const patterns = consolidator.surfaceCrossDomainPatterns();
-      const wsPattern = patterns.find(p => p.pattern === 'websocket');
+      const wsPattern = patterns.find((p) => p.pattern === 'websocket');
       expect(wsPattern).toBeDefined();
       expect(wsPattern!.domains).toContain('security');
       expect(wsPattern!.domains).toContain('agents');
     });
 
     it('filters by specified domains', () => {
-      consolidator.addEntry(makeEntry({
-        id: 'W.SEC.F1',
-        content: 'Authentication tokens expire after timeout',
-        domain: 'security',
-      }));
-      consolidator.addEntry(makeEntry({
-        id: 'W.AGENT.F1',
-        content: 'Agent tokens refresh automatically',
-        domain: 'agents',
-      }));
-      consolidator.addEntry(makeEntry({
-        id: 'W.COMP.F1',
-        content: 'Compiler tokens are parsed differently',
-        domain: 'compilation',
-      }));
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.SEC.F1',
+          content: 'Authentication tokens expire after timeout',
+          domain: 'security',
+        })
+      );
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.AGENT.F1',
+          content: 'Agent tokens refresh automatically',
+          domain: 'agents',
+        })
+      );
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.COMP.F1',
+          content: 'Compiler tokens are parsed differently',
+          domain: 'compilation',
+        })
+      );
 
       const patterns = consolidator.surfaceCrossDomainPatterns(['security', 'agents']);
       // Should not include compilation domain
@@ -262,15 +281,17 @@ describe('KnowledgeConsolidator', () => {
     });
 
     it('returns empty for single-domain entries', () => {
-      consolidator.addEntry(makeEntry({
-        id: 'W.ONLY.001',
-        content: 'Only security concern here',
-        domain: 'security',
-      }));
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.ONLY.001',
+          content: 'Only security concern here',
+          domain: 'security',
+        })
+      );
 
       const patterns = consolidator.surfaceCrossDomainPatterns();
       // No pattern can span 2+ domains with only 1 domain present
-      expect(patterns.every(p => p.domains.length >= 2)).toBe(true);
+      expect(patterns.every((p) => p.domains.length >= 2)).toBe(true);
     });
   });
 
@@ -278,16 +299,20 @@ describe('KnowledgeConsolidator', () => {
 
   describe('detectContradictions', () => {
     it('detects negation-based contradictions', () => {
-      consolidator.addEntry(makeEntry({
-        id: 'W.CON.A',
-        content: 'You should always validate input before processing',
-        domain: 'security',
-      }));
-      consolidator.addEntry(makeEntry({
-        id: 'W.CON.B',
-        content: 'You should never validate input in the render loop',
-        domain: 'security',
-      }));
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.CON.A',
+          content: 'You should always validate input before processing',
+          domain: 'security',
+        })
+      );
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.CON.B',
+          content: 'You should never validate input in the render loop',
+          domain: 'security',
+        })
+      );
 
       const contradictions = consolidator.detectContradictions();
       expect(contradictions.length).toBeGreaterThanOrEqual(1);
@@ -297,32 +322,40 @@ describe('KnowledgeConsolidator', () => {
     });
 
     it('detects should/should not contradictions', () => {
-      consolidator.addEntry(makeEntry({
-        id: 'W.REC.A',
-        content: 'Agents should enable caching for performance',
-        domain: 'agents',
-      }));
-      consolidator.addEntry(makeEntry({
-        id: 'W.REC.B',
-        content: 'Agents should not enable caching in tests',
-        domain: 'agents',
-      }));
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.REC.A',
+          content: 'Agents should enable caching for performance',
+          domain: 'agents',
+        })
+      );
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.REC.B',
+          content: 'Agents should not enable caching in tests',
+          domain: 'agents',
+        })
+      );
 
       const contradictions = consolidator.detectContradictions();
       expect(contradictions.length).toBeGreaterThanOrEqual(1);
     });
 
     it('returns empty for non-contradicting entries', () => {
-      consolidator.addEntry(makeEntry({
-        id: 'W.OK.A',
-        content: 'Use TypeScript for type safety',
-        domain: 'compilation',
-      }));
-      consolidator.addEntry(makeEntry({
-        id: 'W.OK.B',
-        content: 'Prefer vitest over jest for testing',
-        domain: 'compilation',
-      }));
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.OK.A',
+          content: 'Use TypeScript for type safety',
+          domain: 'compilation',
+        })
+      );
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.OK.B',
+          content: 'Prefer vitest over jest for testing',
+          domain: 'compilation',
+        })
+      );
 
       const contradictions = consolidator.detectContradictions();
       expect(contradictions.length).toBe(0);
@@ -330,8 +363,16 @@ describe('KnowledgeConsolidator', () => {
 
     it('accepts external entry array', () => {
       const entries: StoredEntry[] = [
-        makeEntry({ id: 'W.EXT.A', content: 'Feature is deprecated and removed', domain: 'general' }),
-        makeEntry({ id: 'W.EXT.B', content: 'Feature is recommended and added recently', domain: 'general' }),
+        makeEntry({
+          id: 'W.EXT.A',
+          content: 'Feature is deprecated and removed',
+          domain: 'general',
+        }),
+        makeEntry({
+          id: 'W.EXT.B',
+          content: 'Feature is recommended and added recently',
+          domain: 'general',
+        }),
       ];
 
       const contradictions = consolidator.detectContradictions(entries);
@@ -339,30 +380,38 @@ describe('KnowledgeConsolidator', () => {
     });
 
     it('assigns higher confidence to same-domain contradictions', () => {
-      consolidator.addEntry(makeEntry({
-        id: 'W.CONF.A',
-        content: 'Always enable debug logging in production',
-        domain: 'security',
-      }));
-      consolidator.addEntry(makeEntry({
-        id: 'W.CONF.B',
-        content: 'Never enable debug logging anywhere',
-        domain: 'security',
-      }));
-      consolidator.addEntry(makeEntry({
-        id: 'W.CONF.C',
-        content: 'Always enable verbose logging modes',
-        domain: 'agents',
-      }));
-      consolidator.addEntry(makeEntry({
-        id: 'W.CONF.D',
-        content: 'Never enable verbose logging modes',
-        domain: 'rendering',
-      }));
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.CONF.A',
+          content: 'Always enable debug logging in production',
+          domain: 'security',
+        })
+      );
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.CONF.B',
+          content: 'Never enable debug logging anywhere',
+          domain: 'security',
+        })
+      );
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.CONF.C',
+          content: 'Always enable verbose logging modes',
+          domain: 'agents',
+        })
+      );
+      consolidator.addEntry(
+        makeEntry({
+          id: 'W.CONF.D',
+          content: 'Never enable verbose logging modes',
+          domain: 'rendering',
+        })
+      );
 
       const contradictions = consolidator.detectContradictions();
-      const sameDomain = contradictions.filter(c => c.entryA.domain === c.entryB.domain);
-      const crossDomain = contradictions.filter(c => c.entryA.domain !== c.entryB.domain);
+      const sameDomain = contradictions.filter((c) => c.entryA.domain === c.entryB.domain);
+      const crossDomain = contradictions.filter((c) => c.entryA.domain !== c.entryB.domain);
 
       if (sameDomain.length > 0 && crossDomain.length > 0) {
         expect(sameDomain[0].confidence).toBeGreaterThan(crossDomain[0].confidence);

package/src/knowledge/__tests__/knowledge-store-vector.test.ts

@@ -14,10 +14,12 @@ import type { KnowledgeConfig, KnowledgeInsight } from '../../types';
 function makeConfig(remote = true): KnowledgeConfig {
   return {
     persist: false,
-    ...(remote ? {
-      remoteUrl: 'https://mcp-orchestrator-production-45f9.up.railway.app',
-      remoteApiKey: 'test-api-key',
-    } : {}),
+    ...(remote
+      ? {
+          remoteUrl: 'https://mcp-orchestrator-production-45f9.up.railway.app',
+          remoteApiKey: 'test-api-key',
+        }
+      : {}),
   };
 }
 
@@ -159,8 +161,18 @@ describe('KnowledgeStore — Vector Embedding Pipeline', () => {
   describe('semanticSearch', () => {
     it('returns remote results when available', async () => {
       const remoteEntries = [
-        { id: 'r1', type: 'wisdom', content: 'Use strict mode', metadata: { domain: 'compilation', confidence: 0.8 } },
-        { id: 'r2', type: 'pattern', content: 'Pattern matching', metadata: { domain: 'compilation', confidence: 0.7 } },
+        {
+          id: 'r1',
+          type: 'wisdom',
+          content: 'Use strict mode',
+          metadata: { domain: 'compilation', confidence: 0.8 },
+        },
+        {
+          id: 'r2',
+          type: 'pattern',
+          content: 'Pattern matching',
+          metadata: { domain: 'compilation', confidence: 0.7 },
+        },
       ];
       globalThis.fetch = mockFetchOk(remoteEntries);
 
@@ -218,8 +230,18 @@ describe('KnowledgeStore — Vector Embedding Pipeline', () => {
 
     it('filters by minConfidence', async () => {
       const remoteEntries = [
-        { id: 'r1', type: 'wisdom', content: 'High confidence', metadata: { confidence: 0.9, domain: 'general' } },
-        { id: 'r2', type: 'wisdom', content: 'Low confidence', metadata: { confidence: 0.3, domain: 'general' } },
+        {
+          id: 'r1',
+          type: 'wisdom',
+          content: 'High confidence',
+          metadata: { confidence: 0.9, domain: 'general' },
+        },
+        {
+          id: 'r2',
+          type: 'wisdom',
+          content: 'Low confidence',
+          metadata: { confidence: 0.3, domain: 'general' },
+        },
       ];
       globalThis.fetch = mockFetchOk(remoteEntries);
 
@@ -247,19 +269,35 @@ describe('KnowledgeStore — Vector Embedding Pipeline', () => {
 
     it('hybrid search merges remote + local, deduped by ID', async () => {
       const remoteEntries = [
-        { id: 'r1', type: 'wisdom', content: 'Remote only', metadata: { domain: 'general', confidence: 0.9 } },
-        { id: 'shared', type: 'wisdom', content: 'Remote version', metadata: { domain: 'general', confidence: 0.8 } },
+        {
+          id: 'r1',
+          type: 'wisdom',
+          content: 'Remote only',
+          metadata: { domain: 'general', confidence: 0.9 },
+        },
+        {
+          id: 'shared',
+          type: 'wisdom',
+          content: 'Remote version',
+          metadata: { domain: 'general', confidence: 0.8 },
+        },
       ];
       globalThis.fetch = mockFetchOk(remoteEntries);
 
       const store = new KnowledgeStore(makeConfig());
       // Publish a local entry that has the same ID as a remote entry
-      const local = store.publish(makeInsight({ content: 'Local entry about general topics' }), 'agent-a');
-
-      const results = await store.semanticSearch('general topics', { hybridSearch: true, limit: 10 });
+      const local = store.publish(
+        makeInsight({ content: 'Local entry about general topics' }),
+        'agent-a'
+      );
+
+      const results = await store.semanticSearch('general topics', {
+        hybridSearch: true,
+        limit: 10,
+      });
 
       // Should contain remote entries + local entries, no duplicate IDs
-      const ids = results.map(r => r.id);
+      const ids = results.map((r) => r.id);
       const uniqueIds = new Set(ids);
       expect(ids.length).toBe(uniqueIds.size);
 
@@ -275,14 +313,19 @@ describe('KnowledgeStore — Vector Embedding Pipeline', () => {
 
       // Remote returns an entry with the same ID but different content
       const remoteEntries = [
-        { id: localId, type: 'wisdom', content: 'Remote version of knowledge', metadata: { domain: 'compilation', confidence: 0.95 } },
+        {
+          id: localId,
+          type: 'wisdom',
+          content: 'Remote version of knowledge',
+          metadata: { domain: 'compilation', confidence: 0.95 },
+        },
       ];
       globalThis.fetch = mockFetchOk(remoteEntries);
 
       const results = await store.semanticSearch('knowledge', { hybridSearch: true });
 
       // The entry with localId should appear exactly once
-      const matching = results.filter(r => r.id === localId);
+      const matching = results.filter((r) => r.id === localId);
       expect(matching).toHaveLength(1);
       // Remote wins (appears first in merge)
       expect(matching[0].content).toBe('Remote version of knowledge');

package/src/knowledge/brain.ts

@@ -50,7 +50,7 @@ export const DOMAIN_CONSOLIDATION: Record<KnowledgeDomain, DomainConsolidationCo
     sleepFrequencyMs: 12 * 60 * 60 * 1000,
     maxEntries: 150,
     competitionMetric: 'query_frequency',
-    downscaleFactor: 0.90,
+    downscaleFactor: 0.9,
     minCorroborations: 1,
   },
   compilation: {
@@ -58,7 +58,7 @@ export const DOMAIN_CONSOLIDATION: Record<KnowledgeDomain, DomainConsolidationCo
     sleepFrequencyMs: 12 * 60 * 60 * 1000,
     maxEntries: 100,
     competitionMetric: 'citation_count',
-    downscaleFactor: 0.90,
+    downscaleFactor: 0.9,
     minCorroborations: 1,
   },
   general: {
@@ -74,11 +74,11 @@ export const DOMAIN_CONSOLIDATION: Record<KnowledgeDomain, DomainConsolidationCo
 // ── Half-Lives ──
 
 export const DOMAIN_HALF_LIVES: Record<KnowledgeDomain, number> = {
-  security: 2 * 24 * 60 * 60 * 1000,      // 2 days
-  rendering: 14 * 24 * 60 * 60 * 1000,     // 14 days
-  agents: 7 * 24 * 60 * 60 * 1000,         // 7 days
-  compilation: 21 * 24 * 60 * 60 * 1000,   // 21 days
-  general: 7 * 24 * 60 * 60 * 1000,        // 7 days
+  security: 2 * 24 * 60 * 60 * 1000, // 2 days
+  rendering: 14 * 24 * 60 * 60 * 1000, // 14 days
+  agents: 7 * 24 * 60 * 60 * 1000, // 7 days
+  compilation: 21 * 24 * 60 * 60 * 1000, // 21 days
+  general: 7 * 24 * 60 * 60 * 1000, // 7 days
 };
 
 // ── Hot Buffer ──

package/src/knowledge/consolidation.ts

@@ -68,9 +68,15 @@ function defaultExcitability(): ExcitabilityMetadata {
 function containsInjectionPattern(content: string): boolean {
   if (!content || typeof content !== 'string') return false;
 
-  if (/["'];?\s*(import|require|exec|system|Process|eval|Function)\s*[.(]/i.test(content)) return true;
+  if (/["'];?\s*(import|require|exec|system|Process|eval|Function)\s*[.(]/i.test(content))
+    return true;
   if (/<script[\s>]/i.test(content)) return true;
-  if (/\b(os\.execute|os\.system|Runtime\.getRuntime|child_process|Process\.Start)\s*\(/i.test(content)) return true;
+  if (
+    /\b(os\.execute|os\.system|Runtime\.getRuntime|child_process|Process\.Start)\s*\(/i.test(
+      content
+    )
+  )
+    return true;
   if (/#\s*(include|pragma|define)\b/i.test(content)) return true;
   if (content.includes('\0')) return true;
   if (/OS\.(execute|shell_open)\s*\(/i.test(content)) return true;
@@ -155,7 +161,7 @@ export class ConsolidationEngine {
    */
   corroborate(domain: KnowledgeDomain, entryId: string, peerDid: string): boolean {
     const buffer = this.hotBuffers.get(domain) || [];
-    const entry = buffer.find(e => e.id === entryId);
+    const entry = buffer.find((e) => e.id === entryId);
     if (!entry) return false;
     if (!entry.corroborations.includes(peerDid)) {
       entry.corroborations.push(peerDid);
@@ -230,8 +236,8 @@ export class ConsolidationEngine {
     // Phase 2 & 3: CLUSTER + MERGE — deduplicate by content+type equality
     const uniqueEntries: HotBufferEntry[] = [];
     for (const entry of sanitized) {
-      const duplicate = uniqueEntries.find(e =>
-        e.content === entry.content && e.type === entry.type
+      const duplicate = uniqueEntries.find(
+        (e) => e.content === entry.content && e.type === entry.type
       );
       if (duplicate) {
         // Merge corroborations from duplicate
@@ -333,7 +339,7 @@ export class ConsolidationEngine {
    */
   needsConsolidation(): { domain: KnowledgeDomain; overdue: boolean; bufferSize: number }[] {
     const now = Date.now();
-    return KNOWLEDGE_DOMAINS.map(domain => {
+    return KNOWLEDGE_DOMAINS.map((domain) => {
       const config = DOMAIN_CONSOLIDATION[domain];
       const lastRun = this.lastConsolidation.get(domain) || 0;
       const elapsed = now - lastRun;
@@ -392,11 +398,7 @@ export class ConsolidationEngine {
    * Update an entry during its reconsolidation window.
    * Returns false if the window is closed or entry not found.
    */
-  reconsolidateEntry(
-    domain: KnowledgeDomain,
-    entryId: string,
-    updatedContent: string
-  ): boolean {
+  reconsolidateEntry(domain: KnowledgeDomain, entryId: string, updatedContent: string): boolean {
     const window = this.reconsolidationWindows.get(entryId);
     if (!window || !window.windowOpen || Date.now() > window.windowClosesAt) {
       return false;
@@ -488,7 +490,7 @@ export class ConsolidationEngine {
 
   /** Get hot buffer size across all domains. */
   getHotBufferStats(): { domain: string; count: number }[] {
-    return KNOWLEDGE_DOMAINS.map(domain => ({
+    return KNOWLEDGE_DOMAINS.map((domain) => ({
       domain,
       count: (this.hotBuffers.get(domain) || []).length,
     }));
@@ -496,7 +498,7 @@ export class ConsolidationEngine {
 
   /** Get cold store size across all domains. */
   getColdStoreStats(): { domain: string; count: number }[] {
-    return KNOWLEDGE_DOMAINS.map(domain => ({
+    return KNOWLEDGE_DOMAINS.map((domain) => ({
       domain,
       count: (this.coldStores.get(domain) || new Map()).size,
     }));
@@ -566,9 +568,7 @@ export interface CrossDomainMatch {
 
 /** Tokenize content into a set of lowercase words (3+ chars). */
 function tokenize(content: string): Set<string> {
-  return new Set(
-    content.toLowerCase().match(/[a-z0-9]{3,}/g) || []
-  );
+  return new Set(content.toLowerCase().match(/[a-z0-9]{3,}/g) || []);
 }
 
 /** Jaccard overlap between two sets. */