agentic-qe 3.9.0 → 3.9.2

package/dist/coordination/agent-memory-branch.js

@@ -0,0 +1,213 @@
+/**
+ * Agent Memory Branching via RVF Copy-on-Write (ADR-067)
+ *
+ * Provides per-agent isolated memory branches using RVF's COW derive().
+ * Each spawned agent gets a lightweight .rvf branch file that shares
+ * the parent's data via copy-on-write. Writes are isolated to the branch.
+ *
+ * Lifecycle:
+ *   spawn → createBranch() → agent works on isolated branch
+ *   success → mergeBranch() → changed vectors flow back to parent
+ *   failure → discardBranch() → delete branch file (zero cost)
+ *
+ * Storage cost: ~0.5% of parent for typical agent workloads
+ * (only changed vectors are physically copied).
+ *
+ * @module coordination/agent-memory-branch
+ */
+import { existsSync, mkdirSync, unlinkSync, readdirSync, statSync } from 'fs';
+import { join, basename } from 'path';
+const DEFAULT_CONFIG = {
+    branchDir: '.agentic-qe/branches',
+    defaultStrategy: 'child-wins',
+    orphanMaxAgeMs: 3600_000, // 1 hour
+};
+// ============================================================================
+// AgentMemoryBranch Service
+// ============================================================================
+export class AgentMemoryBranch {
+    config;
+    parentAdapter;
+    activeBranches = new Map();
+    witnessChain = null;
+    constructor(parentAdapter, config) {
+        this.parentAdapter = parentAdapter;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /** Attach a witness chain for merge/discard audit trail */
+    setWitnessChain(wc) {
+        this.witnessChain = wc;
+    }
+    // --------------------------------------------------------------------------
+    // Branch Lifecycle
+    // --------------------------------------------------------------------------
+    /**
+     * Create a COW branch for an agent.
+     * The child .rvf inherits all parent data via copy-on-write.
+     * Reads fall through to parent; writes are isolated to the child.
+     */
+    createBranch(agentId) {
+        if (this.activeBranches.has(agentId)) {
+            throw new Error(`Branch already exists for agent ${agentId}`);
+        }
+        // Ensure branch directory exists
+        if (!existsSync(this.config.branchDir)) {
+            mkdirSync(this.config.branchDir, { recursive: true });
+        }
+        const childPath = join(this.config.branchDir, `${agentId}.rvf`);
+        const parentPath = this.parentAdapter.path();
+        // COW derive — creates lightweight child sharing parent's data
+        const childAdapter = this.parentAdapter.derive(childPath);
+        const handle = {
+            agentId,
+            childPath,
+            parentPath,
+            childAdapter,
+            createdAt: Date.now(),
+            ingestLog: [],
+        };
+        this.activeBranches.set(agentId, handle);
+        return handle;
+    }
+    /**
+     * Record a vector that an agent ingested into its branch.
+     * This log is replayed into the parent on merge (child-wins strategy).
+     *
+     * Agents MUST call this alongside childAdapter.ingest() so that
+     * merge can replay the actual vectors into the parent.
+     */
+    recordIngest(agentId, entries) {
+        const handle = this.activeBranches.get(agentId);
+        if (!handle)
+            return;
+        for (const entry of entries) {
+            handle.ingestLog.push({ id: entry.id, vector: entry.vector });
+        }
+    }
+    /**
+     * Merge a successful agent's branch back to the parent.
+     * Replays the agent's ingest log into the parent (child-wins) or
+     * discards all child changes (parent-wins).
+     */
+    async mergeBranch(handle, strategy) {
+        const mergeStrategy = strategy ?? this.config.defaultStrategy;
+        const startTime = performance.now();
+        let vectorsMerged = 0;
+        if (mergeStrategy === 'child-wins' && handle.ingestLog.length > 0) {
+            // Replay the agent's ingest log into the parent
+            // These are the actual vectors the agent wrote — no zero-vector placeholders
+            try {
+                const result = this.parentAdapter.ingest(handle.ingestLog);
+                vectorsMerged = result.accepted;
+            }
+            catch (error) {
+                console.warn(`[AgentMemoryBranch] Merge replay failed for ${handle.agentId}:`, error);
+            }
+        }
+        // parent-wins: nothing to do — child changes are discarded
+        // Record in witness chain
+        this.witnessChain?.append('BRANCH_MERGE', {
+            agentId: handle.agentId,
+            strategy: mergeStrategy,
+            vectorsMerged,
+            branchPath: handle.childPath,
+        }, `agent-${handle.agentId}`);
+        // Cleanup child
+        this.cleanupBranchFile(handle);
+        this.activeBranches.delete(handle.agentId);
+        return {
+            vectorsMerged,
+            strategy: mergeStrategy,
+            durationMs: performance.now() - startTime,
+        };
+    }
+    /**
+     * Discard a failed agent's branch.
+     * Simply deletes the child .rvf file — zero computational cost.
+     */
+    discardBranch(handle) {
+        // Record in witness chain
+        this.witnessChain?.append('BRANCH_DISCARD', {
+            agentId: handle.agentId,
+            action: 'discard',
+            branchPath: handle.childPath,
+        }, `agent-${handle.agentId}`);
+        this.cleanupBranchFile(handle);
+        this.activeBranches.delete(handle.agentId);
+    }
+    // --------------------------------------------------------------------------
+    // Branch Management
+    // --------------------------------------------------------------------------
+    /** Get active branch for an agent (if any) */
+    getBranch(agentId) {
+        return this.activeBranches.get(agentId);
+    }
+    /** List all active branches */
+    getActiveBranches() {
+        return Array.from(this.activeBranches.values());
+    }
+    /** List all branch files on disk (including orphans) */
+    listBranchFiles() {
+        if (!existsSync(this.config.branchDir))
+            return [];
+        const files = readdirSync(this.config.branchDir)
+            .filter(f => f.endsWith('.rvf'));
+        return files.map(f => {
+            const fullPath = join(this.config.branchDir, f);
+            const stat = statSync(fullPath);
+            return {
+                agentId: basename(f, '.rvf'),
+                path: fullPath,
+                sizeBytes: stat.size,
+                modifiedAt: stat.mtime,
+            };
+        });
+    }
+    /**
+     * Clean up orphaned branch files older than maxAge.
+     * An orphan is a .rvf file in branchDir with no active branch.
+     */
+    cleanupOrphans(maxAgeMs) {
+        const maxAge = maxAgeMs ?? this.config.orphanMaxAgeMs;
+        const now = Date.now();
+        let cleaned = 0;
+        for (const info of this.listBranchFiles()) {
+            const age = now - info.modifiedAt.getTime();
+            if (age > maxAge && !this.activeBranches.has(info.agentId)) {
+                try {
+                    unlinkSync(info.path);
+                    // Also remove idmap sidecar if present
+                    const idmapPath = `${info.path}.idmap.json`;
+                    if (existsSync(idmapPath))
+                        unlinkSync(idmapPath);
+                    cleaned++;
+                }
+                catch {
+                    // Best effort cleanup
+                }
+            }
+        }
+        return cleaned;
+    }
+    // --------------------------------------------------------------------------
+    // Private Helpers
+    // --------------------------------------------------------------------------
+    cleanupBranchFile(handle) {
+        try {
+            handle.childAdapter.close();
+        }
+        catch { /* best effort */ }
+        try {
+            if (existsSync(handle.childPath)) {
+                unlinkSync(handle.childPath);
+            }
+            // Remove idmap sidecar
+            const idmapPath = `${handle.childPath}.idmap.json`;
+            if (existsSync(idmapPath)) {
+                unlinkSync(idmapPath);
+            }
+        }
+        catch { /* best effort */ }
+    }
+}
+//# sourceMappingURL=agent-memory-branch.js.map

package/dist/coordination/agent-teams/mailbox.d.ts

@@ -24,6 +24,15 @@ export declare class MailboxService {
     private readonly broadcastHandlers;
     /** Index of agents by domain for efficient broadcast */
     private readonly domainAgents;
+    /** R13: Optional cognitive router for bandwidth-efficient messaging (lazy-initialized) */
+    private cognitiveRouter;
+    private cognitiveRouterInitialized;
+    /**
+     * R13: Tracks which messages were stored with compressed payloads.
+     * Maps message ID to the RoutedMessage needed for decompression on receive().
+     * This avoids modifying the AgentMessage type while enabling real compression.
+     */
+    private readonly compressedMessages;
     /**
      * Create a mailbox for an agent. If a mailbox already exists for this
      * agent ID, the existing mailbox is returned unchanged.
@@ -132,6 +141,40 @@ export declare class MailboxService {
      * Create an immutable snapshot of a mutable mailbox.
      */
     private toSnapshot;
+    /**
+     * Lazily initialize the cognitive router when the feature flag is enabled.
+     * Returns the router instance or null if disabled / unavailable.
+     */
+    private ensureCognitiveRouter;
+    /**
+     * Attempt to compress a message via the cognitive router.
+     * When compression succeeds (compressed payload is smaller), returns a new
+     * AgentMessage with the compressed payload and tracks the RoutedMessage
+     * for later decompression. When compression is unavailable or unhelpful,
+     * returns the original message unchanged.
+     *
+     * Non-blocking: any error returns the original message unmodified.
+     */
+    private compressViaCognitive;
+    /**
+     * Decompress messages that were stored with compressed payloads.
+     * Uses the cognitive router's receive() to reconstruct original payloads.
+     * Messages that were not compressed are returned unchanged.
+     *
+     * Non-blocking: decompression failures return the stored payload as-is.
+     */
+    private decompressMessages;
+    /**
+     * Get cognitive routing statistics (bandwidth savings, compression rates).
+     * Returns null if cognitive routing is not enabled or not initialized.
+     */
+    getCognitiveRoutingStats(): {
+        totalMessages: number;
+        compressedMessages: number;
+        bandwidthSavedBytes: number;
+        bandwidthReductionPercent: number;
+        activeStreams: number;
+    } | null;
 }
 /**
  * Create a new MailboxService instance.

package/dist/coordination/agent-teams/mailbox.js

@@ -10,6 +10,7 @@
  * - Unread tracking with peek support
  * - Event callbacks for message arrival
  */
+import { isCognitiveRoutingEnabled, createCognitiveRouter, } from '../../integrations/ruvector/cognitive-routing.js';
 // ============================================================================
 // Mailbox Service
 // ============================================================================
@@ -26,6 +27,15 @@ export class MailboxService {
     broadcastHandlers = new Map();
     /** Index of agents by domain for efficient broadcast */
     domainAgents = new Map();
+    /** R13: Optional cognitive router for bandwidth-efficient messaging (lazy-initialized) */
+    cognitiveRouter = null;
+    cognitiveRouterInitialized = false;
+    /**
+     * R13: Tracks which messages were stored with compressed payloads.
+     * Maps message ID to the RoutedMessage needed for decompression on receive().
+     * This avoids modifying the AgentMessage type while enabling real compression.
+     */
+    compressedMessages = new Map();
     // ============================================================================
     // Mailbox Lifecycle
     // ============================================================================
@@ -89,6 +99,10 @@ export class MailboxService {
                 this.domainAgents.delete(mailbox.domain);
             }
         }
+        // R13: Clean up compressed message tracking for this mailbox
+        for (const msg of mailbox.messages) {
+            this.compressedMessages.delete(msg.id);
+        }
         // Remove handlers
         this.messageHandlers.delete(agentId);
         // Remove mailbox
@@ -115,7 +129,12 @@ export class MailboxService {
             throw new Error(`No mailbox found for agent '${message.to}'. ` +
                 `Create a mailbox first with createMailbox().`);
         }
-        mailbox.messages.push(message);
+        // R13: Route through cognitive router for bandwidth compression.
+        // When compression succeeds, store the smaller compressed payload instead
+        // of the original. The original is reconstructed on receive().
+        // Non-blocking: routing failure must not prevent message delivery.
+        const messageToStore = this.compressViaCognitive(message);
+        mailbox.messages.push(messageToStore);
         mailbox.unreadCount++;
         // Notify listeners
         const handlers = this.messageHandlers.get(message.to);
@@ -211,7 +230,9 @@ export class MailboxService {
         // Mark all as read (regardless of filters, reading marks the mailbox)
         mailbox.unreadCount = 0;
         mailbox.lastRead = now;
-        return unread;
+        // R13: Decompress any messages that were stored with compressed payloads.
+        // Returns original payloads to the consumer transparently.
+        return this.decompressMessages(unread);
     }
     /**
      * Check unread message count without marking any as read.
@@ -254,11 +275,15 @@ export class MailboxService {
             const readIndex = mailbox.messages.length - mailbox.unreadCount;
             mailbox.messages = mailbox.messages.filter((msg, index) => {
                 // Remove if older than max age
-                if (msg.timestamp < cutoff)
+                if (msg.timestamp < cutoff) {
+                    this.compressedMessages.delete(msg.id); // R13: clean up tracking
                     return false;
+                }
                 // Remove if TTL expired
-                if (this.isExpired(msg, now))
+                if (this.isExpired(msg, now)) {
+                    this.compressedMessages.delete(msg.id); // R13: clean up tracking
                     return false;
+                }
                 return true;
             });
             const removedFromMailbox = before - mailbox.messages.length;
@@ -356,6 +381,9 @@ export class MailboxService {
         this.messageHandlers.clear();
         this.broadcastHandlers.clear();
         this.domainAgents.clear();
+        this.compressedMessages.clear(); // R13: clear compressed message index
+        this.cognitiveRouter = null; // R13: reset cognitive router
+        this.cognitiveRouterInitialized = false;
     }
     // ============================================================================
     // Private Helpers
@@ -380,6 +408,104 @@ export class MailboxService {
             lastRead: mailbox.lastRead,
         };
     }
+    // ============================================================================
+    // R13: Cognitive Routing Integration (ADR-087)
+    // ============================================================================
+    /**
+     * Lazily initialize the cognitive router when the feature flag is enabled.
+     * Returns the router instance or null if disabled / unavailable.
+     */
+    ensureCognitiveRouter() {
+        if (this.cognitiveRouterInitialized) {
+            return this.cognitiveRouter;
+        }
+        this.cognitiveRouterInitialized = true;
+        if (!isCognitiveRoutingEnabled()) {
+            return null;
+        }
+        try {
+            this.cognitiveRouter = createCognitiveRouter() ?? null;
+        }
+        catch {
+            // Module unavailable — leave router null
+            this.cognitiveRouter = null;
+        }
+        return this.cognitiveRouter;
+    }
+    /**
+     * Attempt to compress a message via the cognitive router.
+     * When compression succeeds (compressed payload is smaller), returns a new
+     * AgentMessage with the compressed payload and tracks the RoutedMessage
+     * for later decompression. When compression is unavailable or unhelpful,
+     * returns the original message unchanged.
+     *
+     * Non-blocking: any error returns the original message unmodified.
+     */
+    compressViaCognitive(message) {
+        try {
+            const router = this.ensureCognitiveRouter();
+            if (!router)
+                return message;
+            const streamId = `${message.from}->${message.to}`;
+            const routed = router.send(streamId, message.from, message.to, message.payload);
+            // Only store compressed version when it actually saves space
+            if (routed.compressed && routed.compressedSize < routed.originalSize) {
+                // Track the RoutedMessage so receive() can decompress
+                this.compressedMessages.set(message.id, routed);
+                // Return a copy with the compressed (delta) payload
+                return {
+                    ...message,
+                    payload: routed.payload,
+                };
+            }
+            // Compression didn't help — return original
+            return message;
+        }
+        catch {
+            // Routing failure must never prevent message delivery
+            return message;
+        }
+    }
+    /**
+     * Decompress messages that were stored with compressed payloads.
+     * Uses the cognitive router's receive() to reconstruct original payloads.
+     * Messages that were not compressed are returned unchanged.
+     *
+     * Non-blocking: decompression failures return the stored payload as-is.
+     */
+    decompressMessages(messages) {
+        const router = this.cognitiveRouter;
+        if (!router || this.compressedMessages.size === 0)
+            return messages;
+        return messages.map(msg => {
+            try {
+                const routed = this.compressedMessages.get(msg.id);
+                if (!routed)
+                    return msg;
+                // Decompress via the router's receive path
+                const originalPayload = router.receive(routed);
+                // Clean up — message has been delivered/decompressed
+                this.compressedMessages.delete(msg.id);
+                return {
+                    ...msg,
+                    payload: originalPayload,
+                };
+            }
+            catch {
+                // Decompression failure — return the stored payload as-is
+                return msg;
+            }
+        });
+    }
+    /**
+     * Get cognitive routing statistics (bandwidth savings, compression rates).
+     * Returns null if cognitive routing is not enabled or not initialized.
+     */
+    getCognitiveRoutingStats() {
+        if (!this.cognitiveRouter)
+            return null;
+        return this.cognitiveRouter.getStats();
+    }
 }
 // ============================================================================
 // Factory Function

