agentic-qe 3.11.4 → 3.12.0

package/dist/cli/commands/quality-gate.js

@@ -0,0 +1,135 @@
+/**
+ * Agentic QE v3 - Quality Gate Command (ADR-119)
+ *
+ * `aqe quality-gate` runs the two-gate, three-valued quality verdict against a
+ * pinned ADR-117 checklist: the mechanical (oracle) gate plus a FRONTIER judge.
+ * It calls the SAME `runQualityGate` orchestrator as the `qe/quality/gate` MCP
+ * tool, so CLI and MCP stay in exact parity.
+ *
+ * The oracle (mechanical) result is supplied by the caller (`--oracle-passed` /
+ * `--baseline-passed`, or `--oracle-file`) because the ADR-113 mutation oracle
+ * runs upstream. A missing oracle result is treated as a non-executed test ⇒
+ * mechanical fail (never a silent pass).
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'node:fs';
+import { writeOutput, toJSON } from '../utils/ci-output.js';
+import { runQualityGate, listChecklistIds, } from '../../validation/quality-gate-runner.js';
+import { createRouterFrontierJudge, createUnavailableJudge, } from '../../validation/frontier-judge.js';
+export function createQualityGateCommand(_context, cleanupAndExit, _ensureInitialized) {
+    return new Command('quality-gate')
+        .description('Two-gate, three-valued quality verdict against a pinned ADR-117 checklist (ADR-119)')
+        .option('-c, --checklist <id>', 'Pinned anchor checklist id (e.g. A1-inRange)')
+        .option('-a, --artifact-file <path>', 'File containing the artifact under judgement')
+        .option('--artifact <text>', 'Inline artifact text (alternative to --artifact-file)')
+        .option('--oracle-passed', 'Mechanical oracle passed (mutation score met threshold)')
+        .option('--baseline-passed', 'Tests executed against the reference implementation')
+        .option('--oracle-file <path>', 'JSON file with { passed, baselinePassed } from the ADR-113 oracle')
+        .option('--anchor <path>', 'Override the frozen anchor path (ADR-117)')
+        .option('--model <id>', 'Frontier judge model id (ADR-111: always frontier-tier)')
+        .option('--list', 'List the available pinned checklist ids and exit')
+        .option('-F, --format <format>', 'Output format (text|json)', 'text')
+        .option('-o, --output <path>', 'Write output to file')
+        .action(async (options) => {
+        // No kernel/memory needed: this reads the frozen ADR-117 anchor and calls
+        // the LLM router — so it runs standalone in CI without a fleet init.
+        const format = options.format;
+        try {
+            if (options.list) {
+                const ids = listChecklistIds(options.anchor);
+                if (format === 'json')
+                    writeOutput(toJSON({ checklists: ids }), options.output);
+                else
+                    console.log(`Available checklists:\n  ${ids.join('\n  ')}`);
+                await cleanupAndExit(0);
+                return;
+            }
+            if (!options.checklist) {
+                console.error(chalk.red('Missing required option -c, --checklist <id> (use --list to see ids)'));
+                await cleanupAndExit(1);
+                return;
+            }
+            const artifact = resolveArtifact(options);
+            if (artifact == null) {
+                console.error(chalk.red('Provide --artifact-file <path> or --artifact <text>'));
+                await cleanupAndExit(1);
+                return;
+            }
+            const oracleResult = resolveOracle(options);
+            const judge = await buildJudge(options.model);
+            const request = {
+                oracleResult,
+                artifact,
+                checklistId: options.checklist,
+                judge,
+                anchorPath: options.anchor,
+            };
+            const result = await runQualityGate(request);
+            if (format === 'json') {
+                writeOutput(toJSON(result), options.output);
+            }
+            else {
+                printVerdict(result.verdict, result.mechanical, result.specCoverage, result.unmet, result.reason);
+            }
+            // Exit codes: 0 pass, 1 fail, 3 inconclusive (distinct so CI can branch).
+            const code = result.verdict === 'pass' ? 0 : result.verdict === 'fail' ? 1 : 3;
+            await cleanupAndExit(code);
+        }
+        catch (error) {
+            console.error(chalk.red('\nQuality gate failed:'), error instanceof Error ? error.message : error);
+            await cleanupAndExit(1);
+        }
+    });
+}
+function resolveArtifact(options) {
+    if (typeof options.artifact === 'string')
+        return options.artifact;
+    if (options.artifactFile)
+        return fs.readFileSync(options.artifactFile, 'utf8');
+    return null;
+}
+/**
+ * Resolve the mechanical-gate (oracle) result. `--oracle-file` wins; otherwise
+ * the boolean flags. Returns null (⇒ mechanical fail) when nothing is supplied,
+ * so an un-run oracle can never masquerade as a pass.
+ */
+function resolveOracle(options) {
+    if (options.oracleFile) {
+        const raw = JSON.parse(fs.readFileSync(options.oracleFile, 'utf8'));
+        return { passed: !!raw.passed, baselinePassed: !!raw.baselinePassed };
+    }
+    if (options.oraclePassed === undefined && options.baselinePassed === undefined) {
+        return null;
+    }
+    return { passed: !!options.oraclePassed, baselinePassed: !!options.baselinePassed };
+}
+/**
+ * Build the frontier judge from the shared multi-provider router. When no
+ * provider/credentials are available the judge's preflight fails ⇒ the verdict
+ * is `inconclusive` (never a silent pass). Identical construction to the MCP tool.
+ */
+export async function buildJudge(model) {
+    const { createLLMRouterService } = await import('../../shared/llm/llm-router-service.js');
+    const built = await createLLMRouterService().catch(() => null);
+    if (!built) {
+        return createUnavailableJudge('no LLM provider configured — set a frontier provider API key');
+    }
+    return createRouterFrontierJudge(built.router, model ? { model } : {});
+}
+function printVerdict(verdict, mechanical, specCoverage, unmet, reason) {
+    const icon = verdict === 'pass' ? chalk.green('✓ PASS')
+        : verdict === 'fail' ? chalk.red('✗ FAIL')
+            : chalk.yellow('? INCONCLUSIVE');
+    console.log(`\n  Quality Gate: ${icon}`);
+    console.log(`  Mechanical gate: ${mechanical === 'pass' ? chalk.green('pass') : chalk.red('fail')}`);
+    if (specCoverage != null)
+        console.log(`  Spec coverage:   ${chalk.cyan((specCoverage * 100).toFixed(0) + '%')}`);
+    if (unmet.length > 0) {
+        console.log(chalk.cyan('  Unmet requirements:'));
+        for (const u of unmet)
+            console.log(chalk.gray(`    - ${u}`));
+    }
+    console.log(chalk.gray(`  ${reason}\n`));
+}
+//# sourceMappingURL=quality-gate.js.map

