agentic-qe 3.11.3 → 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/proof-gate.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Tamper-evident hash-chain audit gate — a faithful, dependency-free TypeScript
+ * port of RuVector's `ruvector-proof-gate` `HashChainGate` (upstream ADR-194;
+ * AQE-side integration decision: ADR-116).
+ *
+ * Why ported rather than bound: the Rust crate ships no NAPI/WASM binding, and
+ * the algorithm is small and exact. This uses only Node's `crypto` (no native
+ * dep) and opens NO database — the chain lives in memory and is serialized via
+ * {@link HashChainGate.toJSON}/{@link HashChainGate.fromJSON} so a caller can
+ * persist it through the existing unified `memory.db` (never a competing store).
+ *
+ * QE use-case: turn AQE's "verify row counts BEFORE and AFTER, never claim a
+ * sync/migration succeeded without proof" mandate into a cryptographic
+ * guarantee. Admit one payload per DB operation (table, op, row-count, content
+ * digest); a later `verifyIntegrity()` proves no admitted entry was mutated,
+ * reordered, or dropped.
+ *
+ * Commitment: commitment[n] = SHA256("ruvector:chain:" || commitment[n-1] ||
+ * payload_hash[n] || u64le(n)), seeded from a fixed genesis. Verification is
+ * O(n): replay from genesis. (Genesis differs from the Rust literal — we do not
+ * interoperate with Rust receipts, only self-verify.)
+ */
+/** Any admissible payload. Objects are canonicalized (sorted keys) before hashing. */
+export type GatePayload = string | Uint8Array | Record<string, unknown>;
+export interface WriteReceipt {
+    /** 0-based admission order. */
+    sequence: number;
+    /** SHA-256 of the canonical payload bytes (hex). */
+    payloadHash: string;
+    /** Chain commitment at this entry (hex) — binds it to every prior entry. */
+    chainCommitment: string;
+}
+/** Serializable chain state for persistence through the unified store. */
+export interface HashChainState {
+    seq: number;
+    head: string;
+    chain: string[];
+    payloadHashes: string[];
+}
+/**
+ * Sequential SHA-256 hash chain. O(1) per `admit`, O(n) `verifyIntegrity`.
+ * In-memory; persist/restore via {@link toJSON}/{@link fromJSON}.
+ */
+export declare class HashChainGate {
+    private seq;
+    private prev;
+    private readonly chain;
+    private readonly payloadHashes;
+    /** Admit a payload; returns a receipt committing the chain state. */
+    admit(payload: GatePayload): WriteReceipt;
+    /** True iff `receipt` matches the commitment recorded at its sequence. */
+    verifyReceipt(receipt: WriteReceipt): boolean;
+    /** Current chain head (hex). Changes after every successful `admit`. */
+    chainRoot(): string;
+    get length(): number;
+    get isEmpty(): boolean;
+    /**
+     * Full cryptographic re-derivation from genesis. Returns false if ANY
+     * commitment fails to re-derive — catches a mutated commitment, a mutated
+     * payload hash, a reorder, or a length mismatch.
+     */
+    verifyIntegrity(): boolean;
+    /** Snapshot for persistence through the unified store (no DB opened here). */
+    toJSON(): HashChainState;
+    /** Restore a chain from a {@link toJSON} snapshot. */
+    static fromJSON(state: HashChainState): HashChainGate;
+}
+//# sourceMappingURL=proof-gate.d.ts.map