noormme 1.0.6 → 1.2.0

package/dist/esm/agentic/improvement/RitualOrchestrator.js

@@ -19,7 +19,7 @@ export class RitualOrchestrator {
      */
     async scheduleRitual(name, type, frequency, definition, metadata) {
         const nextRun = this.calculateNextRun(frequency);
-        const ritual = await this.db
+        const ritual = (await this.db
             .insertInto(this.ritualsTable)
             .values({
             name,
@@ -28,10 +28,10 @@ export class RitualOrchestrator {
             definition,
             next_run: nextRun,
             status: 'pending',
-            metadata: metadata ? JSON.stringify(metadata) : null
+            metadata: metadata ? JSON.stringify(metadata) : null,
         })
             .returningAll()
-            .executeTakeFirstOrThrow();
+            .executeTakeFirstOrThrow());
         return this.parseRitual(ritual);
     }
     /**
@@ -40,41 +40,47 @@ export class RitualOrchestrator {
     async runPendingRituals() {
         const now = new Date();
         const lockTimeout = new Date(now.getTime() + 600000); // 10 min lock by default
-        return await this.db.transaction().execute(async (trx) => {
-            const pending = await trx
+        const pending = await this.db.transaction().execute(async (trx) => {
+            const due = (await trx
                 .selectFrom(this.ritualsTable)
                 .selectAll()
                 .where('next_run', '<=', now)
                 .where('status', 'in', ['pending', 'success', 'failure'])
                 .where((eb) => eb.or([
                 eb('locked_until', '<=', now),
-                eb('locked_until', 'is', null)
+                eb('locked_until', 'is', null),
             ]))
-                .execute();
-            if (pending.length === 0)
-                return 0;
-            console.log(`[RitualOrchestrator] Found ${pending.length} pending rituals due. Locking for execution...`);
-            for (const ritual of pending) {
+                .execute());
+            if (due.length === 0)
+                return [];
+            for (const ritual of due) {
                 // Production Hardening: Distributed Lock
                 await trx
                     .updateTable(this.ritualsTable)
                     .set({ locked_until: lockTimeout })
                     .where('id', '=', ritual.id)
                     .execute();
-                // Execute out-of-transaction to avoid long-held locks if sub-tasks are slow
-                // but we await it here for the summary count. 
-                // In a highly parallel system, this might be sent to a worker queue.
-                await this.executeRitual(ritual);
             }
-            return pending.length;
+            return due;
         });
+        if (pending.length === 0)
+            return 0;
+        console.log(`[RitualOrchestrator] Found ${pending.length} pending rituals due. Locking for execution...`);
+        for (const ritual of pending) {
+            // Execute out-of-transaction to avoid long-held locks if sub-tasks are slow
+            await this.executeRitual(ritual);
+        }
+        return pending.length;
     }
     /**
      * Execute a specific ritual
      */
     async executeRitual(ritual) {
         console.log(`[RitualOrchestrator] Executing ritual: ${ritual.name} (${ritual.type})`);
-        const ritualMetadata = { ...ritual.metadata, startedAt: new Date() };
+        const ritualMetadata = {
+            ...ritual.metadata,
+            startedAt: new Date(),
+        };
         let success = false;
         try {
             switch (ritual.type) {
@@ -85,15 +91,15 @@ export class RitualOrchestrator {
                         .select('id')
                         .where('status', '=', 'active')
                         .execute();
-                    const compressionThreshold = (this.config.contextWindowSize || 20);
+                    const compressionThreshold = this.config.contextWindowSize || 20;
                     let compressedCount = 0;
                     for (const session of activeSessions) {
                         const messagesTable = this.config.messagesTable || 'agent_messages';
-                        const countResult = await this.db
+                        const countResult = (await this.db
                             .selectFrom(messagesTable)
                             .select((eb) => eb.fn.countAll().as('count'))
                             .where('session_id', '=', session.id)
-                            .executeTakeFirst();
+                            .executeTakeFirst());
                         const count = Number(countResult?.count || 0);
                         if (count > compressionThreshold) {
                             await this.cortex.compressor.semanticPruning(session.id);
@@ -115,6 +121,12 @@ export class RitualOrchestrator {
                     ritualMetadata.prunedZombies = prunedZombies;
                     ritualMetadata.orphansCleaned = orphans;
                     break;
+                case 'evolution':
+                    const evolutionResults = await this.cortex.evolutionRitual.execute();
+                    ritualMetadata.synthesized = evolutionResults.synthesized;
+                    ritualMetadata.broadcasted = evolutionResults.broadcasted;
+                    ritualMetadata.domainsBoosted = evolutionResults.domainsSynced;
+                    break;
             }
             success = true;
         }
@@ -134,7 +146,7 @@ export class RitualOrchestrator {
                 last_run: new Date(),
                 next_run: nextRun,
                 locked_until: null, // Unlock
-                metadata: JSON.stringify(ritualMetadata)
+                metadata: JSON.stringify(ritualMetadata),
             })
                 .where('id', '=', ritual.id)
                 .execute();
@@ -168,7 +180,7 @@ export class RitualOrchestrator {
             lastRun: r.last_run ? new Date(r.last_run) : undefined,
             nextRun: r.next_run ? new Date(r.next_run) : undefined,
             lockedUntil: r.locked_until ? new Date(r.locked_until) : undefined,
-            metadata: typeof r.metadata === 'string' ? JSON.parse(r.metadata) : r.metadata
+            metadata: typeof r.metadata === 'string' ? JSON.parse(r.metadata) : r.metadata,
         };
     }
 }

package/dist/esm/agentic/improvement/RuleEngine.js

@@ -20,7 +20,7 @@ export class RuleEngine {
      */
     async defineRule(tableName, operation, action, options = {}) {
         return await this.db.transaction().execute(async (trx) => {
-            const rule = await trx
+            const rule = (await trx
                 .insertInto(this.rulesTable)
                 .values({
                 table_name: tableName,
@@ -31,10 +31,10 @@ export class RuleEngine {
                 script: options.script || null,
                 is_enabled: true,
                 metadata: options.metadata ? JSON.stringify(options.metadata) : null,
-                created_at: new Date()
+                created_at: new Date(),
             })
                 .returningAll()
-                .executeTakeFirstOrThrow();
+                .executeTakeFirstOrThrow());
             return this.parseRule(rule);
         });
     }
@@ -51,7 +51,7 @@ export class RuleEngine {
                 return {
                     action: rule.action,
                     ruleId: rule.id,
-                    reason: `Matched rule ${rule.id} (${rule.action})`
+                    reason: `Matched rule ${rule.id} (${rule.action})`,
                 };
             }
         }
@@ -80,13 +80,10 @@ export class RuleEngine {
             .selectFrom(this.rulesTable)
             .selectAll()
             .where('table_name', '=', tableName)
-            .where((eb) => eb.or([
-            eb('operation', '=', operation),
-            eb('operation', '=', 'all')
-        ]))
+            .where((eb) => eb.or([eb('operation', '=', operation), eb('operation', '=', 'all')]))
             .where('is_enabled', '=', true)
             .execute();
-        return list.map(r => this.parseRule(r));
+        return list.map((r) => this.parseRule(r));
     }
     evaluateCondition(condition, data) {
         // Simple condition parser: "key op value"
@@ -105,12 +102,18 @@ export class RuleEngine {
         if (compareValue === 'false')
             compareValue = false;
         switch (op) {
-            case '==': return val == compareValue;
-            case '!=': return val != compareValue;
-            case '>': return val > compareValue;
-            case '<': return val < compareValue;
-            case 'includes': return String(val).includes(String(compareValue));
-            default: return false;
+            case '==':
+                return val == compareValue;
+            case '!=':
+                return val != compareValue;
+            case '>':
+                return val > compareValue;
+            case '<':
+                return val < compareValue;
+            case 'includes':
+                return String(val).includes(String(compareValue));
+            default:
+                return false;
         }
     }
     parseRule(r) {
@@ -122,8 +125,10 @@ export class RuleEngine {
             action: r.action,
             priority: r.priority,
             isEnabled: !!r.is_enabled,
-            metadata: typeof r.metadata === 'string' ? JSON.parse(r.metadata) : (r.metadata || {}),
-            createdAt: new Date(r.created_at)
+            metadata: typeof r.metadata === 'string'
+                ? JSON.parse(r.metadata)
+                : r.metadata || {},
+            createdAt: new Date(r.created_at),
         };
     }
 }

package/dist/esm/agentic/improvement/SelfEvolution.js

@@ -19,7 +19,8 @@ export class SelfEvolution {
         this.config = config;
         this.evolution = new SchemaEvolutionHelper(db);
         this.typeGenerator = new TypeGenerator(config.introspection);
-        this.snapshotsTable = config.agentic?.metadata?.snapshotsTable || 'agent_snapshots';
+        this.snapshotsTable =
+            config.agentic?.metadata?.snapshotsTable || 'agent_snapshots';
     }
     /**
      * Ensure core agentic tables have telemetry columns like 'accessed_at'
@@ -30,13 +31,16 @@ export class SelfEvolution {
             this.config.agentic?.messagesTable || 'agent_messages',
             this.config.agentic?.memoriesTable || 'agent_memories',
             this.config.agentic?.goalsTable || 'agent_goals',
-            this.config.agentic?.knowledgeTable || 'agent_knowledge_base'
+            this.config.agentic?.knowledgeTable || 'agent_knowledge_base',
         ];
         for (const table of tables) {
             try {
                 const introspector = this.db.introspection;
-                const tableInfo = await introspector.getTables().then(ts => ts.find(t => t.name === table));
-                if (tableInfo && !tableInfo.columns.some(c => c.name === 'accessed_at')) {
+                const tableInfo = await introspector
+                    .getTables()
+                    .then((ts) => ts.find((t) => t.name === table));
+                if (tableInfo &&
+                    !tableInfo.columns.some((c) => c.name === 'accessed_at')) {
                     console.log(`[SelfEvolution] Adding 'accessed_at' column to ${table}`);
                     await sql `ALTER TABLE ${sql.table(table)} ADD COLUMN accessed_at TIMESTAMP`.execute(this.db);
                 }
@@ -107,9 +111,9 @@ export class SelfEvolution {
                 ...options.metadata,
                 ddl,
                 is_auto: true,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             }),
-            created_at: new Date()
+            created_at: new Date(),
         })
             .execute();
         // 2. Regenerate types
@@ -123,13 +127,13 @@ export class SelfEvolution {
         const introspector = this.db.introspection;
         const tables = await introspector.getTables();
         const schemaInfo = {
-            tables: tables.map(t => ({
+            tables: tables.map((t) => ({
                 name: t.name,
                 columns: t.columns || [],
                 indexes: t.indexes || [],
-                foreignKeys: t.foreignKeys || []
+                foreignKeys: t.foreignKeys || [],
             })),
-            relationships: []
+            relationships: [],
         };
         const generated = this.typeGenerator.generateTypes(schemaInfo);
         if (this.config.agentic?.metadata?.typesOutputPath) {
@@ -153,12 +157,12 @@ export class SelfEvolution {
         if (ctx.includes('slow') || ctx.includes('latency')) {
             // Suggest index for metrics if they seem slow
             if (ctx.includes('metrics')) {
-                await this.evolve("CREATE INDEX IF NOT EXISTS idx_metrics_fast_lookup ON agent_metrics(metric_name, created_at)");
+                await this.evolve('CREATE INDEX IF NOT EXISTS idx_metrics_fast_lookup ON agent_metrics(metric_name, created_at)');
                 return true;
             }
             // Suggest index for memories if semantic search is mentioned
             if (ctx.includes('search') || ctx.includes('memory')) {
-                await this.evolve("CREATE INDEX IF NOT EXISTS idx_memories_session_time ON agent_memories(session_id, created_at)");
+                await this.evolve('CREATE INDEX IF NOT EXISTS idx_memories_session_time ON agent_memories(session_id, created_at)');
                 return true;
             }
         }
@@ -168,16 +172,16 @@ export class SelfEvolution {
      * Get history of evolutions
      */
     async getEvolutionHistory(limit = 10) {
-        const list = await this.db
+        const list = (await this.db
             .selectFrom(this.snapshotsTable)
             .selectAll()
             .orderBy('created_at', 'desc')
             .limit(limit)
-            .execute();
-        return list.map(s => ({
+            .execute());
+        return list.map((s) => ({
             ...s,
             metadata: typeof s.metadata === 'string' ? JSON.parse(s.metadata) : s.metadata,
-            createdAt: new Date(s.createdAt)
+            createdAt: new Date(s.createdAt),
         }));
     }
     /**
@@ -185,14 +189,16 @@ export class SelfEvolution {
      */
     async rollbackToSnapshot(name) {
         console.log(`[SelfEvolution] Initiating structural rollback to: ${name}`);
-        const snapshot = await this.db
+        const snapshot = (await this.db
             .selectFrom(this.snapshotsTable)
             .selectAll()
             .where('name', '=', name)
-            .executeTakeFirst();
+            .executeTakeFirst());
         if (!snapshot)
             throw new Error(`Snapshot ${name} not found.`);
-        const metadata = typeof snapshot.metadata === 'string' ? JSON.parse(snapshot.metadata) : (snapshot.metadata || {});
+        const metadata = typeof snapshot.metadata === 'string'
+            ? JSON.parse(snapshot.metadata)
+            : snapshot.metadata || {};
         if (metadata.ddl) {
             const inverse = this.invertDDL(metadata.ddl);
             if (inverse) {

package/dist/esm/agentic/improvement/SelfTestRegistry.js

@@ -23,11 +23,11 @@ export class SelfTestRegistry {
             name,
             script,
             expected_outcome: expectedOutcome,
-            created_at: new Date()
+            created_at: new Date(),
         })
             .onConflict((oc) => oc.column('name').doUpdateSet({
             script,
-            expected_outcome: expectedOutcome
+            expected_outcome: expectedOutcome,
         }))
             .execute();
     }
@@ -35,10 +35,10 @@ export class SelfTestRegistry {
      * Run all registered probes
      */
     async runAllProbes() {
-        const probes = await this.db
+        const probes = (await this.db
             .selectFrom('agent_logic_probes')
             .selectAll()
-            .execute();
+            .execute());
         const results = [];
         for (const probe of probes) {
             console.log(`[SelfTestRegistry] Running probe: ${probe.name}`);
@@ -59,9 +59,9 @@ export class SelfTestRegistry {
                                 this.config.memoriesTable || 'agent_memories',
                                 this.config.knowledgeTable || 'agent_knowledge_base',
                                 this.config.actionsTable || 'agent_actions',
-                                this.config.metricsTable || 'agent_metrics'
+                                this.config.metricsTable || 'agent_metrics',
                             ];
-                            const missing = requiredSubsets.filter(req => !tables.some(t => t.name === req));
+                            const missing = requiredSubsets.filter((req) => !tables.some((t) => t.name === req));
                             success = missing.length === 0;
                             break;
                         case 'check_memory_integrity':
@@ -94,47 +94,50 @@ export class SelfTestRegistry {
                             const orphanedKnowledge = await this.db
                                 .selectFrom(knowledgeTable)
                                 .where('source_session_id', 'is not', null)
-                                .where((eb) => eb.not(eb.exists(eb.selectFrom(sessionsTbl)
+                                .where((eb) => eb.not(eb.exists(eb
+                                .selectFrom(sessionsTbl)
                                 .select('id')
                                 .whereRef(`${knowledgeTable}.source_session_id`, '=', `${sessionsTbl}.id`))))
                                 .execute();
                             const orphanedActions = await this.db
                                 .selectFrom(actionsTable)
-                                .where((eb) => eb.not(eb.exists(eb.selectFrom(sessionsTbl)
+                                .where((eb) => eb.not(eb.exists(eb
+                                .selectFrom(sessionsTbl)
                                 .select('id')
                                 .whereRef(`${actionsTable}.session_id`, '=', `${sessionsTbl}.id`))))
                                 .execute();
-                            success = orphanedKnowledge.length === 0 && orphanedActions.length === 0;
+                            success =
+                                orphanedKnowledge.length === 0 && orphanedActions.length === 0;
                             break;
                         case 'check_performance_drift':
                             // Real check: Compare last 10 queries average with historical baseline
                             const metricsTbl = this.config.metricsTable || 'agent_metrics';
-                            const recentMetrics = await this.db
+                            const recentMetrics = (await this.db
                                 .selectFrom(metricsTbl)
                                 .select('execution_time')
                                 .orderBy('created_at', 'desc')
                                 .limit(20)
-                                .execute();
+                                .execute());
                             if (recentMetrics.length < 5) {
                                 success = true; // Not enough data to determine drift
                             }
                             else {
                                 const avgRecent = recentMetrics.reduce((sum, m) => sum + (m.execution_time || 0), 0) / recentMetrics.length;
                                 // Baseline: Avg of previous 100 metrics excluding the most recent 20
-                                const baselineMetrics = await this.db
+                                const baselineMetrics = (await this.db
                                     .selectFrom(metricsTbl)
                                     .select('execution_time')
                                     .orderBy('created_at', 'desc')
                                     .offset(20)
                                     .limit(100)
-                                    .execute();
+                                    .execute());
                                 if (baselineMetrics.length === 0) {
                                     success = avgRecent < 500; // Fallback threshold (500ms)
                                 }
                                 else {
                                     const avgBaseline = baselineMetrics.reduce((sum, m) => sum + (m.execution_time || 0), 0) / baselineMetrics.length;
                                     // Fail if recent performance is > 50% worse than baseline
-                                    success = avgRecent < (avgBaseline * 1.5);
+                                    success = avgRecent < avgBaseline * 1.5;
                                 }
                             }
                             break;
@@ -151,7 +154,7 @@ export class SelfTestRegistry {
                     .updateTable('agent_logic_probes')
                     .set({
                     last_run: new Date(),
-                    last_status: success ? 'pass' : 'fail'
+                    last_status: success ? 'pass' : 'fail',
                 })
                     .where('id', '=', probe.id)
                     .execute();

package/dist/esm/agentic/improvement/SkillSynthesizer.d.ts

@@ -0,0 +1,48 @@
+import type { Kysely } from '../../kysely.js';
+import type { AgenticConfig, AgentCapability, SkillSynthesisStrategy, SynthesisContext } from '../../types/index.js';
+import type { Cortex } from '../Cortex.js';
+/**
+ * High-Throughput Tiered AI Synthesis Strategy.
+ * Orchestrates multiple model tiers for cost-effective ultra-scale evolution.
+ */
+declare class AISynthesisStrategy implements SkillSynthesisStrategy {
+    private cortex;
+    private synthesizer;
+    name: string;
+    constructor(cortex: Cortex, synthesizer: SkillSynthesizer);
+    synthesize(context: SynthesisContext): Promise<{
+        mutatedDescription: any;
+        mutatedMetadata: any;
+        version: string;
+    }>;
+    /**
+     * Batch Synthesis using FAST model (Pass 6)
+     */
+    synthesizeBatch(contexts: SynthesisContext[]): Promise<{
+        tool: string;
+        mutation: any;
+    }[]>;
+    private buildMutationPrompt;
+}
+/**
+ * SkillSynthesizer implements Pass 6 Ultra-Scale Orchestration.
+ */
+export declare class SkillSynthesizer {
+    private db;
+    private cortex;
+    private config;
+    private evolutionConfig;
+    private actionsTable;
+    strategy: AISynthesisStrategy;
+    totalTokensConsumed: number;
+    constructor(db: Kysely<any>, cortex: Cortex, config?: AgenticConfig);
+    /**
+     * Pass 6: Predictive Pre-warming Hook
+     * Called by CapabilityManager when an experimental skill nears promotion.
+     */
+    preWarmSkill(name: string): Promise<void>;
+    discoverAndSynthesize(): Promise<AgentCapability[]>;
+    private registerMutation;
+    private pruneSandboxIfNeeded;
+}
+export {};