package/dist/cli/handlers/status-handler.d.ts

@@ -5,6 +5,24 @@
  */
 import { Command } from 'commander';
 import { ICommandHandler, CLIContext } from './interfaces.js';
+export interface DaemonLivenessStatus {
+    /** A daemon.pid file exists (`aqe`/`npx ruflo daemon start` was run at least once) */
+    configured: boolean;
+    /** The PID in daemon.pid corresponds to a live process right now */
+    running: boolean;
+    pid?: number;
+}
+/**
+ * Check whether the detached background-worker daemon (`.agentic-qe/workers/
+ * start-daemon.cjs`, PID recorded in `daemon.pid` — see `10-workers.ts`) is
+ * actually alive. Mirrors the exact liveness check `stop-daemon.cjs` uses
+ * (`process.kill(pid, 0)`) rather than inventing a new protocol.
+ *
+ * Distinct from `aqe daemon status` (in `cli/commands/daemon.ts`), which
+ * tracks a *different*, in-process `QualityDaemon` instance that can't see a
+ * truly detached process across separate CLI invocations anyway.
+ */
+export declare function checkDaemonLiveness(): DaemonLivenessStatus;
 export declare class StatusHandler implements ICommandHandler {
     readonly name = "status";
     readonly description = "Show system status";

package/dist/cli/handlers/status-handler.js

@@ -4,8 +4,41 @@
  * Handles the 'aqe status' and 'aqe health' commands.
  */
 import chalk from 'chalk';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { getStatusColor, formatUptime, } from './interfaces.js';
 import { writeOutput, toJSON } from '../utils/ci-output.js';
+import { findProjectRoot } from '../../kernel/unified-memory.js';
+/**
+ * Check whether the detached background-worker daemon (`.agentic-qe/workers/
+ * start-daemon.cjs`, PID recorded in `daemon.pid` — see `10-workers.ts`) is
+ * actually alive. Mirrors the exact liveness check `stop-daemon.cjs` uses
+ * (`process.kill(pid, 0)`) rather than inventing a new protocol.
+ *
+ * Distinct from `aqe daemon status` (in `cli/commands/daemon.ts`), which
+ * tracks a *different*, in-process `QualityDaemon` instance that can't see a
+ * truly detached process across separate CLI invocations anyway.
+ */
+export function checkDaemonLiveness() {
+    try {
+        const pidFile = join(findProjectRoot(), '.agentic-qe', 'workers', 'daemon.pid');
+        if (!existsSync(pidFile))
+            return { configured: false, running: false };
+        const pid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10);
+        if (!Number.isFinite(pid))
+            return { configured: true, running: false };
+        try {
+            process.kill(pid, 0); // signal 0: existence check only, doesn't actually kill
+            return { configured: true, running: true, pid };
+        }
+        catch {
+            return { configured: true, running: false, pid };
+        }
+    }
+    catch {
+        return { configured: false, running: false };
+    }
+}
 // ============================================================================
 // Status Handler
 // ============================================================================
