agentic-qe 3.2.2 → 3.3.0

package/v3/dist/integrations/coherence/engines/homotopy-adapter.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Agentic QE v3 - Homotopy Engine Adapter
+ *
+ * Wraps the Prime Radiant HomotopyEngine for homotopy type theory operations.
+ * Used for formal verification and path equivalence checking.
+ *
+ * Homotopy Type Theory (HoTT) in QE:
+ * - Types are spaces
+ * - Terms are points
+ * - Equalities are paths
+ * - Higher equalities are paths between paths
+ *
+ * This enables formal verification of agent reasoning paths and
+ * proof that different execution strategies lead to equivalent results.
+ *
+ * @module integrations/coherence/engines/homotopy-adapter
+ */
+import type { IWasmLoader, CoherenceLogger } from '../types';
+/**
+ * A proposition for formal verification
+ */
+export interface Proposition {
+    /** Unique proposition identifier */
+    id: string;
+    /** Formal statement/formula */
+    formula: string;
+    /** Natural language description */
+    description?: string;
+    /** Whether this has been proven */
+    proven: boolean;
+}
+/**
+ * Result of a path equivalence check
+ */
+export interface PathEquivalenceResult {
+    /** Whether the paths are equivalent */
+    equivalent: boolean;
+    /** The first path */
+    path1: string[];
+    /** The second path */
+    path2: string[];
+    /** Explanation of the result */
+    explanation: string;
+}
+/**
+ * Verification status for the proof system
+ */
+export interface VerificationStatus {
+    /** Total propositions registered */
+    totalPropositions: number;
+    /** Number of proven propositions */
+    provenCount: number;
+    /** List of unproven proposition IDs */
+    unprovenIds: string[];
+    /** Overall verification percentage */
+    verificationPercentage: number;
+}
+/**
+ * Interface for the homotopy adapter
+ */
+export interface IHomotopyAdapter {
+    /** Initialize the adapter */
+    initialize(): Promise<void>;
+    /** Check if initialized */
+    isInitialized(): boolean;
+    /** Add a proposition to verify */
+    addProposition(id: string, formula: string): void;
+    /** Attempt to prove a proposition */
+    addProof(propositionId: string, proof: string): boolean;
+    /** Check if two execution paths are equivalent */
+    verifyPathEquivalence(path1: string[], path2: string[]): PathEquivalenceResult;
+    /** Get all unproven propositions */
+    getUnprovenPropositions(): string[];
+    /** Get verification status */
+    getVerificationStatus(): VerificationStatus;
+    /** Clear all propositions and proofs */
+    clear(): void;
+    /** Dispose of resources */
+    dispose(): void;
+}
+/**
+ * Adapter for the Prime Radiant HomotopyEngine
+ *
+ * Provides homotopy type theory operations for formal verification
+ * of agent behavior and reasoning path equivalence.
+ *
+ * @example
+ * ```typescript
+ * const adapter = new HomotopyAdapter(wasmLoader, logger);
+ * await adapter.initialize();
+ *
+ * // Add propositions about test generation
+ * adapter.addProposition('gen_complete', 'forall f. exists t. covers(t, f)');
+ * adapter.addProposition('gen_sound', 'forall t. valid(t) implies passes(t)');
+ *
+ * // Provide proofs
+ * adapter.addProof('gen_complete', 'by induction on structure of f...');
+ *
+ * // Check path equivalence
+ * const result = adapter.verifyPathEquivalence(
+ *   ['parse', 'analyze', 'generate'],
+ *   ['parse', 'simplify', 'analyze', 'generate']
+ * );
+ * ```
+ */
+export declare class HomotopyAdapter implements IHomotopyAdapter {
+    private readonly wasmLoader;
+    private readonly logger;
+    private engine;
+    private initialized;
+    private readonly propositions;
+    /**
+     * Create a new HomotopyAdapter
+     *
+     * @param wasmLoader - WASM module loader
+     * @param logger - Optional logger for diagnostics
+     */
+    constructor(wasmLoader: IWasmLoader, logger?: CoherenceLogger);
+    /**
+     * Initialize the adapter by loading the WASM module
+     */
+    initialize(): Promise<void>;
+    /**
+     * Check if the adapter is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Ensure the adapter is initialized before use
+     */
+    private ensureInitialized;
+    /**
+     * Add a proposition to verify
+     *
+     * @param id - Unique identifier for the proposition
+     * @param formula - Formal statement in the proof language
+     */
+    addProposition(id: string, formula: string): void;
+    /**
+     * Attempt to prove a proposition
+     *
+     * @param propositionId - ID of the proposition to prove
+     * @param proof - The proof term/script
+     * @returns True if the proof is valid
+     */
+    addProof(propositionId: string, proof: string): boolean;
+    /**
+     * Verify that two execution paths are equivalent
+     *
+     * In HoTT, paths represent equalities. This checks if two different
+     * execution strategies lead to the same result (up to homotopy).
+     *
+     * @param path1 - First execution path (sequence of operations)
+     * @param path2 - Second execution path
+     * @returns Path equivalence result
+     */
+    verifyPathEquivalence(path1: string[], path2: string[]): PathEquivalenceResult;
+    /**
+     * Generate an explanation for path equivalence result
+     */
+    private generateEquivalenceExplanation;
+    /**
+     * Get all unproven propositions
+     *
+     * @returns Array of unproven proposition IDs
+     */
+    getUnprovenPropositions(): string[];
+    /**
+     * Get overall verification status
+     *
+     * @returns Verification status summary
+     */
+    getVerificationStatus(): VerificationStatus;
+    /**
+     * Get a proposition by ID
+     *
+     * @param id - Proposition ID
+     * @returns The proposition or undefined
+     */
+    getProposition(id: string): Proposition | undefined;
+    /**
+     * Clear all propositions and proofs
+     */
+    clear(): void;
+    /**
+     * Dispose of adapter resources
+     */
+    dispose(): void;
+    /**
+     * Get the number of propositions
+     */
+    getPropositionCount(): number;
+}
+/**
+ * Create and initialize a HomotopyAdapter
+ *
+ * @param wasmLoader - WASM module loader
+ * @param logger - Optional logger
+ * @returns Initialized adapter
+ */
+export declare function createHomotopyAdapter(wasmLoader: IWasmLoader, logger?: CoherenceLogger): Promise<HomotopyAdapter>;
+//# sourceMappingURL=homotopy-adapter.d.ts.map

