agentic-qe 3.7.13 → 3.7.15

package/dist/learning/daily-log.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Daily Log Tier - Human-readable Markdown audit trail
+ *
+ * Writes daily learning summaries to memory/YYYY-MM-DD.md files.
+ * Provides a browsable history of what AQE learned each day.
+ */
+export interface DailyLogEntry {
+    timestamp: Date;
+    type: 'pattern-learned' | 'pattern-promoted' | 'pattern-quarantined' | 'experience-captured' | 'search-performed' | 'reward-assigned';
+    summary: string;
+    details?: Record<string, unknown>;
+}
+export interface DailyLogConfig {
+    /** Directory to write daily logs (default: .agentic-qe/logs) */
+    logDir?: string;
+    /** Whether daily logging is enabled (default: true) */
+    enabled?: boolean;
+    /** Maximum entries per daily log before rotation (default: 500) */
+    maxEntriesPerDay?: number;
+}
+export declare class DailyLogger {
+    private config;
+    private buffer;
+    private flushTimer;
+    constructor(config?: DailyLogConfig);
+    /**
+     * Log a learning event
+     */
+    log(entry: DailyLogEntry): void;
+    /**
+     * Flush buffered entries to the daily log file
+     */
+    flush(): void;
+    /**
+     * Get the path to today's log file
+     */
+    getTodayLogPath(): string;
+    /**
+     * Dispose and flush remaining entries
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=daily-log.d.ts.map

package/dist/learning/daily-log.js

@@ -0,0 +1,91 @@
+/**
+ * Daily Log Tier - Human-readable Markdown audit trail
+ *
+ * Writes daily learning summaries to memory/YYYY-MM-DD.md files.
+ * Provides a browsable history of what AQE learned each day.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const LOG_ICONS = {
+    'pattern-learned': '\u{1F9E0}',
+    'pattern-promoted': '\u2B06\uFE0F',
+    'pattern-quarantined': '\u{1F512}',
+    'experience-captured': '\u{1F4F8}',
+    'search-performed': '\u{1F50D}',
+    'reward-assigned': '\u{1F3AF}',
+};
+export class DailyLogger {
+    config;
+    buffer = [];
+    flushTimer = null;
+    constructor(config) {
+        this.config = {
+            logDir: config?.logDir ?? path.join(process.cwd(), '.agentic-qe', 'logs'),
+            enabled: config?.enabled ?? true,
+            maxEntriesPerDay: config?.maxEntriesPerDay ?? 500,
+        };
+    }
+    /**
+     * Log a learning event
+     */
+    log(entry) {
+        if (!this.config.enabled)
+            return;
+        this.buffer.push(entry);
+        // Auto-flush every 10 entries
+        if (this.buffer.length >= 10) {
+            this.flush();
+        }
+    }
+    /**
+     * Flush buffered entries to the daily log file
+     */
+    flush() {
+        if (this.buffer.length === 0)
+            return;
+        const today = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+        const logPath = path.join(this.config.logDir, `${today}.md`);
+        try {
+            // Ensure directory exists
+            fs.mkdirSync(this.config.logDir, { recursive: true });
+            // Build markdown content
+            const entries = this.buffer.splice(0, this.buffer.length);
+            const lines = [];
+            // Add header if file doesn't exist
+            if (!fs.existsSync(logPath)) {
+                lines.push(`# AQE Daily Log \u2014 ${today}\n`);
+                lines.push('| Time | Event | Summary |');
+                lines.push('|------|-------|---------|');
+            }
+            for (const entry of entries) {
+                const time = entry.timestamp.toISOString().split('T')[1]?.slice(0, 8) ?? '00:00:00';
+                const icon = LOG_ICONS[entry.type] ?? '\u{1F4DD}';
+                const escapedSummary = entry.summary.replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/\n/g, ' ');
+                lines.push(`| ${time} | ${icon} ${entry.type} | ${escapedSummary} |`);
+            }
+            fs.appendFileSync(logPath, lines.join('\n') + '\n');
+        }
+        catch (error) {
+            // Non-critical - don't fail the learning pipeline for logging
+            console.debug('[DailyLog] Write failed:', error);
+        }
+    }
+    /**
+     * Get the path to today's log file
+     */
+    getTodayLogPath() {
+        const today = new Date().toISOString().split('T')[0];
+        return path.join(this.config.logDir, `${today}.md`);
+    }
+    /**
+     * Dispose and flush remaining entries
+     */
+    dispose() {
+        this.flush();
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+    }
+}
+//# sourceMappingURL=daily-log.js.map

package/dist/learning/dream/dream-engine.d.ts

