agentic-qe 3.7.21 → 3.8.0

package/dist/cli/commands/audit.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Agentic QE v3 - Audit Command
+ *
+ * Verifies the witness chain audit trail integrity.
+ * Shows chain length, integrity status, and last receipt hash.
+ *
+ * Usage: aqe audit verify [--format json|text]
+ *
+ * @module cli/commands/audit
+ * @see ADR-083-coherence-gated-agent-actions.md
+ */
+import { Command } from 'commander';
+import { type ChainVerificationResult } from '../../governance/witness-chain.js';
+import type { CLIContext } from '../handlers/interfaces.js';
+/**
+ * Verification output for JSON format.
+ */
+export interface AuditVerifyOutput {
+    featureEnabled: boolean;
+    chainLength: number;
+    integrity: boolean;
+    brokenAt: number;
+    lastHash: string;
+    message: string;
+}
+/**
+ * Format verification result as human-readable text.
+ */
+export declare function formatVerificationText(result: ChainVerificationResult, featureEnabled: boolean): string;
+/**
+ * Handle the audit verify command.
+ *
+ * Loads the witness chain from SQLite if available, otherwise creates
+ * a fresh in-memory chain.
+ */
+export declare function handleAuditVerify(options: {
+    format?: 'json' | 'text';
+}): Promise<AuditVerifyOutput>;
+/**
+ * Create the audit command group following the project convention.
+ */
+export declare function createAuditCommand(_context: CLIContext, cleanupAndExit: (code: number) => Promise<never>, _ensureInitialized: () => Promise<boolean>): Command;
+//# sourceMappingURL=audit.d.ts.map

package/dist/cli/commands/audit.js