package/v3/dist/integrations/coherence/engines/homotopy-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"homotopy-adapter.d.ts","sourceRoot":"","sources":["../../../../src/integrations/coherence/engines/homotopy-adapter.ts"],"names":[],"mappings":"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"}

package/v3/dist/integrations/coherence/engines/homotopy-adapter.js

@@ -0,0 +1,324 @@
+/**
+ * Agentic QE v3 - Homotopy Engine Adapter
+ *
+ * Wraps the Prime Radiant HomotopyEngine for homotopy type theory operations.
+ * Used for formal verification and path equivalence checking.
+ *
+ * Homotopy Type Theory (HoTT) in QE:
+ * - Types are spaces
+ * - Terms are points
+ * - Equalities are paths
+ * - Higher equalities are paths between paths
+ *
+ * This enables formal verification of agent reasoning paths and
+ * proof that different execution strategies lead to equivalent results.
+ *
+ * @module integrations/coherence/engines/homotopy-adapter
+ */
+import { WasmNotLoadedError, DEFAULT_COHERENCE_LOGGER } from '../types';
+// ============================================================================
+// WASM Engine Wrapper
+// ============================================================================
+/**
+ * Creates an IHomotopyEngine wrapper around the raw HoTT WASM engine
+ */
+function createHomotopyEngineWrapper(rawEngine) {
+    const propositions = new Map();
+    const proofs = new Map();
+    return {
+        add_proposition(id, formula) {
+            propositions.set(id, { formula, proven: false });
+        },
+        add_proof(propositionId, proof) {
+            const prop = propositions.get(propositionId);
+            if (!prop)
+                return false;
+            // Use HoTT engine to type-check the proof
+            const proofTerm = { id: propositionId, proof };
+            const expectedType = { formula: prop.formula };
+            const result = rawEngine.typeCheck(proofTerm, expectedType);
+            if (result?.valid) {
+                prop.proven = true;
+                proofs.set(propositionId, proof);
+                return true;
+            }
+            return false;
+        },
+        verify_path_equivalence(path1, path2) {
+            // Create path representations
+            const pathObj1 = { steps: path1 };
+            const pathObj2 = { steps: path2 };
+            // Check if paths are equivalent using HoTT type equivalence
+            return rawEngine.checkTypeEquivalence(pathObj1, pathObj2);
+        },
+        get_unproven_propositions() {
+            const unproven = [];
+            propositions.forEach((prop, id) => {
+                if (!prop.proven) {
+                    unproven.push(id);
+                }
+            });
+            return unproven;
+        },
+        clear() {
+            propositions.clear();
+            proofs.clear();
+        },
+    };
+}
+// ============================================================================
+// Homotopy Adapter Implementation
+// ============================================================================
+/**
+ * Adapter for the Prime Radiant HomotopyEngine
+ *
+ * Provides homotopy type theory operations for formal verification
+ * of agent behavior and reasoning path equivalence.
+ *
+ * @example
+ * ```typescript
+ * const adapter = new HomotopyAdapter(wasmLoader, logger);
+ * await adapter.initialize();
+ *
+ * // Add propositions about test generation
+ * adapter.addProposition('gen_complete', 'forall f. exists t. covers(t, f)');
+ * adapter.addProposition('gen_sound', 'forall t. valid(t) implies passes(t)');
+ *
+ * // Provide proofs
+ * adapter.addProof('gen_complete', 'by induction on structure of f...');
+ *
+ * // Check path equivalence
+ * const result = adapter.verifyPathEquivalence(
+ *   ['parse', 'analyze', 'generate'],
+ *   ['parse', 'simplify', 'analyze', 'generate']
+ * );
+ * ```
+ */
+export class HomotopyAdapter {
+    wasmLoader;
+    logger;
+    engine = null;
+    initialized = false;
+    propositions = new Map();
+    /**
+     * Create a new HomotopyAdapter
+     *
+     * @param wasmLoader - WASM module loader
+     * @param logger - Optional logger for diagnostics
+     */
+    constructor(wasmLoader, logger = DEFAULT_COHERENCE_LOGGER) {
+        this.wasmLoader = wasmLoader;
+        this.logger = logger;
+    }
+    /**
+     * Initialize the adapter by loading the WASM module
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        this.logger.debug('Initializing HomotopyAdapter');
+        const isAvailable = await this.wasmLoader.isAvailable();
+        if (!isAvailable) {
+            throw new WasmNotLoadedError('WASM module is not available. Cannot initialize HomotopyAdapter.');
+        }
+        const module = await this.wasmLoader.load();
+        // Create wrapper around raw HoTT WASM engine
+        const rawEngine = new module.HoTTEngine();
+        this.engine = createHomotopyEngineWrapper(rawEngine);
+        this.initialized = true;
+        this.logger.info('HomotopyAdapter initialized successfully');
+    }
+    /**
+     * Check if the adapter is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Ensure the adapter is initialized before use
+     */
+    ensureInitialized() {
+        if (!this.initialized || !this.engine) {
+            throw new WasmNotLoadedError('HomotopyAdapter not initialized. Call initialize() first.');
+        }
+    }
+    /**
+     * Add a proposition to verify
+     *
+     * @param id - Unique identifier for the proposition
+     * @param formula - Formal statement in the proof language
+     */
+    addProposition(id, formula) {
+        this.ensureInitialized();
+        const proposition = {
+            id,
+            formula,
+            proven: false,
+        };
+        this.propositions.set(id, proposition);
+        this.engine.add_proposition(id, formula);
+        this.logger.debug('Added proposition', { id, formula });
+    }
+    /**
+     * Attempt to prove a proposition
+     *
+     * @param propositionId - ID of the proposition to prove
+     * @param proof - The proof term/script
+     * @returns True if the proof is valid
+     */
+    addProof(propositionId, proof) {
+        this.ensureInitialized();
+        const proposition = this.propositions.get(propositionId);
+        if (!proposition) {
+            this.logger.warn('Proposition not found', { propositionId });
+            return false;
+        }
+        const isValid = this.engine.add_proof(propositionId, proof);
+        if (isValid) {
+            proposition.proven = true;
+            this.logger.info('Proposition proven', { propositionId });
+        }
+        else {
+            this.logger.warn('Proof rejected', { propositionId });
+        }
+        return isValid;
+    }
+    /**
+     * Verify that two execution paths are equivalent
+     *
+     * In HoTT, paths represent equalities. This checks if two different
+     * execution strategies lead to the same result (up to homotopy).
+     *
+     * @param path1 - First execution path (sequence of operations)
+     * @param path2 - Second execution path
+     * @returns Path equivalence result
+     */
+    verifyPathEquivalence(path1, path2) {
+        this.ensureInitialized();
+        const equivalent = this.engine.verify_path_equivalence(path1, path2);
+        const explanation = this.generateEquivalenceExplanation(path1, path2, equivalent);
+        const result = {
+            equivalent,
+            path1,
+            path2,
+            explanation,
+        };
+        this.logger.debug('Verified path equivalence', {
+            path1Length: path1.length,
+            path2Length: path2.length,
+            equivalent,
+        });
+        return result;
+    }
+    /**
+     * Generate an explanation for path equivalence result
+     */
+    generateEquivalenceExplanation(path1, path2, equivalent) {
+        if (equivalent) {
+            if (path1.length === path2.length) {
+                return (`The execution paths are homotopically equivalent. ` +
+                    `Both paths traverse the same abstract structure and will produce equivalent results.`);
+            }
+            else {
+                const longer = path1.length > path2.length ? 'first' : 'second';
+                return (`The execution paths are equivalent despite different lengths. ` +
+                    `The ${longer} path contains redundant steps that can be contracted ` +
+                    `without changing the result (homotopy contraction).`);
+            }
+        }
+        else {
+            // Find divergence point
+            let divergeIndex = 0;
+            const minLen = Math.min(path1.length, path2.length);
+            while (divergeIndex < minLen && path1[divergeIndex] === path2[divergeIndex]) {
+                divergeIndex++;
+            }
+            if (divergeIndex === 0) {
+                return (`The execution paths diverge immediately. ` +
+                    `Path 1 starts with '${path1[0]}' while Path 2 starts with '${path2[0]}'. ` +
+                    `These lead to fundamentally different computation spaces.`);
+            }
+            return (`The execution paths diverge at step ${divergeIndex + 1}. ` +
+                `After '${path1[divergeIndex - 1]}', Path 1 proceeds to '${path1[divergeIndex]}' ` +
+                `while Path 2 proceeds to '${path2[divergeIndex]}'. ` +
+                `No homotopy exists between these paths.`);
+        }
+    }
+    /**
+     * Get all unproven propositions
+     *
+     * @returns Array of unproven proposition IDs
+     */
+    getUnprovenPropositions() {
+        this.ensureInitialized();
+        return this.engine.get_unproven_propositions();
+    }
+    /**
+     * Get overall verification status
+     *
+     * @returns Verification status summary
+     */
+    getVerificationStatus() {
+        const totalPropositions = this.propositions.size;
+        const provenCount = Array.from(this.propositions.values()).filter(p => p.proven).length;
+        const unprovenIds = this.getUnprovenPropositions();
+        return {
+            totalPropositions,
+            provenCount,
+            unprovenIds,
+            verificationPercentage: totalPropositions > 0 ? (provenCount / totalPropositions) * 100 : 100,
+        };
+    }
+    /**
+     * Get a proposition by ID
+     *
+     * @param id - Proposition ID
+     * @returns The proposition or undefined
+     */
+    getProposition(id) {
+        return this.propositions.get(id);
+    }
+    /**
+     * Clear all propositions and proofs
+     */
+    clear() {
+        this.ensureInitialized();
+        this.propositions.clear();
+        this.engine.clear();
+        this.logger.debug('Cleared homotopy engine');
+    }
+    /**
+     * Dispose of adapter resources
+     */
+    dispose() {
+        if (this.engine) {
+            this.engine.clear();
+            this.engine = null;
+        }
+        this.propositions.clear();
+        this.initialized = false;
+        this.logger.info('HomotopyAdapter disposed');
+    }
+    /**
+     * Get the number of propositions
+     */
+    getPropositionCount() {
+        return this.propositions.size;
+    }
+}
+// ============================================================================
+// Factory Function
+// ============================================================================
+/**
+ * Create and initialize a HomotopyAdapter
+ *
+ * @param wasmLoader - WASM module loader
+ * @param logger - Optional logger
+ * @returns Initialized adapter
+ */
+export async function createHomotopyAdapter(wasmLoader, logger) {
+    const adapter = new HomotopyAdapter(wasmLoader, logger);
+    await adapter.initialize();
+    return adapter;
+}
+//# sourceMappingURL=homotopy-adapter.js.map

