agentic-qe 3.11.4 → 3.11.5

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
      */

package/dist/domains/test-execution/plugin.js

@@ -181,7 +181,7 @@ export class TestExecutionPlugin extends BaseDomainPlugin {
             eventId: event.id,
             timestamp: event.timestamp,
             sourceFiles: payload.sourceFiles,
-        }, { namespace: 'test-execution', ttl: 86400000 } // 24 hours
+        }, { namespace: 'test-execution', ttl: 86400 } // 24 hours (ttl is in SECONDS — unified-memory.ts:607)
         );
     }
     async handleQualityGateEvaluated(event) {
@@ -192,7 +192,7 @@ export class TestExecutionPlugin extends BaseDomainPlugin {
             await this.memory.set(`quality-context:${payload.gateId}`, {
                 requiresRetry: true,
                 failedChecks: payload.checks.filter(c => !c.passed).map(c => c.name),
-            }, { namespace: 'test-execution', ttl: 3600000 } // 1 hour
+            }, { namespace: 'test-execution', ttl: 3600 } // 1 hour (ttl is in SECONDS — unified-memory.ts:607)
             );
         }
         this.updateHealth({

package/dist/domains/test-execution/services/flaky-detector.js

@@ -92,7 +92,7 @@ export class FlakyDetectorService {
             this.analysisCache.set(testId, cachedAnalysis);
             await this.memory.set(`flaky-analysis:${testId}`, cachedAnalysis, {
                 namespace: 'test-execution',
-                ttl: 3600000, // 1 hour
+                ttl: 3600, // 1 hour (ttl is in SECONDS — unified-memory.ts:607)
             });
             return ok(analysis);
         }

package/dist/domains/test-generation/coordinator.js

@@ -350,7 +350,7 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
                 if (this.config.publishEvents) {
                     await this.publishTestSuiteCreated(result.value, request);
                     for (const test of result.value.tests) {
-                        await this.publishTestGenerated(test, request.framework ?? 'vitest');
+                        await this.publishTestGenerated(test, request.framework ?? 'vitest', result.value.patternsUsed);
                     }
                 }
                 // Three-loop protocol: instantAdapt must precede recordOutcome
@@ -631,13 +631,14 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
     // ============================================================================
     // Event Publishing Methods
     // ============================================================================
-    async publishTestGenerated(test, framework) {
+    async publishTestGenerated(test, framework, patternsUsed) {
         const payload = {
             testId: test.id,
             testFile: test.testFile,
             framework,
             sourceFile: test.sourceFile,
             testType: test.type,
+            patternsUsed,
         };
         const event = createEvent(TestGenerationEvents.TestGenerated, 'test-generation', payload);
         await this.eventBus.publish(event);
@@ -889,14 +890,27 @@ export class TestGenerationCoordinator extends BaseDomainCoordinator {
     // Pattern Learning
     // ============================================================================
     async learnFromGeneration(tests) {
-        // Record successful patterns for future use
-        for (const patternId of tests.patternsUsed) {
-            const pattern = await this.patternMatcher.getPattern(patternId);
-            if (pattern) {
-                // Pattern was successfully used, increase its applicability
-                // This is handled internally by recordPatternUsage
+        // A7: this was previously a no-op — the comment claimed usage tracking
+        // "is handled internally by recordPatternUsage" but nothing was ever
+        // called, and tests.patternsUsed (display names) wasn't even a valid
+        // pattern ID to begin with. Only called on the success path (coordinator
+        // line ~618), so success:true is honest here.
+        const patternIds = tests.patternIds ?? [];
+        if (patternIds.length === 0)
+            return;
+        try {
+            const { getUnifiedMemory } = await import('../../kernel/unified-memory.js');
+            const { recordPatternUsage } = await import('../../learning/pattern-usage-recorder.js');
+            const db = getUnifiedMemory().getDatabase();
+            for (const patternId of patternIds) {
+                recordPatternUsage(db, { patternId, success: true });
             }
         }
+        catch (error) {
+            logger.warn('Pattern usage recording skipped', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
     }
     // ============================================================================
     // @ruvector Integration Methods (ADR-040)

package/dist/domains/test-generation/interfaces.d.ts

@@ -42,7 +42,10 @@ export interface IGenerateTestsRequest {
 export interface IGeneratedTests {
     tests: IGeneratedTest[];
     coverageEstimate: number;
+    /** Human-readable pattern names, for display (reports, CLI output). */
     patternsUsed: string[];
+    /** Real qe_patterns.id values for the same patterns, for usage/ADR-110 tracking. */
+    patternIds?: string[];
 }
 export interface IGeneratedTest {
     id: string;

package/dist/domains/test-generation/services/test-generator.js

@@ -302,11 +302,13 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
             }
             const tests = [];
             const patternsUsed = [];
+            const patternIds = [];
             for (const sourceFile of sourceFiles) {
                 const fileTests = await this.generateTestsForFile(sourceFile, testType, effectiveFramework, patterns, effectiveLanguage, request);
                 if (fileTests.success) {
                     tests.push(...fileTests.value.tests);
                     patternsUsed.push(...fileTests.value.patternsUsed);
+                    patternIds.push(...fileTests.value.patternIds);
                 }
             }
             // ADR-062 Tier 2: Mark holdout tests when feature flag is enabled
@@ -323,6 +325,7 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
                 tests,
                 coverageEstimate,
                 patternsUsed: Array.from(new Set(patternsUsed)),
+                patternIds: Array.from(new Set(patternIds)),
             });
         }
         catch (error) {
@@ -396,8 +399,13 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
     async generateTestsForFile(sourceFile, testType, framework, patterns, effectiveLanguage, originalRequest) {
         const testFile = this.getTestFilePath(sourceFile, framework);
         const patternsUsed = [];
+        // Real qe_patterns.id values, parallel to patternsUsed (names) — feeds
+        // recordPatternUsage/ADR-110 appliedPatternIds, which would silently
+        // no-op against a display name instead of a real pattern ID.
+        const patternIds = [];
         const applicablePatterns = await this.findApplicablePatterns(sourceFile, patterns);
         patternsUsed.push(...applicablePatterns.map((p) => p.name));
+        patternIds.push(...applicablePatterns.map((p) => p.id));
         let codeAnalysis = null;
         let sourceContent = '';
         try {
@@ -470,7 +478,7 @@ Return a JSON array of test suggestions, each with: { "name": "test name", "desc
         if (this.qualityGate) {
             test.qualityGateResult = this.qualityGate.validate(testCode, sourceFile, sourceContent || undefined);
         }
-        return ok({ tests: [test], patternsUsed });
+        return ok({ tests: [test], patternsUsed, patternIds });
     }
     async generateTestForLines(file, lines, framework) {
         if (lines.length === 0)

package/dist/integrations/ruvector/delta-tracker.js

@@ -8,7 +8,16 @@
  * @module integrations/ruvector/delta-tracker
  */
 import { v4 as uuidv4 } from 'uuid';
-import * as fastJsonPatch from 'fast-json-patch';
+import * as fastJsonPatchNs from 'fast-json-patch';
+// fast-json-patch ships two entry points with different export shapes: its CJS
+// entry (index.js) attaches named exports directly via Object.assign(exports,
+// core), but its ESM entry (index.mjs) only exports a single default object
+// bundling everything — it has no named `compare`/`applyPatch` exports. Which
+// shape `import * as fastJsonPatchNs` lands on depends on the resolving
+// loader/bundler, so `fastJsonPatchNs.compare` can be undefined even though
+// the package is installed and working. Normalize once so callers don't care.
+const fastJsonPatch = (fastJsonPatchNs.default
+    ?? fastJsonPatchNs);
 // ============================================================================
 // Schema
 // ============================================================================

package/dist/integrations/ruvector/sona-persistence.d.ts

@@ -194,6 +194,11 @@ export declare class PersistentSONAEngine {
      * @returns Adaptation result, or null if three-loop engine not initialized
      */
     instantAdapt(requestFeatures: number[]): import('./sona-three-loop.js').AdaptationResult | null;
+    /**
+     * Get the three-loop engine's current request count (A10), or null if the
+     * three-loop engine is not active.
+     */
+    getRequestCount(): number | null;
     /**
      * Record the outcome of a request for REINFORCE-style gradient estimation (Loop 1b).
      *
@@ -356,6 +361,25 @@ export declare class PersistentSONAEngine {
      * @returns true if a row was deleted
      */
     deleteFisherMatrix(domain: string): boolean;
+    /**
+     * A10 fix: persist the three-loop engine's request counter independently
+     * of the Fisher row, in kv_store (namespace 'sona'). Consolidation (the
+     * thing that writes the FIRST Fisher row) requires requestCount to reach
+     * consolidationInterval — but requestCount previously only survived via
+     * restoreFisher(), which only runs once a Fisher row already exists.
+     * Fresh short-lived CLI/MCP processes doing ~1 instantAdapt() each could
+     * never accumulate past the threshold: cold-start deadlock. This lets the
+     * counter accumulate across process restarts before any consolidation
+     * has ever happened.
+     */
+    saveRequestCount(domain: string, requestCount: number): void;
+    /** Load the persisted request counter for a domain, or null if never saved. */
+    loadRequestCount(domain: string): number | null;
+    /**
+     * Internal variant of loadRequestCount that skips ensureInitialized() —
+     * used during _doInitialize(), mirroring _loadFisherMatrixUnsafe.
+     */
+    private _loadRequestCountUnsafe;
     /**
      * Set or update the server client for cross-process pattern sharing
      */

package/dist/integrations/ruvector/sona-persistence.js

@@ -187,6 +187,23 @@ export class PersistentSONAEngine {
                         });
                     }
                 }
+                else {
+                    // A10 fix: no Fisher row exists yet (the common case pre-first-
+                    // consolidation), but the request counter may still have
+                    // accumulated across prior short-lived processes — restore it
+                    // independently so it isn't reset to 0 every time.
+                    const savedCount = this._loadRequestCountUnsafe(this.config.domain);
+                    if (savedCount !== null) {
+                        const engine = this.baseEngine.getThreeLoopEngine();
+                        if (engine) {
+                            engine.restoreRequestCount(savedCount);
+                            logger.info('Three-loop engine restored request count independently of Fisher state', {
+                                domain: this.config.domain,
+                                requestCount: savedCount,
+                            });
+                        }
+                    }
+                }
                 logger.info('Three-loop engine initialized with Fisher persistence', {
                     domain: this.config.domain,
                 });
@@ -569,6 +586,14 @@ export class PersistentSONAEngine {
         this.ensureInitialized();
         return this.baseEngine.instantAdapt(requestFeatures);
     }
+    /**
+     * Get the three-loop engine's current request count (A10), or null if the
+     * three-loop engine is not active.
+     */
+    getRequestCount() {
+        this.ensureInitialized();
+        return this.baseEngine.getThreeLoopEngine()?.getRequestCount() ?? null;
+    }
     /**
      * Record the outcome of a request for REINFORCE-style gradient estimation (Loop 1b).
      *
@@ -771,6 +796,19 @@ export class PersistentSONAEngine {
             }
             this.pendingSaves.clear();
         }
+        // A10 fix: checkpoint the request counter once per process lifetime
+        // (cheap — not on the instantAdapt hot path) so short-lived CLI/MCP
+        // processes accumulate progress toward consolidationInterval instead of
+        // resetting to 0 every time.
+        try {
+            const engine = this.baseEngine.getThreeLoopEngine();
+            if (engine && this.db) {
+                this.saveRequestCount(this.config.domain, engine.getRequestCount());
+            }
+        }
+        catch (err) {
+            console.warn('[PersistentSONAEngine] Request count checkpoint failed:', err instanceof Error ? err.message : err);
+        }
         this.prepared.clear();
         this.db = null;
         this.persistence = null;
@@ -866,6 +904,44 @@ export class PersistentSONAEngine {
         const result = stmt.run(domain);
         return result.changes > 0;
     }
+    /**
+     * A10 fix: persist the three-loop engine's request counter independently
+     * of the Fisher row, in kv_store (namespace 'sona'). Consolidation (the
+     * thing that writes the FIRST Fisher row) requires requestCount to reach
+     * consolidationInterval — but requestCount previously only survived via
+     * restoreFisher(), which only runs once a Fisher row already exists.
+     * Fresh short-lived CLI/MCP processes doing ~1 instantAdapt() each could
+     * never accumulate past the threshold: cold-start deadlock. This lets the
+     * counter accumulate across process restarts before any consolidation
+     * has ever happened.
+     */
+    saveRequestCount(domain, requestCount) {
+        if (!this.db)
+            return;
+        this.db.prepare(`
+      INSERT INTO kv_store (namespace, key, value)
+      VALUES ('sona', ?, ?)
+      ON CONFLICT(namespace, key) DO UPDATE SET value = excluded.value
+    `).run(`request-count:${domain}`, String(requestCount));
+    }
+    /** Load the persisted request counter for a domain, or null if never saved. */
+    loadRequestCount(domain) {
+        this.ensureInitialized();
+        return this._loadRequestCountUnsafe(domain);
+    }
+    /**
+     * Internal variant of loadRequestCount that skips ensureInitialized() —
+     * used during _doInitialize(), mirroring _loadFisherMatrixUnsafe.
+     */
+    _loadRequestCountUnsafe(domain) {
+        if (!this.db)
+            return null;
+        const row = this.db.prepare(`SELECT value FROM kv_store WHERE namespace = 'sona' AND key = ?`).get(`request-count:${domain}`);
+        if (!row)
+            return null;
+        const parsed = Number(row.value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
     // ==========================================================================
     // Server Integration
     // ==========================================================================

package/dist/integrations/ruvector/sona-three-loop.d.ts

@@ -335,6 +335,21 @@ export declare class SONAThreeLoopEngine {
     getEffectiveWeights(): Float32Array;
     /** Get the total number of requests processed */
     getRequestCount(): number;
+    /**
+     * Restore the request counter independently of Fisher state (A10 fix).
+     *
+     * Previously requestCount only survived process restarts via
+     * restoreFisher(), which only runs `if (saved)` — i.e. only after a
+     * Fisher row already exists. Since consolidation (the thing that WRITES
+     * the first Fisher row) requires requestCount to reach
+     * consolidationInterval (default 100), and each CLI/MCP invocation is a
+     * fresh short-lived process doing ~1 instantAdapt() call, requestCount
+     * could never accumulate across processes: cold-start deadlock, 0 rows
+     * in sona_fisher_matrices forever. Call this at init (independently of
+     * whether a Fisher row exists) so the counter accumulates across process
+     * restarts even before the first consolidation ever happens.
+     */
+    restoreRequestCount(count: number): void;
     /** Get the engine configuration */
     getConfig(): ThreeLoopConfig;
     /** Get the connected peer states */