@@ -0,0 +1,125 @@
+/**
+ * Agentic QE v3 - Audit Command
+ *
+ * Verifies the witness chain audit trail integrity.
+ * Shows chain length, integrity status, and last receipt hash.
+ *
+ * Usage: aqe audit verify [--format json|text]
+ *
+ * @module cli/commands/audit
+ * @see ADR-083-coherence-gated-agent-actions.md
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { createWitnessChain, createPersistentWitnessChain, createWitnessChainSQLitePersistence, isWitnessChainFeatureEnabled, } from '../../governance/witness-chain.js';
+import { findProjectRoot } from '../../kernel/unified-memory.js';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+/**
+ * Format verification result as human-readable text.
+ */
+export function formatVerificationText(result, featureEnabled) {
+    const lines = [];
+    lines.push(chalk.bold('Witness Chain Audit Verification'));
+    lines.push('');
+    // Feature flag status
+    const flagStatus = featureEnabled
+        ? chalk.green('ENABLED')
+        : chalk.yellow('DISABLED');
+    lines.push(`  Feature Flag: ${flagStatus}`);
+    // Chain length
+    lines.push(`  Chain Length:  ${result.length} receipts`);
+    // Integrity status
+    const integrityStatus = result.valid
+        ? chalk.green('VALID')
+        : chalk.red('BROKEN');
+    lines.push(`  Integrity:    ${integrityStatus}`);
+    // Last hash
+    if (result.length > 0) {
+        lines.push(`  Last Hash:    ${result.lastHash.slice(0, 16)}...`);
+    }
+    // Details
+    if (!result.valid && result.brokenAt >= 0) {
+        lines.push('');
+        lines.push(chalk.red(`  Break detected at index ${result.brokenAt}`));
+        lines.push(chalk.red(`  ${result.message}`));
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Try to load a SQLite-backed witness chain from the project's unified database.
+ * Returns null if the database is unavailable.
+ */
+function tryLoadPersistentChain() {
+    try {
+        const root = findProjectRoot();
+        const dbPath = path.join(root, '.agentic-qe', 'memory.db');
+        if (!existsSync(dbPath))
+            return null;
+        // Dynamic import to avoid hard dependency on better-sqlite3 at CLI load time
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const Database = require('better-sqlite3');
+        const db = new Database(dbPath);
+        const persistence = createWitnessChainSQLitePersistence(db);
+        const chain = createPersistentWitnessChain(persistence);
+        // Close the DB handle; chain data is now loaded into memory
+        db.close();
+        return chain;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Handle the audit verify command.
+ *
+ * Loads the witness chain from SQLite if available, otherwise creates
+ * a fresh in-memory chain.
+ */
+export async function handleAuditVerify(options) {
+    const featureEnabled = isWitnessChainFeatureEnabled();
+    // Load persisted chain from SQLite if available, else in-memory
+    const chain = tryLoadPersistentChain() ?? createWitnessChain();
+    const result = chain.verifyChain();
+    const output = {
+        featureEnabled,
+        chainLength: result.length,
+        integrity: result.valid,
+        brokenAt: result.brokenAt,
+        lastHash: result.lastHash,
+        message: result.message,
+    };
+    if (options.format === 'json') {
+        console.log(JSON.stringify(output, null, 2));
+    }
+    else {
+        console.log(formatVerificationText(result, featureEnabled));
+    }
+    return output;
+}
+/**
+ * Create the audit command group following the project convention.
+ */
+export function createAuditCommand(_context, cleanupAndExit, _ensureInitialized) {
+    const audit = new Command('audit')
+        .description('Witness chain audit trail management');
+    audit
+        .command('verify')
+        .description('Verify witness chain integrity')
+        .option('-F, --format <format>', 'Output format (json|text)', 'text')
+        .action(async (options) => {
+        try {
+            await handleAuditVerify({
+                format: options.format,
+            });
+            await cleanupAndExit(0);
+        }
+        catch (error) {
+            console.error('Failed to verify witness chain:', error);
+            await cleanupAndExit(1);
+        }
+    });
+    return audit;
+}
+//# sourceMappingURL=audit.js.map

package/dist/cli/commands/hooks.js

@@ -358,7 +358,24 @@ async function consolidateExperiencesToPatterns() {
         await um.initialize();
     }
     const db = um.getDatabase();
-    // Aggregate unprocessed experiences by domain+agent with quality thresholds
+    // Ensure consolidation columns exist (may be missing on older DBs)
+    const existingCols = new Set(db.prepare('PRAGMA table_info(captured_experiences)').all().map(c => c.name));
+    const migrations = [
+        ['consolidated_into', 'TEXT DEFAULT NULL'],
+        ['consolidation_count', 'INTEGER DEFAULT 1'],
+        ['quality_updated_at', 'TEXT DEFAULT NULL'],
+        ['reuse_success_count', 'INTEGER DEFAULT 0'],
+        ['reuse_failure_count', 'INTEGER DEFAULT 0'],
+    ];
+    for (const [col, def] of migrations) {
+        if (!existingCols.has(col)) {
+            db.exec(`ALTER TABLE captured_experiences ADD COLUMN ${col} ${def}`);
+        }
+    }
+    // Aggregate unprocessed experiences by domain+agent with quality thresholds.
+    // Exclude 'cli-hook' agent — these are low-quality hook telemetry events
+    // (quality ~0.40, success_rate ~0.24) that flood the pipeline and block
+    // real pattern creation. See issue #348.
     const aggregates = db.prepare(`
     SELECT
       domain,
@@ -371,6 +388,7 @@ async function consolidateExperiencesToPatterns() {
       GROUP_CONCAT(DISTINCT source) as sources
     FROM captured_experiences
     WHERE application_count = 0
+      AND agent != 'cli-hook'
     GROUP BY domain, agent
     HAVING cnt >= 3 AND avg_quality >= 0.5 AND success_rate >= 0.6
     ORDER BY avg_quality DESC
@@ -382,20 +400,25 @@ async function consolidateExperiencesToPatterns() {
     let created = 0;
     for (const agg of aggregates) {
         try {
-            // Check for existing pattern with same domain+agent to avoid duplicates
+            // Use date-bucketed names so new patterns emerge as usage evolves,
+            // instead of silently reinforcing one static pattern forever.
+            const dateBucket = new Date().toISOString().slice(0, 7); // YYYY-MM
+            const patternName = `${agg.agent}-${agg.domain}-${dateBucket}`;
+            // Check for existing pattern with same name this month
             const existing = db.prepare(`
         SELECT id FROM qe_patterns
         WHERE qe_domain = ? AND name = ?
         LIMIT 1
-      `).get(agg.domain, `${agg.agent}-session-pattern`);
+      `).get(agg.domain, patternName);
             if (existing) {
-                // Reinforce existing pattern instead of creating duplicate
+                // Reinforce existing monthly pattern
                 db.prepare(`
           UPDATE qe_patterns
           SET usage_count = usage_count + ?,
               successful_uses = successful_uses + ?,
               confidence = MIN(0.99, confidence + 0.01),
-              quality_score = MIN(0.99, quality_score + 0.005)
+              quality_score = MIN(0.99, quality_score + 0.005),
+              updated_at = datetime('now')
           WHERE id = ?
         `).run(agg.cnt, agg.successes, existing.id);
             }
@@ -409,7 +432,7 @@ async function consolidateExperiencesToPatterns() {
             confidence, usage_count, success_rate, quality_score, tier,
             template_json, context_json, created_at, successful_uses
           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), ?)
-        `).run(patternId, 'workflow', agg.domain, agg.domain, `${agg.agent}-session-pattern`, `Auto-consolidated from ${agg.cnt} experiences. Agent: ${agg.agent}, success rate: ${(agg.success_rate * 100).toFixed(0)}%`, confidence, agg.cnt, agg.success_rate, qualityScore, 'short-term', JSON.stringify({ type: 'workflow', content: `${agg.agent} pattern for ${agg.domain}`, variables: [] }), JSON.stringify({ tags: (agg.sources || '').split(','), sourceType: 'session-consolidation', extractedAt: new Date().toISOString() }), agg.successes);
+        `).run(patternId, 'workflow', agg.domain, agg.domain, patternName, `Auto-consolidated from ${agg.cnt} experiences. Agent: ${agg.agent}, success rate: ${(agg.success_rate * 100).toFixed(0)}%`, confidence, agg.cnt, agg.success_rate, qualityScore, 'short-term', JSON.stringify({ type: 'workflow', content: `${agg.agent} pattern for ${agg.domain}`, variables: [] }), JSON.stringify({ tags: (agg.sources || '').split(','), sourceType: 'session-consolidation', extractedAt: new Date().toISOString() }), agg.successes);
                 created++;
             }
             // Mark experiences as processed

package/dist/cli/commands/init.js

@@ -28,7 +28,6 @@ export function createInitCommand() {
         .description('Initialize Agentic QE v3 in your project')
         .option('-a, --auto', 'Auto-configure without prompts')
         .option('-u, --upgrade', 'Upgrade existing installation (overwrites skills, agents, validation)')
-        .option('--auto-migrate', 'Automatically migrate from v2 if detected')
         .option('--minimal', 'Minimal installation (no skills, patterns, or workers)')
         .option('--skip-patterns', 'Skip pattern loading')
         .option('--with-n8n', 'Include n8n workflow testing platform')
@@ -57,14 +56,6 @@ export function createInitCommand() {
         .action(async () => {
         await checkStatus();
     });
-    initCmd
-        .command('migrate')
-        .description('Migrate from v2 to v3')
-        .option('--dry-run', 'Show what would be migrated without making changes')
-        .option('--force', 'Force migration even if v3 already exists')
-        .action(async (migrateOptions) => {
-        await runMigration(migrateOptions);
-    });
     initCmd
         .command('reset')
         .description('Reset AQE configuration (keeps data)')
@@ -87,11 +78,10 @@ async function runInit(options) {
     // Check if already initialized
     const aqeDir = path.join(projectRoot, '.agentic-qe');
     const isExisting = existsSync(aqeDir);
-    if (isExisting && !options.auto && !options.autoMigrate && !options.upgrade) {
+    if (isExisting && !options.auto && !options.upgrade) {
         console.log(chalk.yellow('  ⚠ AQE directory already exists at:'), aqeDir);
         console.log(chalk.gray('    Use --auto to update configuration (keeps existing skills)'));
         console.log(chalk.gray('    Use --upgrade to update all skills, agents, and validation'));
-        console.log(chalk.gray('    Use --auto-migrate to migrate from v2'));
         console.log('');
     }
     // Expand --with-all-platforms into individual flags
@@ -110,7 +100,6 @@ async function runInit(options) {
         projectRoot,
         autoMode: options.auto,
         upgrade: options.upgrade,
-        autoMigrate: options.autoMigrate,
         minimal: options.minimal,
         skipPatterns: options.skipPatterns,
         withN8n: options.withN8n,
@@ -223,67 +212,6 @@ async function checkStatus() {
     }
     console.log('');
 }
-/**
- * Run v2 to v3 migration
- */
-async function runMigration(options) {
-    const projectRoot = process.cwd();
-    const aqeDir = path.join(projectRoot, '.agentic-qe');
-    console.log('');
-    console.log(chalk.bold.blue('  AQE v2 to v3 Migration'));
-    console.log(chalk.gray('  ──────────────────────────'));
-    console.log('');
-    // Import migration modules
-    const { createV2Detector, createV2DataMigrator, createV2ConfigMigrator } = await import('../../init/migration/index.js');
-    // Detect v2
-    const detector = createV2Detector(projectRoot);
-    const v2Info = await detector.detect();
-    if (!v2Info.detected) {
-        console.log(chalk.yellow('  ⚠ No v2 installation detected'));
-        console.log(chalk.gray('    Run "aqe init" to create a new installation'));
-        console.log('');
-        return;
-    }
-    console.log(chalk.green('  ✓ Found v2 installation'));
-    console.log(chalk.gray(`    Database: ${v2Info.paths.memoryDb || 'not found'}`));
-    console.log(chalk.gray(`    Config: ${v2Info.paths.configDir || 'not found'}`));
-    console.log(chalk.gray(`    Version: ${v2Info.version || 'unknown'}`));
-    console.log('');
-    if (options.dryRun) {
-        console.log(chalk.yellow('  Dry run - no changes will be made'));
-        console.log('');
-        return;
-    }
-    // Run migration
-    console.log(chalk.blue('  Migrating data...'));
-    if (v2Info.paths.memoryDb) {
-        const dataMigrator = createV2DataMigrator({
-            v2DbPath: v2Info.paths.memoryDb,
-            v3PatternsDbPath: path.join(aqeDir, 'patterns.db'),
-            onProgress: (p) => console.log(chalk.gray(`    ${p.message}`)),
-        });
-        const dataResult = await dataMigrator.migrate();
-        if (dataResult.success) {
-            console.log(chalk.green(`  ✓ Migrated ${dataResult.counts.patterns || 0} patterns`));
-            console.log(chalk.green(`  ✓ Migrated ${dataResult.counts.experiences || 0} experiences`));
-        }
-        else {
-            console.log(chalk.red(`  ✗ Data migration failed: ${dataResult.errors.join(', ')}`));
-        }
-    }
-    const configMigrator = createV2ConfigMigrator(projectRoot);
-    const configResult = await configMigrator.migrate();
-    if (configResult.success) {
-        console.log(chalk.green('  ✓ Config migrated'));
-    }
-    else {
-        console.log(chalk.yellow('  ⚠ Config migration skipped (no v2 config found)'));
-    }
-    console.log('');
-    console.log(chalk.green('  Migration complete!'));
-    console.log(chalk.gray('    Run "aqe init" to complete setup'));
-    console.log('');
-}
 /**
  * Reset AQE configuration
  */