package/v3/dist/integrations/coherence/engines/homotopy-adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"homotopy-adapter.js","sourceRoot":"","sources":["../../../../src/integrations/coherence/engines/homotopy-adapter.ts"],"names":[],"mappings":"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"}

package/v3/dist/integrations/coherence/engines/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Agentic QE v3 - Coherence Engine Adapters
+ *
+ * Exports all Prime Radiant engine adapters:
+ * - CohomologyAdapter: Sheaf cohomology for contradiction detection
+ * - SpectralAdapter: Spectral analysis for collapse prediction
+ * - CausalAdapter: Causal inference for spurious correlation detection
+ * - CategoryAdapter: Category theory for type verification
+ * - HomotopyAdapter: Homotopy type theory for formal verification
+ * - WitnessAdapter: Blake3 witness chain for audit trails
+ *
+ * @module integrations/coherence/engines
+ */
+export { CohomologyAdapter, createCohomologyAdapter, type ICohomologyAdapter, } from './cohomology-adapter';
+export { SpectralAdapter, createSpectralAdapter, type ISpectralAdapter, } from './spectral-adapter';
+export { CausalAdapter, createCausalAdapter, type ICausalAdapter, } from './causal-adapter';
+export { CategoryAdapter, createCategoryAdapter, type ICategoryAdapter, } from './category-adapter';
+export { HomotopyAdapter, createHomotopyAdapter, type IHomotopyAdapter, type Proposition, type PathEquivalenceResult, type VerificationStatus, } from './homotopy-adapter';
+export { WitnessAdapter, createWitnessAdapter, type IWitnessAdapter, } from './witness-adapter';
+//# sourceMappingURL=index.d.ts.map

