noormme 1.0.6 → 1.2.0

package/dist/cjs/util/security-validator.js

@@ -62,7 +62,12 @@ function validateIdentifier(identifier, context = 'identifier') {
     }
     // Additional check: prevent reserved SQLite keywords that could be dangerous
     const reservedKeywords = [
-        'PRAGMA', 'ATTACH', 'DETACH', 'VACUUM', 'ANALYZE', 'REINDEX'
+        'PRAGMA',
+        'ATTACH',
+        'DETACH',
+        'VACUUM',
+        'ANALYZE',
+        'REINDEX',
     ];
     for (const keyword of reservedKeywords) {
         if (identifier.toUpperCase() === keyword) {
@@ -83,7 +88,11 @@ function validateTableReference(tableRef) {
     }
     // Validate each part
     parts.forEach((part, index) => {
-        const context = index === 0 ? (parts.length === 2 ? 'schema name' : 'table name') : 'table name';
+        const context = index === 0
+            ? parts.length === 2
+                ? 'schema name'
+                : 'table name'
+            : 'table name';
         validateIdentifier(part, context);
     });
 }
@@ -108,7 +117,8 @@ function validateColumnReference(columnRef) {
             context = index === 0 ? 'table name' : 'column name';
         }
         else {
-            context = index === 0 ? 'schema name' : (index === 1 ? 'table name' : 'column name');
+            context =
+                index === 0 ? 'schema name' : index === 1 ? 'table name' : 'column name';
         }
         validateIdentifier(part, context);
     });
