noormme 1.2.0 → 1.2.1

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

@@ -69,12 +69,14 @@ export class RecursiveReasoner {
         const clusters = {};
         // Global Token Frequency Pass
         const globalTokenFreq = new Map();
-        for (const lesson of rawLessons) {
+        const maxItems = this.config.maxSynthesisItems || 500;
+        const limitedResults = rawLessons.slice(0, maxItems);
+        for (const lesson of limitedResults) {
             for (const token of this.tokenize(lesson)) {
                 globalTokenFreq.set(token, (globalTokenFreq.get(token) || 0) + 1);
             }
         }
-        for (const lesson of rawLessons) {
+        for (const lesson of limitedResults) {
             const tokens = this.tokenize(lesson);
             if (tokens.length === 0)
                 continue;
@@ -106,30 +108,34 @@ export class RecursiveReasoner {
             .selectAll()
             .where('metadata', 'like', '%"evolution_status":"stable"%')
             .execute();
+        // Audit Phase 14: Linear Batch Check
+        const descriptions = breakthroughs
+            .map((p) => {
+            const meta = JSON.parse(p.metadata || '{}');
+            const reasoning = meta.mutation_reasoning || meta.reasoning;
+            return reasoning ? `Systemic Best-Practice: ${reasoning}` : null;
+        })
+            .filter(Boolean);
+        if (descriptions.length === 0)
+            return 0;
+        const existingGoals = await this.typedDb
+            .selectFrom(goalsTable)
+            .select('description')
+            .where('description', 'in', descriptions)
+            .execute();
+        const existingSet = new Set(existingGoals.map((g) => g.description));
         let goalsCreated = 0;
-        for (const p of breakthroughs) {
-            const persona = p;
-            const metadata = JSON.parse(persona.metadata || '{}');
-            const reasoning = metadata.mutation_reasoning || metadata.reasoning;
-            if (!reasoning)
-                continue;
-            // Check if this goal already exists to avoid duplication
-            const existing = await this.typedDb
-                .selectFrom(goalsTable)
-                .select('id')
-                .where('description', 'like', `%${reasoning.slice(0, 50)}%`)
-                .executeTakeFirst();
-            if (!existing) {
-                console.log(`[RecursiveReasoner] Distilling breakthrough from Persona ${persona.id} into Global Goal...`);
+        for (const desc of descriptions) {
+            if (!existingSet.has(desc)) {
+                console.log(`[RecursiveReasoner] Distilling breakthrough into Global Goal: ${desc.slice(0, 50)}...`);
                 await this.typedDb
                     .insertInto(goalsTable)
                     .values({
                     session_id: 0, // System-level goal
-                    description: `Systemic Best-Practice: ${reasoning}`,
+                    description: desc,
                     status: 'pending',
                     priority: 5,
                     metadata: JSON.stringify({
-                        source_persona: persona.id,
                         cross_pollinated: true,
                     }),
                     created_at: new Date(),
@@ -152,15 +158,34 @@ export class RecursiveReasoner {
             .where('status', '=', 'active')
             .execute());
         const contradictions = [];
-        for (let i = 0; i < activeGoals.length; i++) {
-            for (let j = i + 1; j < activeGoals.length; j++) {
-                const g1 = activeGoals[i];
-                const g2 = activeGoals[j];
-                const conflict = this.checkConflict(g1.description, g2.description);
-                if (conflict) {
-                    contradictions.push(`Goal Conflict: "${g1.description}" opposes "${g2.description}" regarding '${conflict}'`);
+        const subjectMap = new Map();
+        // Audit Phase 7: O(N) Linear Contradiction Detection
+        for (const goal of activeGoals) {
+            const tokens = this.tokenize(goal.description);
+            for (const token of tokens) {
+                if (!subjectMap.has(token))
+                    subjectMap.set(token, []);
+                subjectMap.get(token).push({ desc: goal.description, keywords: new Set(tokens) });
+            }
+        }
+        for (const [subject, entries] of subjectMap.entries()) {
+            if (entries.length < 2)
+                continue;
+            for (let i = 0; i < entries.length; i++) {
+                for (let j = i + 1; j < entries.length; j++) {
+                    const conflict = this.checkConflict(entries[i].desc, entries[j].desc);
+                    if (conflict) {
+                        contradictions.push(`Goal Conflict: "${entries[i].desc}" opposes "${entries[j].desc}" regarding '${conflict}'`);
+                        // Limit duplicates for the same pair
+                        if (contradictions.length > 50)
+                            break;
+                    }
                 }
+                if (contradictions.length > 50)
+                    break;
             }
+            if (contradictions.length > 50)
+                break;
         }
         return contradictions;
     }

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

@@ -16,7 +16,10 @@ export declare class ReflectionEngine {
     /**
      * Get reflections for a specific session
      */
-    getSessionReflections(sessionId: string | number): Promise<AgentReflection[]>;
+    getSessionReflections(sessionId: string | number, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<AgentReflection[]>;
     /**
      * Get recent lessons learned across all sessions
      */

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

@@ -35,12 +35,14 @@ export class ReflectionEngine {
     /**
      * Get reflections for a specific session
      */
-    async getSessionReflections(sessionId) {
+    async getSessionReflections(sessionId, options = {}) {
         const reflections = (await this.db
             .selectFrom(this.reflectionsTable)
             .selectAll()
             .where('session_id', '=', sessionId)
             .orderBy('created_at', 'desc')
+            .limit(options.limit ?? 500) // Audit Phase 18: Hard memory safety limit
+            .offset(options.offset ?? 0)
             .execute());
         return reflections.map((r) => this.parseReflection(r));
     }

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

@@ -86,25 +86,36 @@ export class RitualOrchestrator {
             switch (ritual.type) {
                 case 'compression':
                     const sessionsTable = this.config.sessionsTable || 'agent_sessions';
-                    const activeSessions = await this.db
-                        .selectFrom(sessionsTable)
-                        .select('id')
-                        .where('status', '=', 'active')
-                        .execute();
+                    const messagesTable = this.config.messagesTable || 'agent_messages';
                     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
-                            .selectFrom(messagesTable)
-                            .select((eb) => eb.fn.countAll().as('count'))
-                            .where('session_id', '=', session.id)
-                            .executeTakeFirst());
-                        const count = Number(countResult?.count || 0);
-                        if (count > compressionThreshold) {
-                            await this.cortex.compressor.semanticPruning(session.id);
-                            compressedCount++;
+                    let offset = 0;
+                    const batchSize = 100; // Audit Phase 17: Paginated session processing
+                    while (true) {
+                        const activeSessions = await this.db
+                            .selectFrom(sessionsTable)
+                            .select('id')
+                            .where('status', '=', 'active')
+                            .limit(batchSize)
+                            .offset(offset)
+                            .execute();
+                        if (activeSessions.length === 0)
+                            break;
+                        for (const session of activeSessions) {
+                            const countResult = (await this.db
+                                .selectFrom(messagesTable)
+                                .select((eb) => eb.fn.countAll().as('count'))
+                                .where('session_id', '=', session.id)
+                                .executeTakeFirst());
+                            const count = Number(countResult?.count || 0);
+                            if (count > compressionThreshold) {
+                                await this.cortex.compressor.semanticPruning(session.id);
+                                compressedCount++;
+                            }
                         }
+                        if (activeSessions.length < batchSize)
+                            break;
+                        offset += batchSize;
                     }
                     ritualMetadata.sessionsCompressed = compressedCount;
                     break;

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

@@ -33,7 +33,7 @@ export declare class RuleEngine {
         priority?: number;
         script?: string;
         metadata?: Record<string, any>;
-    }): Promise<CognitiveRule>;
+    }, trx?: any): Promise<CognitiveRule>;
     /**
      * Evaluate rules against a specific data object.
      * Returns the highest priority rule action that matches.

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

@@ -18,9 +18,9 @@ export class RuleEngine {
     /**
      * Define a new cognitive rule transactionally.
      */
-    async defineRule(tableName, operation, action, options = {}) {
-        return await this.db.transaction().execute(async (trx) => {
-            const rule = (await trx
+    async defineRule(tableName, operation, action, options = {}, trx) {
+        const defineStep = async (t) => {
+            const rule = (await t
                 .insertInto(this.rulesTable)
                 .values({
                 table_name: tableName,
@@ -36,7 +36,13 @@ export class RuleEngine {
                 .returningAll()
                 .executeTakeFirstOrThrow());
             return this.parseRule(rule);
-        });
+        };
+        if (trx) {
+            return await defineStep(trx);
+        }
+        else {
+            return await this.db.transaction().execute(defineStep);
+        }
     }
     /**
      * Evaluate rules against a specific data object.

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

@@ -99,23 +99,27 @@ export class SelfEvolution {
      */
     async evolve(ddl, options = {}) {
         console.log(`[SelfEvolution] Applying structural change: ${ddl}`);
-        // 1. Apply the DDL change
-        await this.evolution.applySuggestion(ddl);
-        // 1b. Log for potential rollback
-        await this.db
-            .insertInto(this.snapshotsTable)
-            .values({
-            name: options.name || `auto_evolution_${Date.now()}`,
-            dna: await this.getDNA(),
-            metadata: JSON.stringify({
-                ...options.metadata,
-                ddl,
-                is_auto: true,
-                timestamp: Date.now(),
-            }),
-            created_at: new Date(),
-        })
-            .execute();
+        await this.db.transaction().execute(async (trx) => {
+            // 1. Apply the DDL change
+            // Pass transaction to evolution helper if it supports it, 
+            // otherwise use trx.execute() directly for the DDL
+            await trx.execute(sql.raw(ddl));
+            // 1b. Log for potential rollback
+            await trx
+                .insertInto(this.snapshotsTable)
+                .values({
+                name: options.name || `auto_evolution_${Date.now()}`,
+                dna: await this.getDNA(),
+                metadata: JSON.stringify({
+                    ...options.metadata,
+                    ddl,
+                    is_auto: true,
+                    timestamp: Date.now(),
+                }),
+                created_at: new Date(),
+            })
+                .execute();
+        });
         // 2. Regenerate types
         await this.regenerateTypes();
         console.log(`[SelfEvolution] Schema evolved successfully.`);

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

@@ -22,4 +22,9 @@ export declare class SelfTestRegistry {
         success: boolean;
         error?: string;
     }[]>;
+    private runAuditAction;
+    /**
+     * Interpret custom probe logic by providing the LLM with relevant database snapshots.
+     */
+    private dynamicEvaluation;
 }

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

@@ -43,121 +43,33 @@ export class SelfTestRegistry {
         for (const probe of probes) {
             console.log(`[SelfTestRegistry] Running probe: ${probe.name}`);
             try {
-                // Real implementation: Execute the probe script
-                // For safety and integration, we support a set of predefined audit functions
-                // or the ability to run a dynamic check if enabled.
                 let success = false;
                 if (probe.script.startsWith('audit:')) {
-                    const action = probe.script.split(':')[1];
-                    switch (action) {
-                        case 'check_schema_consistency':
-                            // Real check: compare introspection with required core tables
-                            const tables = await this.db.introspection.getTables();
-                            const requiredSubsets = [
-                                this.config.messagesTable || 'agent_messages',
-                                this.config.sessionsTable || 'agent_sessions',
-                                this.config.memoriesTable || 'agent_memories',
-                                this.config.knowledgeTable || 'agent_knowledge_base',
-                                this.config.actionsTable || 'agent_actions',
-                                this.config.metricsTable || 'agent_metrics',
-                            ];
-                            const missing = requiredSubsets.filter((req) => !tables.some((t) => t.name === req));
-                            success = missing.length === 0;
-                            break;
-                        case 'check_memory_integrity':
-                            // Real check: verify embeddings are not null where expected
-                            const memoriesTable = this.config.memoriesTable || 'agent_memories';
-                            const invalidMemories = await this.db
-                                .selectFrom(memoriesTable)
-                                .select('id')
-                                .where('embedding', 'is', null)
-                                .execute();
-                            success = invalidMemories.length === 0;
-                            break;
-                        case 'check_session_coherence':
-                            // Check if sessions have at least one message
-                            const sessionsTable = this.config.sessionsTable || 'agent_sessions';
-                            const messagesTable = this.config.messagesTable || 'agent_messages';
-                            const emptySessions = await this.db
-                                .selectFrom(sessionsTable)
-                                .leftJoin(messagesTable, `${sessionsTable}.id`, `${messagesTable}.session_id`)
-                                .select(`${sessionsTable}.id as sid`)
-                                .where(`${messagesTable}.id`, 'is', null)
-                                .execute();
-                            success = emptySessions.length < 5; // Allow small buffer of new sessions
-                            break;
-                        case 'check_data_integrity':
-                            // Real check: Detect orphaned records pointing to non-existent sessions
-                            const knowledgeTable = this.config.knowledgeTable || 'agent_knowledge_base';
-                            const actionsTable = this.config.actionsTable || 'agent_actions';
-                            const sessionsTbl = this.config.sessionsTable || 'agent_sessions';
-                            const orphanedKnowledge = await this.db
-                                .selectFrom(knowledgeTable)
-                                .where('source_session_id', 'is not', null)
-                                .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)
-                                .select('id')
-                                .whereRef(`${actionsTable}.session_id`, '=', `${sessionsTbl}.id`))))
-                                .execute();
-                            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
-                                .selectFrom(metricsTbl)
-                                .select('execution_time')
-                                .orderBy('created_at', 'desc')
-                                .limit(20)
-                                .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
-                                    .selectFrom(metricsTbl)
-                                    .select('execution_time')
-                                    .orderBy('created_at', 'desc')
-                                    .offset(20)
-                                    .limit(100)
-                                    .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;
-                                }
-                            }
-                            break;
-                        default:
-                            success = true;
-                    }
+                    success = await this.runAuditAction(probe.script.split(':')[1]);
                 }
                 else {
-                    // Fallback to simple truthy check or simulation if not a known audit
-                    success = true;
+                    // Master Sentinel Pass: Dynamic Probe Evaluation
+                    // If not a hardcoded audit, use LLM to interpret the script against DB state
+                    success = await this.dynamicEvaluation(probe);
                 }
                 results.push({ name: probe.name, success });
-                await this.db
-                    .updateTable('agent_logic_probes')
-                    .set({
-                    last_run: new Date(),
-                    last_status: success ? 'pass' : 'fail',
-                })
-                    .where('id', '=', probe.id)
-                    .execute();
+                await this.db.transaction().execute(async (trx) => {
+                    // Audit Phase 13: Lock row before updating last_status
+                    await trx
+                        .selectFrom('agent_logic_probes')
+                        .select('id')
+                        .where('id', '=', probe.id)
+                        .forUpdate()
+                        .executeTakeFirst();
+                    await trx
+                        .updateTable('agent_logic_probes')
+                        .set({
+                        last_run: new Date(),
+                        last_status: success ? 'pass' : 'fail',
+                    })
+                        .where('id', '=', probe.id)
+                        .execute();
+                });
             }
             catch (e) {
                 results.push({ name: probe.name, success: false, error: String(e) });
@@ -165,4 +77,112 @@ export class SelfTestRegistry {
         }
         return results;
     }
+    async runAuditAction(action) {
+        switch (action) {
+            case 'check_schema_consistency':
+                const tables = await this.db.introspection.getTables();
+                const requiredSubsets = [
+                    this.config.messagesTable || 'agent_messages',
+                    this.config.sessionsTable || 'agent_sessions',
+                    this.config.memoriesTable || 'agent_memories',
+                    this.config.knowledgeTable || 'agent_knowledge_base',
+                    this.config.actionsTable || 'agent_actions',
+                    this.config.metricsTable || 'agent_metrics',
+                ];
+                const missing = requiredSubsets.filter((req) => !tables.some((t) => t.name === req));
+                return missing.length === 0;
+            case 'check_memory_integrity':
+                const memoriesTable = this.config.memoriesTable || 'agent_memories';
+                const invalidMemories = await this.db
+                    .selectFrom(memoriesTable)
+                    .select('id')
+                    .where('embedding', 'is', null)
+                    .execute();
+                return invalidMemories.length === 0;
+            case 'check_session_coherence':
+                const sessionsTable = this.config.sessionsTable || 'agent_sessions';
+                const messagesTable = this.config.messagesTable || 'agent_messages';
+                const emptySessions = await this.db
+                    .selectFrom(sessionsTable)
+                    .leftJoin(messagesTable, `${sessionsTable}.id`, `${messagesTable}.session_id`)
+                    .select(`${sessionsTable}.id as sid`)
+                    .where(`${messagesTable}.id`, 'is', null)
+                    .execute();
+                return emptySessions.length < 5;
+            case 'check_data_integrity':
+                const knowledgeTable = this.config.knowledgeTable || 'agent_knowledge_base';
+                const actionsTable = this.config.actionsTable || 'agent_actions';
+                const sessionsTbl = this.config.sessionsTable || 'agent_sessions';
+                const orphanedKnowledge = await this.db
+                    .selectFrom(knowledgeTable)
+                    .where('source_session_id', 'is not', null)
+                    .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)
+                    .select('id')
+                    .whereRef(`${actionsTable}.session_id`, '=', `${sessionsTbl}.id`))))
+                    .execute();
+                return orphanedKnowledge.length === 0 && orphanedActions.length === 0;
+            case 'check_performance_drift':
+                const metricsTbl = this.config.metricsTable || 'agent_metrics';
+                const recentMetrics = (await this.db
+                    .selectFrom(metricsTbl)
+                    .select('execution_time')
+                    .orderBy('created_at', 'desc')
+                    .limit(20)
+                    .execute());
+                if (recentMetrics.length < 5)
+                    return true;
+                const avgRecent = recentMetrics.reduce((sum, m) => sum + (m.execution_time || 0), 0) / recentMetrics.length;
+                const baselineMetrics = (await this.db
+                    .selectFrom(metricsTbl)
+                    .select('execution_time')
+                    .orderBy('created_at', 'desc')
+                    .offset(20)
+                    .limit(100)
+                    .execute());
+                if (baselineMetrics.length === 0)
+                    return avgRecent < 500;
+                const avgBaseline = baselineMetrics.reduce((sum, m) => sum + (m.execution_time || 0), 0) / baselineMetrics.length;
+                return avgRecent < avgBaseline * 1.5;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Interpret custom probe logic by providing the LLM with relevant database snapshots.
+     */
+    async dynamicEvaluation(probe) {
+        const model = this.cortex.llmFast || this.cortex.llm;
+        if (!model)
+            return true; // Safety fallback if no AI is available
+        // Provide a small sample of metrics and actions to allow for semantic reasoning
+        const sampleMetrics = await this.db.selectFrom(this.config.metricsTable || 'agent_metrics').limit(10).execute();
+        const prompt = `
+        You are a Logic Verification Engine for NOORMME.
+        TESTRUN: "${probe.name}"
+        SCRIPT: "${probe.script}"
+        EXPECTED: "${probe.expected_outcome || 'Unspecified'}"
+        
+        DB CONTEXT (Sample Metrics):
+        ${JSON.stringify(sampleMetrics, null, 2)}
+        
+        TASK:
+        Evaluate if the script passes based on the context.
+        If the script is a natural language requirement, infer the result. 
+        RETURN ONLY "PASS" OR "FAIL".
+      `;
+        const response = await model.complete({
+            prompt,
+            temperature: 0.1,
+            maxTokens: 5
+        });
+        return response.content.toUpperCase().includes('PASS');
+    }
 }

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

@@ -23,6 +23,7 @@ declare class AISynthesisStrategy implements SkillSynthesisStrategy {
         mutation: any;
     }[]>;
     private buildMutationPrompt;
+    private sanitizeInput;
 }
 /**
  * SkillSynthesizer implements Pass 6 Ultra-Scale Orchestration.

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

@@ -77,10 +77,10 @@ class AISynthesisStrategy {
             TOOLS TO MUTATE:
             ${contexts
             .map((ctx, i) => `
-                [Tool ${i + 1}: ${ctx.targetTool}]
-                Current Description: ${ctx.existingDescription || 'None'}
+                [Tool ${i + 1}: ${this.sanitizeInput(ctx.targetTool)}]
+                Current Description: ${this.sanitizeInput(ctx.existingDescription || 'None')}
                 Failure Patterns:
-                ${ctx.failures.map((f) => `- Args: ${JSON.stringify(f.arguments)}, Error: ${f.error}`).join('\n')}
+                ${ctx.failures.map((f) => `- Args: ${this.sanitizeInput(JSON.stringify(f.arguments))}, Error: ${this.sanitizeInput(f.error || 'None')}`).join('\n')}
             `)
             .join('\n')}
 
@@ -120,19 +120,23 @@ class AISynthesisStrategy {
     }
     buildMutationPrompt(context) {
         const failureList = context.failures
-            .map((f, i) => `${i + 1}. Args: ${JSON.stringify(f.arguments)}, Error: ${f.error || 'None'}`)
+            .map((f, i) => `${i + 1}. Args: ${this.sanitizeInput(JSON.stringify(f.arguments))}, Error: ${this.sanitizeInput(f.error || 'None')}`)
             .join('\n');
         return `
-            You are a Meta-Evolutionary AI Engine optimizing a tool: "${context.targetTool}".
+            You are a Meta-Evolutionary AI Engine optimizing a tool: "${this.sanitizeInput(context.targetTool)}".
             Analyze FAILURES and rewrite the description to prevent them.
             
-            EXISTING: "${context.existingDescription || 'None'}"
+            EXISTING: "${this.sanitizeInput(context.existingDescription || 'None')}"
             FAILURES:
             ${failureList}
 
             RETURN JSON: { "description": "...", "metadata": { "fixed": [...], "reason": "..." } }
         `;
     }
+    sanitizeInput(input) {
+        // Audit Phase 9: Neutralize prompt injection markers and control chars
+        return input.slice(0, 1000).replace(/[\u0000-\u001F\u007F-\u009F]/g, '').replace(/<\|.*?\|>/g, '');
+    }
 }
 /**
  * SkillSynthesizer implements Pass 6 Ultra-Scale Orchestration.
@@ -261,6 +265,8 @@ export class SkillSynthesizer {
         return await this.cortex.capabilities.registerCapability(tool, mutation.version, mutation.mutatedDescription, {
             initialStatus: 'experimental',
             mutatedFrom: tool,
+            lineage: mutation.mutatedMetadata?.lineage || tool,
+            variant_tag: `v${Date.now()}`,
             synthesis_engine: 'Ultra-Scale-Tiered',
             ...mutation.mutatedMetadata,
             synthesized_at: new Date(),
@@ -273,13 +279,16 @@ export class SkillSynthesizer {
             const toPrune = experimental
                 .sort((a, b) => a.reliability - b.reliability)
                 .slice(0, Math.ceil(experimental.length * 0.2));
-            for (const skill of toPrune) {
-                await this.db
-                    .deleteFrom(this.cortex.agenticConfig.capabilitiesTable ||
-                    'agent_capabilities')
-                    .where('id', '=', skill.id)
-                    .execute();
-            }
+            // Audit Phase 19: Transactional pruning
+            await this.db.transaction().execute(async (trx) => {
+                for (const skill of toPrune) {
+                    await trx
+                        .deleteFrom(this.cortex.agenticConfig.capabilitiesTable ||
+                        'agent_capabilities')
+                        .where('id', '=', skill.id)
+                        .execute();
+                }
+            });
         }
     }
 }

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

@@ -81,6 +81,7 @@ export declare class StrategicPlanner {
      * Revert the last mutation for a persona.
      */
     rollbackPersona(id: string | number): Promise<string>;
+    private sanitizeRole;
     private parsePersona;
 }
 export {};