package/v3/dist/integrations/coherence/engines/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/integrations/coherence/engines/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,KAAK,kBAAkB,GACxB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,KAAK,gBAAgB,GACtB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,KAAK,gBAAgB,GACtB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,KAAK,eAAe,GACrB,MAAM,mBAAmB,CAAC"}

package/v3/dist/integrations/coherence/engines/index.js

@@ -0,0 +1,26 @@
+/**
+ * Agentic QE v3 - Coherence Engine Adapters
+ *
+ * Exports all Prime Radiant engine adapters:
+ * - CohomologyAdapter: Sheaf cohomology for contradiction detection
+ * - SpectralAdapter: Spectral analysis for collapse prediction
+ * - CausalAdapter: Causal inference for spurious correlation detection
+ * - CategoryAdapter: Category theory for type verification
+ * - HomotopyAdapter: Homotopy type theory for formal verification
+ * - WitnessAdapter: Blake3 witness chain for audit trails
+ *
+ * @module integrations/coherence/engines
+ */
+// Cohomology Engine (Contradiction Detection)
+export { CohomologyAdapter, createCohomologyAdapter, } from './cohomology-adapter';
+// Spectral Engine (Collapse Prediction)
+export { SpectralAdapter, createSpectralAdapter, } from './spectral-adapter';
+// Causal Engine (Spurious Correlation Detection)
+export { CausalAdapter, createCausalAdapter, } from './causal-adapter';
+// Category Engine (Type Verification)
+export { CategoryAdapter, createCategoryAdapter, } from './category-adapter';
+// Homotopy Engine (Formal Verification)
+export { HomotopyAdapter, createHomotopyAdapter, } from './homotopy-adapter';
+// Witness Engine (Audit Trails)
+export { WitnessAdapter, createWitnessAdapter, } from './witness-adapter';
+//# sourceMappingURL=index.js.map

package/v3/dist/integrations/coherence/engines/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/integrations/coherence/engines/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,8CAA8C;AAC9C,OAAO,EACL,iBAAiB,EACjB,uBAAuB,GAExB,MAAM,sBAAsB,CAAC;AAE9B,wCAAwC;AACxC,OAAO,EACL,eAAe,EACf,qBAAqB,GAEtB,MAAM,oBAAoB,CAAC;AAE5B,iDAAiD;AACjD,OAAO,EACL,aAAa,EACb,mBAAmB,GAEpB,MAAM,kBAAkB,CAAC;AAE1B,sCAAsC;AACtC,OAAO,EACL,eAAe,EACf,qBAAqB,GAEtB,MAAM,oBAAoB,CAAC;AAE5B,wCAAwC;AACxC,OAAO,EACL,eAAe,EACf,qBAAqB,GAKtB,MAAM,oBAAoB,CAAC;AAE5B,gCAAgC;AAChC,OAAO,EACL,cAAc,EACd,oBAAoB,GAErB,MAAM,mBAAmB,CAAC"}