@@ -17,6 +17,7 @@
 import { type ActivationConfig } from './spreading-activation.js';
 import { type InsightConfig, type DreamInsight } from './insight-generator.js';
 import { RVCOWBranchManager, type Branch, type ValidationResult, type ValidationThresholds } from './rvcow-branch-manager.js';
+import type { WitnessChain } from '../../audit/witness-chain.js';
 import type { DreamCycle, PatternImportData } from './types.js';
 /**
  * Complete DreamEngine configuration
@@ -102,6 +103,9 @@ export declare class DreamEngine {
     private initialized;
     private cancelled;
     private branchEventListeners;
+    /** Optional witness chain for audit trail of dream decisions (ADR-070) */
+    private _witnessChain;
+    set witnessChain(wc: WitnessChain | null);
     constructor(config?: Partial<DreamConfig>);
     /**
      * Initialize using unified persistence

package/dist/learning/dream/dream-engine.js

@@ -209,6 +209,9 @@ export class DreamEngine {
     initialized = false;
     cancelled = false;
     branchEventListeners = [];
+    /** Optional witness chain for audit trail of dream decisions (ADR-070) */
+    _witnessChain = null;
+    set witnessChain(wc) { this._witnessChain = wc; }
     constructor(config) {
         this.config = { ...DEFAULT_DREAM_CONFIG, ...config };
     }