@@ -140,7 +150,7 @@ function validateFilePath(filePath, allowedExtensions) {
     }
     // Validate file extension if specified
     if (allowedExtensions && allowedExtensions.length > 0) {
-        const hasValidExtension = allowedExtensions.some(ext => filePath.toLowerCase().endsWith(ext.toLowerCase()));
+        const hasValidExtension = allowedExtensions.some((ext) => filePath.toLowerCase().endsWith(ext.toLowerCase()));
         if (!hasValidExtension) {
             throw new Error(`Invalid file extension for "${filePath}". ` +
                 `Allowed extensions: ${allowedExtensions.join(', ')}`);
@@ -164,7 +174,9 @@ function validateFilePath(filePath, allowedExtensions) {
 function sanitizeDatabasePath(dbPath) {
     validateFilePath(dbPath, ['.db', '.sqlite', '.sqlite3', '.db3']);
     // Ensure the path doesn't escape current directory
-    if (dbPath.includes('..') || dbPath.startsWith('/') || /^[a-zA-Z]:/.test(dbPath)) {
+    if (dbPath.includes('..') ||
+        dbPath.startsWith('/') ||
+        /^[a-zA-Z]:/.test(dbPath)) {
         throw new Error(`Database path "${dbPath}" must be a relative path within the current directory`);
     }
     return dbPath;
@@ -221,8 +233,7 @@ class RateLimiter {
     maxAttempts;
     windowMs;
     attempts = new Map();
-    constructor(maxAttempts = 10, windowMs = 60000 // 1 minute
-    ) {
+    constructor(maxAttempts = 10, windowMs = 60000) {
         this.maxAttempts = maxAttempts;
         this.windowMs = windowMs;
     }
@@ -230,7 +241,7 @@ class RateLimiter {
         const now = Date.now();
         const attempts = this.attempts.get(key) || [];
         // Remove old attempts outside the window
-        const recentAttempts = attempts.filter(time => now - time < this.windowMs);
+        const recentAttempts = attempts.filter((time) => now - time < this.windowMs);
         if (recentAttempts.length >= this.maxAttempts) {
             throw new Error(`Rate limit exceeded for ${key}. Please wait before trying again.`);
         }
@@ -243,7 +254,7 @@ class RateLimiter {
     }
     cleanup(now) {
         for (const [key, attempts] of this.attempts.entries()) {
-            const recentAttempts = attempts.filter(time => now - time < this.windowMs);
+            const recentAttempts = attempts.filter((time) => now - time < this.windowMs);
             if (recentAttempts.length === 0) {
                 this.attempts.delete(key);
             }

package/dist/cjs/utils/errorHelpers.js

@@ -26,11 +26,15 @@ function wrapKyselyError(error, context) {
         }
     }
     // Handle connection errors
-    if (message.includes('connect') || message.includes('ECONNREFUSED') || message.includes('ENOTFOUND')) {
+    if (message.includes('connect') ||
+        message.includes('ECONNREFUSED') ||
+        message.includes('ENOTFOUND')) {
         return new NoormError_js_1.ConnectionError(message, error);
     }
     // Handle authentication errors
-    if (message.includes('authentication') || message.includes('password') || message.includes('SASL')) {
+    if (message.includes('authentication') ||
+        message.includes('password') ||
+        message.includes('SASL')) {
         return new NoormError_js_1.ConnectionError('Authentication failed. Check your username and password.', error);
     }
     // Handle syntax errors
@@ -38,17 +42,19 @@ function wrapKyselyError(error, context) {
         return new NoormError_js_1.NoormError(`SQL syntax error: ${message}`, {
             table: context.table,
             operation: context.operation,
-            suggestion: 'Check your query syntax or report this as a bug if you\'re using NOORMME methods',
-            originalError: error
+            suggestion: "Check your query syntax or report this as a bug if you're using NOORMME methods",
+            originalError: error,
         });
     }
     // Handle constraint violations
-    if (message.includes('constraint') || message.includes('duplicate') || message.includes('unique')) {
+    if (message.includes('constraint') ||
+        message.includes('duplicate') ||
+        message.includes('unique')) {
         return new NoormError_js_1.NoormError(`Database constraint violation: ${extractConstraintMessage(message)}`, {
             table: context.table,
             operation: context.operation,
             suggestion: 'Check for duplicate values or foreign key violations',
-            originalError: error
+            originalError: error,
         });
     }
     // Generic wrapper for other errors
@@ -56,7 +62,7 @@ function wrapKyselyError(error, context) {
         table: context.table,
         operation: context.operation,
         suggestion: 'Check the database connection and query parameters',
-        originalError: error
+        originalError: error,
     });
 }
 /**
@@ -121,14 +127,15 @@ function suggestCorrections(input, available, maxSuggestions = 3) {
     const suggestions = [];
     for (const option of available) {
         const score = calculateSimilarity(input.toLowerCase(), option.toLowerCase());
-        if (score > 0.3) { // Only suggest if similarity > 30%
+        if (score > 0.3) {
+            // Only suggest if similarity > 30%
             suggestions.push({ name: option, score });
         }
     }
     return suggestions
         .sort((a, b) => b.score - a.score)
         .slice(0, maxSuggestions)
-        .map(s => s.name);
+        .map((s) => s.name);
 }
 /**
  * Calculate string similarity using Jaro-Winkler algorithm (simplified)
@@ -173,7 +180,10 @@ function calculateSimilarity(str1, str2) {
             transpositions++;
         k++;
     }
-    const jaro = (matches / len1 + matches / len2 + (matches - transpositions / 2) / matches) / 3;
+    const jaro = (matches / len1 +
+        matches / len2 +
+        (matches - transpositions / 2) / matches) /
+        3;
     // Jaro-Winkler bonus for common prefix
     let prefix = 0;
     for (let i = 0; i < Math.min(len1, len2, 4); i++) {

package/dist/cjs/watch/schema-watcher.js

@@ -27,7 +27,7 @@ class SchemaWatcher {
             ignoreViews: true,
             ignoredTables: [],
             enabled: options.enabled !== undefined ? options.enabled : defaultEnabled,
-            ...options
+            ...options,
         };
     }
     /**
@@ -57,7 +57,7 @@ class SchemaWatcher {
         }
         this.isWatching = true;
         this.intervalId = setInterval(() => {
-            this.checkForChanges().catch(error => {
+            this.checkForChanges().catch((error) => {
                 this.logger.error('Error checking for schema changes:', error);
             });
         }, this.options.pollInterval);
@@ -141,23 +141,22 @@ class SchemaWatcher {
         // Create a deterministic string representation of the schema
         const schemaString = JSON.stringify({
             tables: schema.tables
-                .filter(table => !this.options.ignoredTables?.includes(table.name))
-                .map(table => ({
+                .filter((table) => !this.options.ignoredTables?.includes(table.name))
+                .map((table) => ({
                 name: table.name,
-                columns: table.columns.map(col => ({
+                columns: table.columns.map((col) => ({
                     name: col.name,
                     type: col.type,
                     nullable: col.nullable,
                     isPrimaryKey: col.isPrimaryKey,
-                    defaultValue: col.defaultValue
+                    defaultValue: col.defaultValue,
                 })),
                 primaryKey: table.primaryKey,
                 foreignKeys: table.foreignKeys,
-                indexes: table.indexes
+                indexes: table.indexes,
             }))
                 .sort((a, b) => a.name.localeCompare(b.name)),
-            relationships: schema.relationships
-                .sort((a, b) => `${a.fromTable}.${a.name}`.localeCompare(`${b.fromTable}.${b.name}`))
+            relationships: schema.relationships.sort((a, b) => `${a.fromTable}.${a.name}`.localeCompare(`${b.fromTable}.${b.name}`)),
         });
         return (0, node_crypto_1.createHash)('sha256').update(schemaString).digest('hex');
     }
@@ -175,20 +174,20 @@ class SchemaWatcher {
                 changes.push({
                     type: 'table_added',
                     table: table.name,
-                    details: { columns: table.columns.length }
+                    details: { columns: table.columns.length },
                 });
             }
             return changes;
         }
-        const oldTablesMap = new Map(oldSchema.tables.map(t => [t.name, t]));
-        const newTablesMap = new Map(newSchema.tables.map(t => [t.name, t]));
+        const oldTablesMap = new Map(oldSchema.tables.map((t) => [t.name, t]));
+        const newTablesMap = new Map(newSchema.tables.map((t) => [t.name, t]));
         // Check for added tables
         for (const table of newSchema.tables) {
             if (!oldTablesMap.has(table.name)) {
                 changes.push({
                     type: 'table_added',
                     table: table.name,
-                    details: { columns: table.columns.length }
+                    details: { columns: table.columns.length },
                 });
             }
         }
@@ -197,7 +196,7 @@ class SchemaWatcher {
             if (!newTablesMap.has(table.name)) {
                 changes.push({
                     type: 'table_removed',
-                    table: table.name
+                    table: table.name,
                 });
             }
         }
@@ -205,8 +204,8 @@ class SchemaWatcher {
         for (const newTable of newSchema.tables) {
             const oldTable = oldTablesMap.get(newTable.name);
             if (oldTable) {
-                const oldColumnsMap = new Map(oldTable.columns.map(c => [c.name, c]));
-                const newColumnsMap = new Map(newTable.columns.map(c => [c.name, c]));
+                const oldColumnsMap = new Map(oldTable.columns.map((c) => [c.name, c]));
+                const newColumnsMap = new Map(newTable.columns.map((c) => [c.name, c]));
                 // Check for added columns
                 for (const column of newTable.columns) {
                     if (!oldColumnsMap.has(column.name)) {
@@ -214,7 +213,7 @@ class SchemaWatcher {
                             type: 'column_added',
                             table: newTable.name,
                             column: column.name,
-                            details: { type: column.type }
+                            details: { type: column.type },
                         });
                     }
                 }
@@ -224,7 +223,7 @@ class SchemaWatcher {
                         changes.push({
                             type: 'column_removed',
                             table: newTable.name,
-                            column: column.name
+                            column: column.name,
                         });
                     }
                     else {
@@ -237,8 +236,8 @@ class SchemaWatcher {
                                 column: column.name,
                                 details: {
                                     old: { type: column.type, nullable: column.nullable },
-                                    new: { type: newColumn.type, nullable: newColumn.nullable }
-                                }
+                                    new: { type: newColumn.type, nullable: newColumn.nullable },
+                                },
                             });
                         }
                     }
@@ -248,15 +247,15 @@ class SchemaWatcher {
         return changes;
     }
     isColumnModified(oldCol, newCol) {
-        return oldCol.type !== newCol.type ||
+        return (oldCol.type !== newCol.type ||
             oldCol.nullable !== newCol.nullable ||
-            oldCol.isPrimaryKey !== newCol.isPrimaryKey;
+            oldCol.isPrimaryKey !== newCol.isPrimaryKey);
     }
     /**
      * Notify all registered callbacks about schema changes
      */
     notifyCallbacks(changes) {
-        this.callbacks.forEach(callback => {
+        this.callbacks.forEach((callback) => {
             try {
                 callback(changes);
             }

package/dist/esm/agentic/ActionJournal.js

@@ -29,7 +29,7 @@ export class ActionJournal {
             tool_name: toolName,
             arguments: JSON.stringify(args),
             status: 'pending',
-            created_at: new Date()
+            created_at: new Date(),
         })
             .returningAll()
             .executeTakeFirstOrThrow();
@@ -50,7 +50,7 @@ export class ActionJournal {
             status,
             outcome,
             duration_ms: durationMs || null,
-            metadata: metadata ? JSON.stringify(metadata) : null
+            metadata: metadata ? JSON.stringify(metadata) : null,
         })
             .where('id', '=', actionId)
             .returningAll()
@@ -74,7 +74,7 @@ export class ActionJournal {
             .where('session_id', '=', sessionId)
             .orderBy('created_at', 'asc')
             .execute();
-        return actions.map(a => this.parseAction(a));
+        return actions.map((a) => this.parseAction(a));
     }
     /**
      * Get actions by tool name across all sessions.
@@ -87,7 +87,7 @@ export class ActionJournal {
             .orderBy('created_at', 'desc')
             .limit(limit)
             .execute();
-        return actions.map(a => this.parseAction(a));
+        return actions.map((a) => this.parseAction(a));
     }
     /**
      * Generate a report of tool failures.
@@ -98,7 +98,7 @@ export class ActionJournal {
             .select([
             'tool_name',
             (eb) => eb.fn.count('id').as('failureCount'),
-            (eb) => eb.fn.max('created_at').as('lastFailure')
+            (eb) => eb.fn.max('created_at').as('lastFailure'),
         ])
             .where('status', '=', 'failure')
             .groupBy('tool_name')
@@ -107,7 +107,7 @@ export class ActionJournal {
         return results.map((r) => ({
             toolName: r.tool_name,
             failureCount: Number(r.failureCount),
-            lastFailure: r.lastFailure
+            lastFailure: r.lastFailure,
         }));
     }
     parseAction(action) {
@@ -116,12 +116,16 @@ export class ActionJournal {
             sessionId: action.session_id,
             messageId: action.message_id,
             toolName: action.tool_name,
-            arguments: typeof action.arguments === 'string' ? JSON.parse(action.arguments) : (action.arguments || {}),
+            arguments: typeof action.arguments === 'string'
+                ? JSON.parse(action.arguments)
+                : action.arguments || {},
             status: action.status,
             outcome: action.outcome,
             durationMs: action.duration_ms,
-            metadata: typeof action.metadata === 'string' ? JSON.parse(action.metadata) : (action.metadata || {}),
-            createdAt: new Date(action.created_at)
+            metadata: typeof action.metadata === 'string'
+                ? JSON.parse(action.metadata)
+                : action.metadata || {},
+            createdAt: new Date(action.created_at),
         };
     }
 }

package/dist/esm/agentic/CapabilityManager.d.ts

@@ -1,10 +1,12 @@
 import type { Kysely } from '../kysely.js';
-import type { AgenticConfig, AgentCapability } from '../types/index.js';
+import { AgenticConfig, AgentCapability } from '../types/index.js';
+import type { Cortex } from './Cortex.js';
 export interface CapabilityTable {
     id: number | string;
     name: string;
     version: string;
     description: string | null;
+    status: 'experimental' | 'verified' | 'blacklisted';
     reliability: number;
     metadata: string | null;
     created_at: string | Date;
@@ -19,9 +21,11 @@ export interface CapabilityDatabase {
  */
 export declare class CapabilityManager {
     private db;
+    private cortex;
     private config;
     private capabilitiesTable;
-    constructor(db: Kysely<any>, config?: AgenticConfig);
+    private evolutionConfig;
+    constructor(db: Kysely<any>, cortex: Cortex, config?: AgenticConfig);
     private get typedDb();
     /**
      * Register or update a capability (skill)
@@ -29,6 +33,7 @@ export declare class CapabilityManager {
     registerCapability(name: string, version: string, description?: string, metadata?: Record<string, any>): Promise<AgentCapability>;
     /**
      * Update reliability based on action outcome using a damped moving average.
+     * Manages the lifecycle of emergent skills (sandbox -> verified / blacklisted).
      */
     reportOutcome(name: string, success: boolean): Promise<void>;
     /**
@@ -36,8 +41,8 @@ export declare class CapabilityManager {
      */
     getReliability(name: string): Promise<number>;
     /**
-     * Get all registered capabilities
+     * Get all registered capabilities, optionally filtered by status
      */
-    getCapabilities(): Promise<AgentCapability[]>;
+    getCapabilities(status?: AgentCapability['status']): Promise<AgentCapability[]>;
     private parseCapability;
 }

package/dist/esm/agentic/CapabilityManager.js

@@ -5,12 +5,22 @@
  */
 export class CapabilityManager {
     db;
+    cortex;
     config;
     capabilitiesTable;
-    constructor(db, config = {}) {
+    evolutionConfig;
+    constructor(db, cortex, config = {}) {
         this.db = db;
+        this.cortex = cortex;
         this.config = config;
         this.capabilitiesTable = config.capabilitiesTable || 'agent_capabilities';
+        this.evolutionConfig = {
+            verificationWindow: config.evolution?.verificationWindow ?? 20,
+            rollbackThresholdZ: config.evolution?.rollbackThresholdZ ?? 2.5,
+            enableHiveLink: config.evolution?.enableHiveLink ?? true,
+            mutationAggressiveness: config.evolution?.mutationAggressiveness ?? 0.5,
+            maxSandboxSkills: config.evolution?.maxSandboxSkills ?? 5,
+        };
     }
     get typedDb() {
         return this.db;
@@ -31,8 +41,12 @@ export class CapabilityManager {
                     .updateTable(this.capabilitiesTable)
                     .set({
                     description: description || existing.description,
-                    metadata: JSON.stringify({ ...JSON.parse(existing.metadata || '{}'), ...metadata }),
-                    updated_at: new Date()
+                    status: existing.status || 'experimental',
+                    metadata: JSON.stringify({
+                        ...JSON.parse(existing.metadata || '{}'),
+                        ...metadata,
+                    }),
+                    updated_at: new Date(),
                 })
                     .where('id', '=', existing.id)
                     .returningAll()
@@ -45,10 +59,15 @@ export class CapabilityManager {
                 name,
                 version,
                 description: description || null,
+                status: metadata.initialStatus || 'experimental',
                 reliability: 1.0,
-                metadata: JSON.stringify({ ...metadata, successCount: 0, totalCount: 0 }),
+                metadata: JSON.stringify({
+                    ...metadata,
+                    successCount: 0,
+                    totalCount: 0,
+                }),
                 created_at: new Date(),
-                updated_at: new Date()
+                updated_at: new Date(),
             })
                 .returningAll()
                 .executeTakeFirstOrThrow();
@@ -57,6 +76,7 @@ export class CapabilityManager {
     }
     /**
      * Update reliability based on action outcome using a damped moving average.
+     * Manages the lifecycle of emergent skills (sandbox -> verified / blacklisted).
      */
     async reportOutcome(name, success) {
         await this.db.transaction().execute(async (trx) => {
@@ -68,7 +88,9 @@ export class CapabilityManager {
                 .executeTakeFirst();
             if (capability) {
                 const cap = capability;
-                const metadata = typeof cap.metadata === 'string' ? JSON.parse(cap.metadata) : (cap.metadata || {});
+                const metadata = typeof cap.metadata === 'string'
+                    ? JSON.parse(cap.metadata)
+                    : cap.metadata || {};
                 const totalCount = (metadata.totalCount || 0) + 1;
                 const successCount = (metadata.successCount || 0) + (success ? 1 : 0);
                 // Damped moving average: weight recent outcomes more but keep history
@@ -78,12 +100,81 @@ export class CapabilityManager {
                 const newReliability = success
                     ? Math.min(1.0, currentReliability * (1 - alpha) + alpha)
                     : Math.max(0.0, currentReliability * (1 - alpha));
+                let newStatus = cap.status || 'experimental';
+                // --- Emergent Skill Evolution Optimization ---
+                const successStreak = (metadata.successStreak || 0) + (success ? 1 : 0);
+                const failureStreak = success ? 0 : (metadata.failureStreak || 0) + 1;
+                const streakSuccess = success ? successStreak : 0;
+                const winRate = successCount / totalCount;
+                const windowSize = this.evolutionConfig.verificationWindow || 20;
+                const minSampleSize = Math.ceil(windowSize * 0.75);
+                // Fast-Track Promotion: 5 consecutive successes bypasses sample size
+                const isPromotable = (totalCount >= minSampleSize && winRate >= 0.8) || streakSuccess >= 5;
+                // Early-Exit Rollback: 3 consecutive failures at the start immediately blacklists
+                const isCatastrophic = !success && failureStreak >= 3 && totalCount <= 5;
+                // Pass 6: Predictive Pre-warming Trigger
+                // If a skill is close to promotion, pre-warm its optimized description
+                const promoThreshold = Math.ceil(minSampleSize * 0.8);
+                const isNearingPromotion = (totalCount >= promoThreshold && winRate >= 0.8) ||
+                    streakSuccess === 4;
+                if (isNearingPromotion &&
+                    newStatus === 'experimental' &&
+                    this.cortex.skillSynthesizer) {
+                    // Trigger async background pre-warming
+                    this.cortex.skillSynthesizer.preWarmSkill(name).catch(() => { });
+                }
+                // --- Production Hardening: Dynamic Performance Baselining ---
+                const historyAlpha = 0.05; // Slower moving average for baseline
+                const baseline = metadata.performanceBaseline ?? winRate;
+                const newBaseline = baseline * (1 - historyAlpha) + winRate * historyAlpha;
+                // Variance tracking for Z-score calculation
+                const variance = metadata.performanceVariance ?? 0.01;
+                const diff = winRate - baseline;
+                const newVariance = variance * (1 - historyAlpha) + Math.pow(diff, 2) * historyAlpha;
+                const stdDev = Math.sqrt(newVariance);
+                // Z-Score: How many standard deviations is current performance from baseline?
+                const zScore = stdDev > 0 ? (winRate - baseline) / stdDev : 0;
+                // Promotion/Demotion Logic
+                if (isCatastrophic &&
+                    (newStatus === 'experimental' || newStatus === 'sandbox')) {
+                    console.error(`[CapabilityManager] Skill '${name}' FAILED early-exit safety check (Streak: ${failureStreak}). Blacklisting immediately.`);
+                    newStatus = 'blacklisted';
+                }
+                else if (isPromotable &&
+                    (newStatus === 'experimental' || newStatus === 'sandbox')) {
+                    console.log(`[CapabilityManager] Skill '${name}' PASSED fast-track verification (Streak: ${streakSuccess}, Rate: ${(winRate * 100).toFixed(1)}%). Promoting to Verified.`);
+                    newStatus = 'verified';
+                }
+                else if (totalCount >= minSampleSize) {
+                    if (winRate < 0.4) {
+                        console.log(`[CapabilityManager] Skill '${name}' FAILED statistical verification (Rate: ${(winRate * 100).toFixed(1)}%). Blacklisting.`);
+                        newStatus = 'blacklisted';
+                    }
+                    else if (newStatus === 'verified' && zScore < -2.0) {
+                        // Performance Collapse: Z-score indicates current run is significantly below historical baseline
+                        console.warn(`[CapabilityManager] Verified skill '${name}' PERFORMANCE COLLAPSE (Z: ${zScore.toFixed(2)}, Rate: ${(winRate * 100).toFixed(1)}%). Demoting to Experimental.`);
+                        newStatus = 'experimental';
+                    }
+                }
+                if (newStatus !== cap.status) {
+                    console.log(`[CapabilityManager] EVOLVING STATUS: ${name} (${cap.status} -> ${newStatus})`);
+                }
                 await trx
                     .updateTable(this.capabilitiesTable)
                     .set({
                     reliability: newReliability,
-                    metadata: JSON.stringify({ ...metadata, totalCount, successCount }),
-                    updated_at: new Date()
+                    status: newStatus,
+                    metadata: JSON.stringify({
+                        ...metadata,
+                        totalCount,
+                        successCount,
+                        successStreak: streakSuccess,
+                        failureStreak,
+                        performanceBaseline: newBaseline,
+                        performanceVariance: newVariance,
+                        lastOutcomeType: success ? 'success' : 'failure', // Categorization point
+                    }),
+                    updated_at: new Date(),
                 })
                     .where('id', '=', cap.id)
                     .execute();
@@ -103,15 +194,17 @@ export class CapabilityManager {
         return cap ? cap.reliability : 0.0;
     }
     /**
-     * Get all registered capabilities
+     * Get all registered capabilities, optionally filtered by status
      */
-    async getCapabilities() {
-        const list = await this.typedDb
+    async getCapabilities(status) {
+        let query = this.typedDb
             .selectFrom(this.capabilitiesTable)
-            .selectAll()
-            .orderBy('name', 'asc')
-            .execute();
-        return list.map(c => this.parseCapability(c));
+            .selectAll();
+        if (status) {
+            query = query.where('status', '=', status);
+        }
+        const list = await query.orderBy('name', 'asc').execute();
+        return list.map((c) => this.parseCapability(c));
     }
     parseCapability(cap) {
         return {
@@ -119,10 +212,13 @@ export class CapabilityManager {
             name: cap.name,
             version: cap.version,
             description: cap.description,
+            status: cap.status || 'experimental',
             reliability: cap.reliability,
-            metadata: typeof cap.metadata === 'string' ? JSON.parse(cap.metadata) : (cap.metadata || {}),
+            metadata: typeof cap.metadata === 'string'
+                ? JSON.parse(cap.metadata)
+                : cap.metadata || {},
             createdAt: new Date(cap.created_at),
-            updatedAt: new Date(cap.updated_at)
+            updatedAt: new Date(cap.updated_at),
         };
     }
 }