@@ -193,6 +226,7 @@ export class HealthHandler {
                         lastCheck: health.lastHealthCheck.toISOString(),
                         domains: domainSummary,
                         issues: health.issues,
+                        daemon: checkDaemonLiveness(),
                     }), options.output);
                 }
                 await this.cleanupAndExit(0);
@@ -244,6 +278,19 @@ export class HealthHandler {
                 if (idle > 0 && healthy === 0 && degraded === 0 && unhealthy === 0) {
                     console.log(chalk.gray('\n  Tip: Domains are idle (ready). Run a task to spawn agents.'));
                 }
+                // A18: background worker daemon liveness \u2014 was previously invisible,
+                // so a stopped daemon looked identical to "everything's fine".
+                const daemon = checkDaemonLiveness();
+                console.log(chalk.blue('\n  Background Daemon:'));
+                if (!daemon.configured) {
+                    console.log(`  ${chalk.gray('\u25CB')} Not configured (never started \u2014 run "npx ruflo daemon start")`);
+                }
+                else if (daemon.running) {
+                    console.log(`  ${chalk.green('\u25CF')} Running (PID: ${daemon.pid})`);
+                }
+                else {
+                    console.log(`  ${chalk.red('\u25CF')} Not running (stale PID: ${daemon.pid ?? 'unknown'}) \u2014 learning/consolidation snapshots will not advance`);
+                }
             }
             console.log('');
             await this.cleanupAndExit(0);

package/dist/cli/index.js

@@ -248,6 +248,11 @@ registerLazyCommand(program, {
     description: 'Quality assessment shortcut',
     factory: () => import('./commands/quality.js').then(m => m.createQualityCommand(context, cleanupAndExit, ensureInitialized)),
 });