@@ -374,10 +377,23 @@ export class DreamEngine {
                 if (validation.passed) {
                     this.branchManager.mergeBranch(branch);
                     this.emitBranchEvent('dream:branch_merged', branch, validation);
+                    try {
+                        this._witnessChain?.append('DREAM_MERGE', {
+                            cycleId: this.currentCycle.id, branchName: branch.name,
+                        }, 'dream-engine');
+                    }
+                    catch { /* best-effort witness */ }
                 }
                 else {
                     this.branchManager.discardBranch(branch);
                     this.emitBranchEvent('dream:branch_discarded', branch, validation);
+                    try {
+                        this._witnessChain?.append('DREAM_DISCARD', {
+                            cycleId: this.currentCycle.id, branchName: branch.name,
+                            reason: validation.reason,
+                        }, 'dream-engine');
+                    }
+                    catch { /* best-effort witness */ }
                     dreamLogger.warn('Dream branch discarded: quality validation failed', {
                         cycleId: this.currentCycle.id,
                         reason: validation.reason,

package/dist/learning/dream/rvcow-branch-manager.d.ts

@@ -16,6 +16,7 @@
  * @module learning/dream/rvcow-branch-manager
  */
 import type { Database as DatabaseType } from 'better-sqlite3';
+import type { WitnessChain } from '../../audit/witness-chain.js';
 /**
  * Represents an active RVCOW branch backed by a SQLite savepoint.
  */
@@ -103,6 +104,9 @@ export declare class RVCOWBranchManager {
     private rvfAdapter?;
     /** When true and rvfAdapter is set, createBranch() also forks an RVF snapshot */
     private useRvfFork;
+    /** Optional witness chain for audit trail of branch operations (ADR-070) */
+    private _witnessChain;
+    set witnessChain(wc: WitnessChain | null);
     constructor(db: DatabaseType, thresholds?: ValidationThresholds);
     /**
      * Set an RVF native adapter for supplementary COW fork snapshots.

package/dist/learning/dream/rvcow-branch-manager.js

@@ -50,6 +50,9 @@ export class RVCOWBranchManager {
     rvfAdapter;
     /** When true and rvfAdapter is set, createBranch() also forks an RVF snapshot */
     useRvfFork = false;
+    /** Optional witness chain for audit trail of branch operations (ADR-070) */
+    _witnessChain = null;
+    set witnessChain(wc) { this._witnessChain = wc; }
     constructor(db, thresholds = DEFAULT_VALIDATION_THRESHOLDS) {
         this.db = db;
         this.thresholds = thresholds;
@@ -175,6 +178,12 @@ export class RVCOWBranchManager {
         branch.status = 'merged';
         this.activeBranches.delete(branch.name);
         this.emit('dream:branch_merged', branch);
+        try {
+            this._witnessChain?.append('BRANCH_MERGE', {
+                branchName: branch.name,
+            }, 'rvcow-branch-manager');
+        }
+        catch { /* best-effort witness */ }
     }
     /**
      * Discard a branch by rolling back to its savepoint.

package/dist/learning/experience-capture.d.ts

@@ -16,6 +16,30 @@ import type { MemoryBackend, EventBus } from '../kernel/interfaces.js';
 import type { Result } from '../shared/types/index.js';
 import type { QEDomain } from './qe-patterns.js';
 import type { PatternStore } from './pattern-store.js';
+/**
+ * Test outcome categories for binary reward assignment (GRPO-inspired).
+ * Maps discrete test outcomes to reward signals for pattern learning.
+ */
+export type TestOutcome = 'catches-bug' | 'flaky' | 'false-positive' | 'new-coverage' | 'redundant' | 'code-smell' | 'neutral';
+/**
+ * Reward values for each test outcome.
+ * Based on GRPO (Group Relative Policy Optimization) binary reward model.
+ */
+export declare const TEST_OUTCOME_REWARDS: Record<TestOutcome, number>;
+/**
+ * Valid test outcome values for runtime validation.
+ */
+export declare const VALID_TEST_OUTCOMES: Set<string>;
+/**
+ * Check if a value is a valid TestOutcome.
+ */
+export declare function isValidTestOutcome(value: unknown): value is TestOutcome;
+/**
+ * Compute binary reward from a test outcome.
+ * Returns a reward signal in [-1.0, +1.0] range.
+ * Returns undefined for invalid outcomes (caller must handle).
+ */
+export declare function computeBinaryReward(outcome: TestOutcome): number | undefined;
 /**
  * Task execution experience
  */
@@ -42,6 +66,10 @@ export interface TaskExperience {
     success: boolean;
     /** Quality score (0-1) */
     quality: number;
+    /** Binary reward signal from test outcome (-1.0 to +1.0) */
+    reward?: number;
+    /** Test outcome category (if applicable) */
+    testOutcome?: TestOutcome;
     /** Feedback provided */
     feedback?: string;
     /** Extracted patterns (if any) */
@@ -135,6 +163,7 @@ export declare class ExperienceCaptureService {
     private cleanupTimer?;
     private activeExperiences;
     private stats;
+    private sessionCaptureCount;
     constructor(memory: MemoryBackend, patternStore?: PatternStore | undefined, eventBus?: EventBus | undefined, config?: Partial<ExperienceCaptureConfig>);
     /**
      * Initialize the experience capture service
@@ -161,11 +190,24 @@ export declare class ExperienceCaptureService {
         success: boolean;
         quality?: number;
         feedback?: string;
+        testOutcome?: TestOutcome;
     }): Promise<Result<TaskExperience>>;
     /**
      * Get an active experience
      */
     getActiveExperience(experienceId: string): TaskExperience | undefined;
+    /**
+     * Get the count of pending (in-flight) experiences not yet persisted.
+     * Used by pre-compaction hook to decide whether a flush is needed.
+     */
+    getPendingCount(): number;
+    /**
+     * Flush all pending (in-flight) experiences to persistence.
+     * Each active experience is completed as a partial success and stored,
+     * preventing knowledge loss during context compaction.
+     * Returns the number of experiences flushed.
+     */
+    flushPending(): Promise<number>;
     /**
      * Get experience by ID
      */

package/dist/learning/experience-capture.js

@@ -16,6 +16,41 @@ import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../shared/types/index.js';
 import { LoggerFactory } from '../logging/index.js';
 const logger = LoggerFactory.create('experience-capture');
+import { PROMOTION_THRESHOLD } from './qe-patterns.js';
+/**
+ * Reward values for each test outcome.
+ * Based on GRPO (Group Relative Policy Optimization) binary reward model.
+ */
+export const TEST_OUTCOME_REWARDS = {
+    'catches-bug': 1.0,
+    'flaky': -1.0,
+    'false-positive': -1.0,
+    'new-coverage': 0.3,
+    'redundant': 0.0,
+    'code-smell': -0.5,
+    'neutral': 0.0,
+};
+/**
+ * Valid test outcome values for runtime validation.
+ */
+export const VALID_TEST_OUTCOMES = new Set(Object.keys(TEST_OUTCOME_REWARDS));
+/**
+ * Check if a value is a valid TestOutcome.
+ */
+export function isValidTestOutcome(value) {
+    return typeof value === 'string' && VALID_TEST_OUTCOMES.has(value);
+}
+/**
+ * Compute binary reward from a test outcome.
+ * Returns a reward signal in [-1.0, +1.0] range.
+ * Returns undefined for invalid outcomes (caller must handle).
+ */
+export function computeBinaryReward(outcome) {
+    if (!isValidTestOutcome(outcome)) {
+        return undefined;
+    }
+    return TEST_OUTCOME_REWARDS[outcome];
+}
 /**
  * Default experience capture configuration
  */
@@ -23,7 +58,7 @@ export const DEFAULT_EXPERIENCE_CONFIG = {
     namespace: 'qe-experiences',
     minQualityForPatternExtraction: 0.7,
     similarityThreshold: 0.85,
-    promotionThreshold: 3,
+    promotionThreshold: PROMOTION_THRESHOLD,
     maxExperiencesPerDomain: 1000,
     enableCrossDomainSharing: true,
     autoCleanup: true,
@@ -46,7 +81,7 @@ export class ExperienceCaptureService {
     cleanupTimer;
     // In-memory cache for active experiences
     activeExperiences = new Map();
-    // Statistics
+    // Statistics (cumulative, loaded from persistence)
     stats = {
         totalCaptured: 0,
         successfulCaptures: 0,
@@ -54,6 +89,8 @@ export class ExperienceCaptureService {
         patternsPromoted: 0,
         byDomain: new Map(),
     };
+    // Session-level counter (not persisted, tracks only this session)
+    sessionCaptureCount = 0;
     constructor(memory, patternStore, eventBus, config = {}) {
         this.memory = memory;
         this.patternStore = patternStore;
@@ -133,15 +170,24 @@ export class ExperienceCaptureService {
         else {
             experience.quality = this.calculateQuality(experience);
         }
+        // Compute binary reward from test outcome (GRPO-inspired)
+        const rawOutcome = outcome.testOutcome ?? experience.metadata?.testOutcome;
+        if (rawOutcome && isValidTestOutcome(rawOutcome)) {
+            experience.testOutcome = rawOutcome;
+            experience.reward = computeBinaryReward(rawOutcome);
+        }
         // Remove from active
         this.activeExperiences.delete(experienceId);
         // Store experience
         await this.storeExperience(experience);
         // Update stats
         this.updateStats(experience);
-        // Extract patterns if quality is high enough
+        // Extract patterns: require positive reward (or no reward signal) AND quality threshold
+        // Zero or negative reward blocks extraction — only learn from genuinely positive outcomes
+        const rewardAllowsExtraction = experience.reward === undefined || experience.reward > 0;
         if (experience.success &&
-            experience.quality >= this.config.minQualityForPatternExtraction) {
+            experience.quality >= this.config.minQualityForPatternExtraction &&
+            rewardAllowsExtraction) {
             const extractionResult = await this.extractPattern(experience);
             if (extractionResult.newPattern || extractionResult.reinforced) {
                 experience.patterns = [extractionResult.patternId];
@@ -157,6 +203,41 @@ export class ExperienceCaptureService {
     getActiveExperience(experienceId) {
         return this.activeExperiences.get(experienceId);
     }
+    /**
+     * Get the count of pending (in-flight) experiences not yet persisted.
+     * Used by pre-compaction hook to decide whether a flush is needed.
+     */
+    getPendingCount() {
+        return this.activeExperiences.size;
+    }
+    /**
+     * Flush all pending (in-flight) experiences to persistence.
+     * Each active experience is completed as a partial success and stored,
+     * preventing knowledge loss during context compaction.
+     * Returns the number of experiences flushed.
+     */
+    async flushPending() {
+        const pending = Array.from(this.activeExperiences.entries());
+        if (pending.length === 0)
+            return 0;
+        let flushed = 0;
+        for (const [id, experience] of pending) {
+            // Complete the experience with what we have so far
+            const now = Date.now();
+            experience.completedAt = now;
+            experience.durationMs = now - experience.startedAt;
+            // Mark as partial — quality reflects incomplete capture
+            experience.quality = experience.quality || this.calculateQuality(experience);
+            experience.metadata = { ...experience.metadata, flushedByCompaction: true };
+            // Persist to storage
+            await this.storeExperience(experience);
+            this.updateStats(experience);
+            this.activeExperiences.delete(id);
+            flushed++;
+        }
+        logger.info(`Flushed ${flushed} pending experiences before compaction`);
+        return flushed;
+    }
     /**
      * Get experience by ID
      */
@@ -336,6 +417,12 @@ export class ExperienceCaptureService {
         }
         // Save stats
         await this.saveStats();
+        // At-least-one learning guarantee: warn if zero experiences captured this session
+        if (this.sessionCaptureCount === 0) {
+            console.warn('[ExperienceCapture] WARNING: Zero experiences captured this session. ' +
+                'Learning cannot improve without experience data. ' +
+                'Ensure tasks call startCapture()/completeCapture() to feed the learning loop.');
+        }
         this.activeExperiences.clear();
         this.initialized = false;
     }
@@ -402,6 +489,7 @@ export class ExperienceCaptureService {
      */
     updateStats(experience) {
         this.stats.totalCaptured++;
+        this.sessionCaptureCount++;
         if (experience.success) {
             this.stats.successfulCaptures++;
         }
@@ -591,6 +679,8 @@ Duration: ${experience.durationMs}ms`;
             timestamp: new Date(),
             payload: {
                 experience, // Full experience for cross-domain learning
+                reward: experience.reward, // Binary reward for RL integration
+                testOutcome: experience.testOutcome,
             },
         });
     }

package/dist/learning/index.d.ts

@@ -75,6 +75,10 @@ export { SkillValidationLearner, createSkillValidationLearner, } from './skill-v
 export type { SkillTrustTier, ValidationLevel, TestCaseResult, SkillValidationOutcome, SkillConfidence, CrossModelAnalysis, ValidationPattern, } from './skill-validation-learner.js';
 export { PatternLifecycleManager, createPatternLifecycleManager, DEFAULT_LIFECYCLE_CONFIG, } from './pattern-lifecycle.js';
 export type { PatternLifecycleConfig, ExperienceAggregate, PatternCandidate, PromotionCheckResult, DeprecationCheckResult, PatternLifecycleStats, } from './pattern-lifecycle.js';
+export { generateRemediationHints, findCommonKeywords, } from './opd-remediation.js';
+export type { RemediationHint, RemediationCategory, RemediationConfig, PatternInput, ExecutionRecord, } from './opd-remediation.js';
 export { LearningMetricsTracker, createLearningMetricsTracker, } from './metrics-tracker.js';
 export type { LearningMetricsSnapshot, DashboardData, } from './metrics-tracker.js';
+export { DailyLogger } from './daily-log.js';
+export type { DailyLogEntry, DailyLogConfig, } from './daily-log.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/learning/index.js

@@ -138,7 +138,15 @@ export { SkillValidationLearner, createSkillValidationLearner, } from './skill-v
 // ============================================================================
 export { PatternLifecycleManager, createPatternLifecycleManager, DEFAULT_LIFECYCLE_CONFIG, } from './pattern-lifecycle.js';
 // ============================================================================
+// OPD Remediation Hints
+// ============================================================================
+export { generateRemediationHints, findCommonKeywords, } from './opd-remediation.js';
+// ============================================================================
 // Learning Metrics Tracker (Phase 6: Learning Improvement Plan)
 // ============================================================================
 export { LearningMetricsTracker, createLearningMetricsTracker, } from './metrics-tracker.js';
+// ============================================================================
+// Daily Log Tier (OpenClaw Daily Log Pattern)
+// ============================================================================
+export { DailyLogger } from './daily-log.js';
 //# sourceMappingURL=index.js.map

package/dist/learning/opd-remediation.d.ts

@@ -0,0 +1,55 @@
+/**
+ * OPD (Observe-Plan-Decide) Remediation Hints
+ *
+ * When patterns have negative rewards (failures, flakiness), generate
+ * actionable hints: "bad because X, fix by Y"
+ *
+ * Categories:
+ *  - flaky: intermittent failures (20-80% fail rate, 3+ executions)
+ *  - false-positive: consistently broken (80%+ fail rate)
+ *  - outdated: was working, now fails (recent regression)
+ *  - wrong-scope: vague description + high failure rate
+ *  - missing-context: recurring keywords in failure feedback
+ */
+export interface RemediationHint {
+    patternId: string;
+    observation: string;
+    diagnosis: string;
+    suggestion: string;
+    confidence: number;
+    category: RemediationCategory;
+}
+export type RemediationCategory = 'flaky' | 'false-positive' | 'outdated' | 'wrong-scope' | 'missing-context';
+export interface RemediationConfig {
+    /** Minimum negative reward to trigger remediation (default: -0.3) */
+    minNegativeReward?: number;
+    /** Maximum hints to generate per pattern (default: 3) */
+    maxHintsPerPattern?: number;
+}
+export interface PatternInput {
+    id: string;
+    name: string;
+    description: string;
+    successRate: number;
+    usageCount: number;
+    confidence: number;
+    tags?: string[];
+}
+export interface ExecutionRecord {
+    success: boolean;
+    feedback?: string;
+    durationMs?: number;
+}
+/**
+ * Generate remediation hints for a failed pattern based on its execution history.
+ *
+ * Analyzes execution records to classify the failure mode and produce
+ * actionable suggestions for fixing the pattern.
+ */
+export declare function generateRemediationHints(pattern: PatternInput, executionHistory: ExecutionRecord[], config?: RemediationConfig): RemediationHint[];
+/**
+ * Find common keywords across failure feedback messages.
+ * Returns words that appear in at least 2 distinct messages, sorted by frequency.
+ */
+export declare function findCommonKeywords(feedbacks: string[]): string[];
+//# sourceMappingURL=opd-remediation.d.ts.map