package/dist/coordination/handlers/handler-utils.d.ts

@@ -95,6 +95,7 @@ export declare function parseCoberturaXml(content: string): CoverageData;
 export declare function discoverSourceFiles(targetPath: string, options?: {
     includeTests?: boolean;
     languages?: string[];
+    maxFiles?: number;
 }): Promise<string[]>;
 /**
  * Generate security recommendations based on findings

package/dist/coordination/handlers/handler-utils.js

@@ -342,7 +342,7 @@ export function parseCoberturaXml(content) {
  */
 export async function discoverSourceFiles(targetPath, options = {}) {
     const files = [];
-    const { includeTests = true, languages } = options;
+    const { includeTests = true, languages, maxFiles = 5000 } = options;
     // Determine file extensions to include
     // Default: scan ALL common source languages unless explicitly filtered
     let extensions = [
@@ -398,9 +398,14 @@ export async function discoverSourceFiles(targetPath, options = {}) {
                 if (entry.isDirectory()) {
                     if (['node_modules', '.git', 'dist', 'build', 'coverage', '.nyc_output',
                         '__pycache__', '.venv', 'venv', '.tox', '.mypy_cache', 'target',
-                        '.gradle', 'vendor', '.bundle'].includes(entry.name)) {
+                        '.gradle', 'vendor', '.bundle',
+                        '.agentic-qe', '.claude', '.cache', '.npm', '.yarn',
+                        '.next', '.nuxt', '.svelte-kit', 'out', '.turbo',
+                        'tmp', 'temp', '.tmp'].includes(entry.name)) {
                         continue;
                     }
+                    if (files.length >= maxFiles)
+                        return; // Cap reached
                     await walkDir(fullPath);
                 }
                 else if (entry.isFile()) {
@@ -420,6 +425,8 @@ export async function discoverSourceFiles(targetPath, options = {}) {
                         if (isTestFile)
                             continue;
                     }
+                    if (files.length >= maxFiles)
+                        return; // Cap reached
                     files.push(fullPath);
                 }
             }

package/dist/coordination/handlers/quality-handlers.js

@@ -23,7 +23,13 @@ export function registerQualityHandlers(ctx) {
                 sourceFiles = await discoverSourceFiles(payload.target, { includeTests: false });
             }
             else {
-                sourceFiles = await discoverSourceFiles(process.cwd(), { includeTests: false });
+                // Default to src/ — scanning the entire project root is too slow
+                // (node_modules, dist, .git, etc. make it hang on large projects)
+                const path = await import('path');
+                const fs = await import('fs');
+                const srcDir = path.join(process.cwd(), 'src');
+                const targetDir = fs.existsSync(srcDir) ? srcDir : process.cwd();
+                sourceFiles = await discoverSourceFiles(targetDir, { includeTests: false });
             }
             if (sourceFiles.length === 0) {
                 return ok({

package/dist/domains/contract-testing/coordinator.js

@@ -972,6 +972,17 @@ export class ContractTestingCoordinator extends BaseDomainCoordinator {
                     validationSuccess ? 1 : 0,
                     contract.version.major / 10,
                 ]);
+                // EWC++ outcome recording: reward based on validation result
+                try {
+                    this.qesona.recordOutcome(validationSuccess ? quality : -quality);
+                    if (this.qesona.shouldConsolidate()) {
+                        try {
+                            this.qesona.backgroundConsolidate();
+                        }
+                        catch { /* best-effort */ }
+                    }
+                }
+                catch { /* must not break main flow */ }
             }
             const action = {
                 type: validationSuccess ? 'validate' : 'reject',

package/dist/domains/quality-assessment/coherence/gate-controller.d.ts

@@ -5,7 +5,7 @@
  * Evaluates quality lambda and makes 4-tier deployment decisions.
  * Based on ruvector-mincut-gated-transformer's gate control patterns.
  */
-import { QualityLambda, QualityTier, QualityGateDecision, CoherenceGatePolicy } from './types';
+import { QualityLambda, QualityTier, QualityGateDecision, CoherenceGatePolicy, RatchetConfig, RatchetState } from './types';
 /**
  * Configuration for the coherence gate controller
  */
@@ -106,6 +106,25 @@ export declare class CoherenceGateController {
      */
     private recordDecision;
 }
+/**
+ * Check whether a ratchet should occur based on the gate pass/fail result
+ * and return the updated ratchet state.
+ *
+ * Ratcheting rules:
+ * - If gate passed: increment consecutivePasses
+ * - If consecutivePasses >= required AND cooldown elapsed: ratchet up
+ * - Threshold is capped at maxThreshold (95% default)
+ * - MONOTONIC INVARIANT: new threshold >= old threshold (never decreases)
+ * - If gate failed: reset consecutivePasses to 0
+ * - If feature flag disabled: return state unchanged
+ *
+ * @param passed - Whether the quality gate passed
+ * @param config - Ratchet configuration
+ * @param state - Current ratchet state
+ * @param now - Current timestamp in ms (default: Date.now())
+ * @returns Updated ratchet state
+ */
+export declare function checkRatchet(passed: boolean, config: RatchetConfig, state: RatchetState, now?: number): RatchetState;
 /**
  * Factory function to create a coherence gate controller
  */

package/dist/domains/quality-assessment/coherence/gate-controller.js

@@ -396,6 +396,70 @@ export class CoherenceGateController {
         }
     }
 }
+// ============================================================================
+// ADR-062 Tier 2: Monotonic Gate Threshold Ratcheting
+// ============================================================================
+/**
+ * Check whether a ratchet should occur based on the gate pass/fail result
+ * and return the updated ratchet state.
+ *
+ * Ratcheting rules:
+ * - If gate passed: increment consecutivePasses
+ * - If consecutivePasses >= required AND cooldown elapsed: ratchet up
+ * - Threshold is capped at maxThreshold (95% default)
+ * - MONOTONIC INVARIANT: new threshold >= old threshold (never decreases)
+ * - If gate failed: reset consecutivePasses to 0
+ * - If feature flag disabled: return state unchanged
+ *
+ * @param passed - Whether the quality gate passed
+ * @param config - Ratchet configuration
+ * @param state - Current ratchet state
+ * @param now - Current timestamp in ms (default: Date.now())
+ * @returns Updated ratchet state
+ */
+export function checkRatchet(passed, config, state, now = Date.now()) {
+    // Feature flag check: if disabled via env or config, return state unchanged
+    if (process.env.AQE_GATE_RATCHETING_ENABLED !== 'true' || !config.enabled) {
+        return state;
+    }
+    // Clone state to avoid mutation
+    const newState = {
+        currentThreshold: state.currentThreshold,
+        consecutivePasses: state.consecutivePasses,
+        lastRatchetTime: state.lastRatchetTime,
+        history: [...state.history],
+    };
+    if (!passed) {
+        // Gate failed: reset consecutive passes counter
+        newState.consecutivePasses = 0;
+        return newState;
+    }
+    // Gate passed: increment consecutive passes
+    newState.consecutivePasses = newState.consecutivePasses + 1;
+    // Check if we should ratchet
+    const hasEnoughPasses = newState.consecutivePasses >= config.consecutivePassesRequired;
+    const cooldownElapsed = (now - newState.lastRatchetTime) >= config.cooldownMs;
+    if (hasEnoughPasses && cooldownElapsed) {
+        // Calculate new threshold
+        const proposedThreshold = newState.currentThreshold + config.ratchetIncrementPercent;
+        // Cap at max threshold
+        const cappedThreshold = Math.min(proposedThreshold, config.maxThreshold);
+        // MONOTONIC INVARIANT: never decrease
+        const newThreshold = Math.max(cappedThreshold, newState.currentThreshold);
+        // Only record a ratchet if threshold actually changed
+        if (newThreshold > newState.currentThreshold) {
+            newState.currentThreshold = newThreshold;
+            newState.lastRatchetTime = now;
+            newState.history.push({
+                threshold: newThreshold,
+                ratchetedAt: now,
+            });
+        }
+        // Reset consecutive passes after ratchet attempt (whether or not threshold changed)
+        newState.consecutivePasses = 0;
+    }
+    return newState;
+}
 /**
  * Factory function to create a coherence gate controller
  */

package/dist/domains/quality-assessment/coherence/index.d.ts

@@ -40,12 +40,12 @@
  * console.log(`Found ${partitions.partitionCount} quality partitions`);
  * ```
  */
-export type { QualityLambda, QualityDimensions, QualityMetricsInput, QualityGateReason, QualityAction, QualityGateDecision, CoherenceGatePolicy, QualityPartition, LambdaHistoryPoint, LambdaTrend, } from './types.js';
-export { QualityTier, QualityLambdaFlags, DEFAULT_COHERENCE_GATE_POLICY, } from './types.js';
+export type { QualityLambda, QualityDimensions, QualityMetricsInput, QualityGateReason, QualityAction, QualityGateDecision, CoherenceGatePolicy, QualityPartition, LambdaHistoryPoint, LambdaTrend, RatchetConfig, RatchetState, } from './types.js';
+export { QualityTier, QualityLambdaFlags, DEFAULT_COHERENCE_GATE_POLICY, DEFAULT_RATCHET_CONFIG, } from './types.js';
 export type { QualityPartitionType } from './types.js';
 export { LambdaCalculator, createLambdaCalculator, calculateQualityLambda, } from './lambda-calculator.js';
 export type { LambdaCalculatorConfig, } from './lambda-calculator.js';
-export { CoherenceGateController, createCoherenceGateController, evaluateQualityGate, } from './gate-controller.js';
+export { CoherenceGateController, createCoherenceGateController, evaluateQualityGate, checkRatchet, } from './gate-controller.js';
 export type { CoherenceGateControllerConfig, } from './gate-controller.js';
 export { PartitionDetector, createPartitionDetector, detectQualityPartitions, } from './partition-detector.js';
 export type { PartitionDetectorConfig, PartitionDetectionResult, RemediationStep, RemediationPlan, } from './partition-detector.js';

package/dist/domains/quality-assessment/coherence/index.js

@@ -41,11 +41,11 @@
  * ```
  */
 // Runtime values (enums and constants)
-export { QualityTier, QualityLambdaFlags, DEFAULT_COHERENCE_GATE_POLICY, } from './types.js';
+export { QualityTier, QualityLambdaFlags, DEFAULT_COHERENCE_GATE_POLICY, DEFAULT_RATCHET_CONFIG, } from './types.js';
 // Lambda Calculator
 export { LambdaCalculator, createLambdaCalculator, calculateQualityLambda, } from './lambda-calculator.js';
 // Gate Controller
-export { CoherenceGateController, createCoherenceGateController, evaluateQualityGate, } from './gate-controller.js';
+export { CoherenceGateController, createCoherenceGateController, evaluateQualityGate, checkRatchet, } from './gate-controller.js';
 // Partition Detector
 export { PartitionDetector, createPartitionDetector, detectQualityPartitions, } from './partition-detector.js';
 import { calculateQualityLambda } from './lambda-calculator.js';