+registerLazyCommand(program, {
+    name: 'quality-gate',
+    description: 'Two-gate, three-valued quality verdict against a pinned checklist (ADR-119)',
+    factory: () => import('./commands/quality-gate.js').then(m => m.createQualityGateCommand(context, cleanupAndExit, ensureInitialized)),
+});
 registerLazyCommand(program, {
     name: 'security',
     description: 'Security scanning and URL validation',

package/dist/coordination/mincut/dream-integration.d.ts

@@ -53,6 +53,11 @@ interface DreamInsight {
     applied: boolean;
     suggestedAction?: string;
     createdAt: Date;
+    /**
+     * ADR-121 evidence tier of the insight. Absent → the conservative default
+     * (`proxy:structural`), which the ADR-120 dream-apply gate will not apply.
+     */
+    provenanceTier?: string;
 }
 interface PatternImportData {
     id: string;
@@ -165,6 +170,12 @@ export interface DreamIntegrationConfig {
     maxAdaptationHistory: number;
     /** Whether to auto-apply high-confidence insights */
     autoApplyInsights: boolean;
+    /**
+     * ADR-121: whether `judge:llm`-tier insights may be applied. A single LLM
+     * judgment is noisy, so judge-tier apply is opt-in (default false). Oracle
+     * tier always applies; proxy tier never does.
+     */
+    allowJudgeTierApply?: boolean;
 }
 /**
  * Default dream integration configuration

package/dist/coordination/mincut/dream-integration.js

@@ -21,6 +21,8 @@
  */
 import { v4 as uuidv4 } from 'uuid';
 import { StrangeLoopController } from './strange-loop';
+import { DEFAULT_PROVENANCE_TIER } from '../../learning/provenance-tier.js';
+import { reExecutePathGate, pathGateFingerprint, pathSealedHash, verifyPathPromotion, } from '../../validation/gate-reexecute.js';
 /**
  * Default dream integration configuration
  */
@@ -930,19 +932,44 @@ export class DreamMinCutController {
                 continue;
             }
             const action = this.integration.convertInsightToAction(insight);
-            if (action && action.type !== 'no_action') {
-                // Record as adaptation
-                this.integration.getMetaTracker().recordAdaptation({
-                    timestamp: new Date(),
-                    type: 'insight_applied',
-                    trigger: 'dream_insight',
-                    stateBefore: { minCutValue: 0, weakVertexCount: 0 },
-                    stateAfter: { minCutValue: 0, weakVertexCount: 0 },
-                    improvement: insight.noveltyScore * insight.confidenceScore,
-                    insightId: insight.id,
-                });
-                appliedCount++;
+            const actionable = !!action && action.type !== 'no_action';
+            // ADR-120: seal the apply decision's inputs and re-execute the frozen
+            // `dream-apply/v1` rule. This is the A8-EXT fake-`applied`-counter home:
+            // a logged apply the frozen rule would reject (proxy-tier evidence, or an
+            // insight that produced no real reorganization) is a forgery. Only a
+            // receipt that re-executes to `promote` on intact sealed inputs is
+            // counted as applied — the log no longer decides, the re-run does.
+            const sealed = {
+                provenanceTier: insight.provenanceTier ?? DEFAULT_PROVENANCE_TIER,
+                allowJudgeTier: this.config.allowJudgeTierApply,
+                insightConfidence: insight.confidenceScore,
+                insightConfidenceThreshold: this.config.insightConfidenceThreshold,
+                insightActionable: actionable,
+            };
+            const rerun = reExecutePathGate('dream-apply/v1', sealed);
+            const receipt = {
+                ruleVersion: 'dream-apply/v1',
+                ruleFingerprint: pathGateFingerprint('dream-apply/v1'),
+                sealedHash: pathSealedHash(sealed),
+                sealed,
+                recordedVerdict: rerun.promote ? 'promote' : 'reject',
+            };
+            const verdict = verifyPathPromotion(receipt);
+            if (!verdict.valid || !rerun.promote) {
+                continue; // not reproducibly applicable under the frozen rule — do not count
             }
+            // Record as adaptation
+            this.integration.getMetaTracker().recordAdaptation({
+                timestamp: new Date(),
+                type: 'insight_applied',
+                trigger: 'dream_insight',
+                stateBefore: { minCutValue: 0, weakVertexCount: 0 },
+                stateAfter: { minCutValue: 0, weakVertexCount: 0 },
+                improvement: insight.noveltyScore * insight.confidenceScore,
+                insightId: insight.id,
+            });
+            insight.applied = true;
+            appliedCount++;
         }
         return appliedCount;
     }

package/dist/coordination/mincut/queen-integration.js

@@ -277,7 +277,7 @@ export class QueenMinCutBridge {
         };
         // Agent status changed
         const onAgentStatusChanged = async (event) => {
-            const { agentId, status, domain } = event.payload;
+            const { agentId, status } = event.payload;
             const vertexId = `agent:${agentId}`;
             const vertex = this.graph.getVertex(vertexId);
             if (vertex) {
@@ -293,7 +293,7 @@ export class QueenMinCutBridge {
         };
         // Task coordination (agent-to-agent communication)
         const onTaskCoordination = async (event) => {
-            const { fromAgent, toAgent, messageType } = event.payload;
+            const { fromAgent, toAgent } = event.payload;
             const sourceId = `agent:${fromAgent}`;
             const targetId = `agent:${toAgent}`;
             if (this.graph.hasVertex(sourceId) && this.graph.hasVertex(targetId)) {
@@ -321,11 +321,20 @@ export class QueenMinCutBridge {
                 }
             }
         };
-        // Subscribe to events (would use eventBus.subscribe in real implementation)
-        // For now, we store the handlers for cleanup
-        this.eventSubscriptions.push(() => {
-            // Cleanup placeholder - actual unsubscribe would go here
-        });
+        // A16: these handlers existed but were never actually subscribed — the
+        // topology graph only ever saw its static domain-coordinator scaffold,
+        // never a real agent, no matter how many agents Queen actually spawned.
+        // `QueenCoordinator.publishEvent()` prefixes every event with "Queen"
+        // (e.g. `AgentSpawned` -> `QueenAgentSpawned`); only that one has a real
+        // publisher today (`queen-coordinator.ts`). The other three are wired to
+        // the same convention so they activate automatically if/when a publisher
+        // for agent termination / status-change / cross-agent coordination is
+        // added — they are current no-ops otherwise, not fabricated coverage.
+        const spawnedSub = this.eventBus.subscribe('QueenAgentSpawned', onAgentSpawned);
+        const terminatedSub = this.eventBus.subscribe('QueenAgentTerminated', onAgentTerminated);
+        const statusSub = this.eventBus.subscribe('QueenAgentStatusChanged', onAgentStatusChanged);
+        const taskCoordSub = this.eventBus.subscribe('QueenTaskCoordination', onTaskCoordination);
+        this.eventSubscriptions.push(() => spawnedSub.unsubscribe(), () => terminatedSub.unsubscribe(), () => statusSub.unsubscribe(), () => taskCoordSub.unsubscribe());
     }
     // ==========================================================================
     // Health Integration
@@ -437,6 +446,14 @@ export class QueenMinCutBridge {
      */
     startSnapshotTimer() {
         this.snapshotTimer = setInterval(async () => {
+            // A16: skip the periodic write entirely when no real agents have
+            // spawned yet — the domain-coordinator scaffold is static, so an
+            // empty-of-agents graph produces the exact same degenerate reading
+            // (14 vertices, mincut 0.0) every tick forever, which is noise, not
+            // signal. The dispose()-time final snapshot still runs unconditionally
+            // since that's a single row, not a recurring accumulation.
+            if (this.isEmptyTopology())
+                return;
             await this.saveSnapshot();
             // Also record history
             await this.persistence.recordHistory({

package/dist/coordination/protocol-executor.js

@@ -486,7 +486,8 @@ export class DefaultProtocolExecutor {
             results: Object.fromEntries(execution.results),
         }, {
             namespace: 'coordination',
-            ttl: 86400000, // 24 hours
+            // ttl is in SECONDS, not ms (unified-memory.ts:607) — was 1000x too long.
+            ttl: 86400, // 24 hours
         });
     }
     /**

package/dist/coordination/queen-lifecycle.js

@@ -67,7 +67,10 @@ export function startMetricsCollectionTimer(ctx) {
         const metrics = ctx.getMetrics();
         await ctx.publishEvent('MetricsCollected', { metrics });
         await ctx.memory.set(`queen:metrics:${Date.now()}`, metrics, {
-            ttl: 86400000, // 24 hours
+            // MemoryBackend.set's ttl is in SECONDS, not ms (unified-memory.ts:607
+            // does Date.now() + ttl * 1000) — this was 86400000, making rows live
+            // 1000 days instead of 1, hence unbounded kv_store growth.
+            ttl: 86400, // 24 hours
             namespace: 'queen-coordinator',
         });
         // ADR-064 Phase 4C: Feed workload metrics to dynamic scaler

package/dist/domains/code-intelligence/coordinator.js

@@ -853,14 +853,16 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
      */
     async storeC4DiagramsInMemory(projectPath, result) {
         const key = `c4-diagrams:latest:${this.hashCode(projectPath)}`;
+        // ttl is in SECONDS, not ms (unified-memory.ts:607) — these were
+        // 3600000, making cache entries live ~41.6 days instead of 1 hour.
         await this.memory.set(key, result, {
             namespace: 'code-intelligence',
             persist: true,
-            ttl: 3600000, // 1 hour
+            ttl: 3600, // 1 hour
         });
         // Also store components and external systems separately for quick access
-        await this.memory.set(`c4-components:${this.hashCode(projectPath)}`, result.components, { namespace: 'code-intelligence', ttl: 3600000 });
-        await this.memory.set(`c4-external-systems:${this.hashCode(projectPath)}`, result.externalSystems, { namespace: 'code-intelligence', ttl: 3600000 });
+        await this.memory.set(`c4-components:${this.hashCode(projectPath)}`, result.components, { namespace: 'code-intelligence', ttl: 3600 });
+        await this.memory.set(`c4-external-systems:${this.hashCode(projectPath)}`, result.externalSystems, { namespace: 'code-intelligence', ttl: 3600 });
     }
     // ============================================================================
     // V3 Integration: MetricCollector for Real Code Metrics (Phase 5)
@@ -921,14 +923,16 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
      */
     async storeProjectMetricsInMemory(projectPath, metrics) {
         const key = `project-metrics:latest:${this.hashCode(projectPath)}`;
+        // ttl is in SECONDS, not ms (unified-memory.ts:607) — these were
+        // 300000, making entries live ~3.47 days instead of 5 minutes.
         await this.memory.set(key, metrics, {
             namespace: 'code-intelligence',
             persist: true,
-            ttl: 300000, // 5 minutes (metrics can change frequently)
+            ttl: 300, // 5 minutes (metrics can change frequently)
         });
         // Store LOC and test counts separately for quick access
-        await this.memory.set(`loc-metrics:${this.hashCode(projectPath)}`, metrics.loc, { namespace: 'code-intelligence', ttl: 300000 });
-        await this.memory.set(`test-metrics:${this.hashCode(projectPath)}`, metrics.tests, { namespace: 'code-intelligence', ttl: 300000 });
+        await this.memory.set(`loc-metrics:${this.hashCode(projectPath)}`, metrics.loc, { namespace: 'code-intelligence', ttl: 300 });
+        await this.memory.set(`test-metrics:${this.hashCode(projectPath)}`, metrics.tests, { namespace: 'code-intelligence', ttl: 300 });
     }
     /**
      * Get the MetricCollector service for direct access

package/dist/domains/code-intelligence/services/product-factors-bridge.js

@@ -624,7 +624,9 @@ export class ProductFactorsBridgeService {
         };
         await this.memory.set(cacheKey, cacheEntry, {
             namespace: 'code-intelligence',
-            ttl: this.config.cacheTtlMs,
+            // MemoryBackend.set's ttl is in SECONDS (unified-memory.ts:607 does
+            // Date.now() + ttl * 1000) — cacheTtlMs is milliseconds, so convert.
+            ttl: this.config.cacheTtlMs / 1000,
         });
     }
     getCacheKey(projectPath) {

package/dist/domains/defect-intelligence/services/defect-predictor.d.ts

@@ -121,6 +121,12 @@ export declare class DefectPredictorService implements IDefectPredictorService {
      * ADR-051: Retrieve historical defect patterns for context
      */
     private getHistoricalDefectPatterns;
+    /**
+     * Write side of getHistoricalDefectPatterns — records a confirmed defect's
+     * type both per-file and in the general pool, capped and deduped to match
+     * what the reader expects.
+     */
+    private recordConfirmedDefectPattern;
     /**
      * Analyze regression risk for a changeset
      */

package/dist/domains/defect-intelligence/services/defect-predictor.js

@@ -331,6 +331,21 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
         }
         return [...new Set(patterns)].slice(0, 10);
     }
+    /**
+     * Write side of getHistoricalDefectPatterns — records a confirmed defect's
+     * type both per-file and in the general pool, capped and deduped to match
+     * what the reader expects.
+     */
+    async recordConfirmedDefectPattern(file, defectType) {
+        const fileKey = `${this.config.modelNamespace}:defect-patterns:${file}`;
+        const existing = await this.memory.get(fileKey);
+        const patterns = [...new Set([...(existing?.patterns ?? []), defectType])].slice(-20);
+        await this.memory.set(fileKey, { patterns }, { namespace: 'defect-intelligence', persist: true });
+        const generalKey = `${this.config.modelNamespace}:common-defect-patterns`;
+        const existingGeneral = (await this.memory.get(generalKey)) ?? [];
+        const general = [...new Set([...existingGeneral, defectType])].slice(-50);
+        await this.memory.set(generalKey, general, { namespace: 'defect-intelligence', persist: true });
+    }
     /**
      * Analyze regression risk for a changeset
      */
@@ -385,6 +400,12 @@ Be specific and actionable. Focus on concrete issues, not generic advice.`,
             });
             // Update model metrics based on feedback
             await this.recalculateMetrics(feedback);
+            // A confirmed defect with a known type is the write side of
+            // getHistoricalDefectPatterns' read — previously nothing populated
+            // these keys, so historical-pattern lookup always returned empty.
+            if (feedback.actualDefect && feedback.defectType) {
+                await this.recordConfirmedDefectPattern(feedback.file, feedback.defectType);
+            }
             return ok(undefined);
         }
         catch (error) {

package/dist/domains/learning-optimization/interfaces.d.ts

@@ -56,6 +56,13 @@ export interface Experience {
     readonly result: ExperienceResult;
     readonly reward: number;
     readonly timestamp: Date;
+    /**
+     * ReasoningBank pattern IDs that were applied/matched to produce this
+     * experience (ADR-110 kept-nulls). Optional — most domains don't yet
+     * track which pattern influenced a given operation; only populate this
+     * when real matched-pattern data exists, never a placeholder.
+     */
+    readonly appliedPatternIds?: readonly string[];
 }
 export interface StateSnapshot {
     readonly context: Record<string, unknown>;

package/dist/domains/learning-optimization/plugin.js

@@ -391,6 +391,11 @@ export class LearningOptimizationPlugin extends BaseDomainPlugin {
                 duration: 0,
             },
             reward: 0.8,
+            // ADR-110: real matched-pattern IDs from test-generation/coordinator.ts's
+            // GeneratedTests.patternsUsed. This event always represents a successful
+            // generation, so nulls won't fire from here in practice — threaded for
+            // correctness/future use, not for immediate null-recording payoff.
+            appliedPatternIds: payload.patternsUsed,
         });
     }
     async handleTestRunCompleted(event) {

package/dist/domains/learning-optimization/services/learning-coordinator.d.ts

@@ -40,6 +40,8 @@ export declare class LearningCoordinatorService implements IPatternLearningServi
      * Provides 2.49x-7.47x speedup via @ruvector/attention SIMD implementation
      */
     private flashAttention;
+    /** ADR-110 null store, lazily wired. undefined = not yet attempted; null = attempted and unavailable. */
+    private _nullStore?;
     constructor(dependencies: LearningCoordinatorDependencies, config?: Partial<LearningCoordinatorConfig>);
     /**
      * Initialize FlashAttention for high-performance similarity computations.
@@ -143,6 +145,14 @@ export declare class LearningCoordinatorService implements IPatternLearningServi
      * Record a new experience
      */
     recordExperience(experience: Omit<Experience, 'id' | 'timestamp'>): Promise<Result<string>>;
+    /**
+     * Lazily wire the ADR-110 null store (fail-soft — mirrors the witness-chain
+     * wiring pattern in AQELearningEngine). Cached after first successful init;
+     * silently no-ops if the unified persistence layer isn't available (e.g.
+     * memory-only mode) so a learning-side failure never blocks the caller.
+     */
+    private getNullStore;
+    private recordPatternNulls;
     /**
      * Mine experiences for insights
      */

package/dist/domains/learning-optimization/services/learning-coordinator.js

@@ -40,6 +40,8 @@ export class LearningCoordinatorService {
      * Provides 2.49x-7.47x speedup via @ruvector/attention SIMD implementation
      */
     flashAttention = null;
+    /** ADR-110 null store, lazily wired. undefined = not yet attempted; null = attempted and unavailable. */
+    _nullStore;
     constructor(dependencies, config = {}) {
         this.memory = dependencies.memory;
         this.llmRouter = dependencies.llmRouter;
@@ -462,12 +464,67 @@ Provide:
             });
             // Index by agent and domain for faster retrieval
             await this.indexExperience(fullExperience);
+            // ADR-110: a pattern-guided failure is a kept null, not a discarded
+            // run. Only fires when the caller supplied real matched-pattern IDs
+            // (appliedPatternIds) — most domains don't track this yet, so this is
+            // a no-op for them, which is correct (nothing to blame the failure on).
+            if (!experience.result.success && experience.appliedPatternIds?.length) {
+                await this.recordPatternNulls(fullExperience);
+            }
             return ok(id);
         }
         catch (error) {
             return err(toError(error));
         }
     }
+    /**
+     * Lazily wire the ADR-110 null store (fail-soft — mirrors the witness-chain
+     * wiring pattern in AQELearningEngine). Cached after first successful init;
+     * silently no-ops if the unified persistence layer isn't available (e.g.
+     * memory-only mode) so a learning-side failure never blocks the caller.
+     */
+    async getNullStore() {
+        if (this._nullStore !== undefined)
+            return this._nullStore || undefined;
+        try {
+            const { getUnifiedPersistence } = await import('../../../kernel/unified-persistence.js');
+            const persistence = getUnifiedPersistence();
+            if (!persistence.isInitialized()) {
+                this._nullStore = null;
+                return undefined;
+            }
+            const { PatternNullStore } = await import('../../../learning/pattern-null-store.js');
+            this._nullStore = new PatternNullStore(persistence.getDatabase());
+            return this._nullStore;
+        }
+        catch (e) {
+            this._nullStore = null;
+            logger.warn('Null store wiring skipped', { error: e instanceof Error ? e.message : String(e) });
+            return undefined;
+        }
+    }
+    async recordPatternNulls(experience) {
+        const nullStore = await this.getNullStore();
+        if (!nullStore)
+            return;
+        const contextFingerprint = `${experience.domain}:${experience.action}`;
+        for (const patternId of experience.appliedPatternIds ?? []) {
+            try {
+                nullStore.recordNull({
+                    patternId,
+                    contextFingerprint,
+                    failureMode: String(experience.result.outcome?.error ?? experience.action),
+                    evidenceClass: 'EXECUTED',
+                });
+            }
+            catch (e) {
+                logger.warn('Failed to record pattern null', {
+                    patternId,
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+    }
     /**
      * Mine experiences for insights
      */