agentic-qe 3.8.8 → 3.8.10

package/dist/domains/quality-assessment/services/quality-analyzer.d.ts

@@ -106,7 +106,6 @@ export declare class QualityAnalyzerService implements IQualityAnalyzerService {
     getQualityTrend(metric: string, days: number): Promise<Result<QualityTrend, Error>>;
     private collectFileMetrics;
     private getStoredCoverage;
-    private hashFilePath;
     private aggregateMetrics;
     private calculateQualityScore;
     private generateTrends;

package/dist/domains/quality-assessment/services/quality-analyzer.js

@@ -381,15 +381,22 @@ Focus on:
                 }
                 if (includeAll || includeMetrics.includes('coverage')) {
                     // Coverage requires external data (from test runners)
-                    // Use stored coverage or estimate from testability
+                    // Only use real stored coverage — never fabricate a number
                     const storedCoverage = await this.getStoredCoverage(file);
-                    metrics.coverage = storedCoverage ?? Math.min(95, metrics.testability || 70);
+                    if (storedCoverage !== null) {
+                        metrics.coverage = storedCoverage;
+                    }
+                    // If no coverage data exists, omit the metric rather than guessing
                 }
             }
             else {
                 // Fallback for files that couldn't be analyzed
                 if (includeAll || includeMetrics.includes('coverage')) {
-                    metrics.coverage = 70;
+                    // Only use real stored coverage — never fabricate a number
+                    const storedCoverage = await this.getStoredCoverage(file);
+                    if (storedCoverage !== null) {
+                        metrics.coverage = storedCoverage;
+                    }
                 }
                 if (includeAll || includeMetrics.includes('complexity')) {
                     metrics.complexity = 10;
@@ -409,19 +416,23 @@ Focus on:
         return fileMetrics;
     }
     async getStoredCoverage(file) {
-        // Try to get coverage from stored test results
-        const key = `quality-analysis:coverage:${this.hashFilePath(file)}`;
-        const coverage = await this.memory.get(key);
-        return coverage ?? null;
-    }
-    hashFilePath(path) {
-        // Simple hash for file path
-        let hash = 0;
-        for (let i = 0; i < path.length; i++) {
-            hash = ((hash << 5) - hash) + path.charCodeAt(i);
-            hash = hash & hash;
-        }
-        return hash.toString(16);
+        try {
+            // 1. Try per-file coverage stored by test executor
+            const fileCoverage = await this.memory.get(`coverage:file:${file}`);
+            if (fileCoverage && typeof fileCoverage.line === 'number') {
+                return fileCoverage.line;
+            }
+            // 2. Fall back to project-wide summary from coverage-analyzer
+            const summary = await this.memory.get('coverage:latest');
+            if (summary && typeof summary.line === 'number') {
+                return summary.line;
+            }
+            // No coverage data available — return null (never fabricate)
+            return null;
+        }
+        catch {
+            return null;
+        }
     }
     aggregateMetrics(fileMetrics) {
         const aggregated = new Map();
@@ -469,9 +480,11 @@ Focus on:
             totalWeight += weight;
         }
         const overall = totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 0;
+        // Use -1 to signal "no data available" rather than 0 which implies "0% coverage"
+        const coverageMetric = metrics.find((m) => m.name === 'coverage');
         return {
             overall,
-            coverage: metrics.find((m) => m.name === 'coverage')?.value || 0,
+            coverage: coverageMetric ? coverageMetric.value : -1,
             complexity: metrics.find((m) => m.name === 'complexity')?.value || 0,
             maintainability: metrics.find((m) => m.name === 'maintainability')?.value || 0,
             security: 85, // Placeholder - would come from security analysis

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

@@ -68,6 +68,15 @@ export interface ITestRunResult {
     duration: number;
     failedTests: IFailedTest[];
     coverage?: ICoverageData;
+    /** Per-file coverage data for granular quality assessment */
+    fileCoverages?: IFileCoverageData[];
+}
+export interface IFileCoverageData {
+    path: string;
+    line: number;
+    branch: number;
+    function: number;
+    statement: number;
 }
 export interface IFailedTest {
     testId: string;
@@ -304,6 +313,8 @@ export type TestRunResult = ITestRunResult;
 export type FailedTest = IFailedTest;
 /** @deprecated Use ICoverageData */
 export type CoverageData = ICoverageData;
+/** @deprecated Use IFileCoverageData */
+export type FileCoverageData = IFileCoverageData;
 /** @deprecated Use IFlakyDetectionRequest */
 export type FlakyDetectionRequest = IFlakyDetectionRequest;
 /** @deprecated Use IFlakyTestReport */

package/dist/domains/test-execution/services/test-executor.d.ts

@@ -144,7 +144,32 @@ export declare class TestExecutorService implements ITestExecutionService {
     private shardTests;
     private executeWorker;
     private aggregateResults;
+    /**
+     * Aggregate coverage from multiple test file results.
+     *
+     * Note: uses unweighted average across entries. When coverage comes from
+     * readCoverageFromDisk() the runner's own weighted total is used directly
+     * (bypassing this method), so the unweighted average only applies when
+     * individual file JSON outputs each report their own summary.
+     */
     private aggregateCoverage;
+    /**
+     * Extract coverage percentages from vitest/jest JSON output.
+     *
+     * Both runners include a `coverageMap` (or `coverageSummary`) object when
+     * --coverage is passed. The shape varies, so we handle the common cases:
+     *   - Jest/vitest v8: json.coverageMap with per-file entries
+     *   - Jest coverageSummary: json.coverageSummary.total with pct fields
+     *
+     * Returns both aggregate and per-file coverage data.
+     */
+    private extractCoverageFromJson;
+    /**
+     * Read coverage from disk files written by vitest/jest.
+     * Both runners write coverage-summary.json to a coverage/ directory when
+     * --coverage is passed, rather than embedding it in stdout JSON.
+     */
+    private readCoverageFromDisk;
     private storeResults;
 }
 /**

package/dist/domains/test-execution/services/test-executor.js

@@ -4,7 +4,8 @@
  */
 import { LoggerFactory } from '../../../logging/index.js';
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../../shared/types';
 import { TEST_EXECUTION_CONSTANTS, LLM_ANALYSIS_CONSTANTS } from '../../constants.js';
@@ -66,6 +67,7 @@ export class TestExecutorService {
                 duration,
                 failedTests: results.failedTests,
                 coverage: results.coverage,
+                fileCoverages: results.fileCoverages,
             };
             // Store results
             this.runResults.set(runId, runResult);
@@ -118,6 +120,7 @@ export class TestExecutorService {
                 duration,
                 failedTests: aggregated.failedTests,
                 coverage: aggregated.coverage,
+                fileCoverages: aggregated.fileCoverages,
             };
             // Store results
             this.runResults.set(runId, runResult);
@@ -295,6 +298,8 @@ Provide:
     async runTests(request) {
         const { testFiles, framework, timeout = 30000 } = request;
         const failedTests = [];
+        const coverages = [];
+        const allFileCoverages = [];
         let passed = 0;
         let failed = 0;
         let skipped = 0;
@@ -304,6 +309,12 @@ Provide:
             failed += result.failed;
             skipped += result.skipped;
             failedTests.push(...result.failedTests);
+            if (result.coverage) {
+                coverages.push(result.coverage);
+            }
+            if (result.fileCoverages) {
+                allFileCoverages.push(...result.fileCoverages);
+            }
         }
         return {
             total: passed + failed + skipped,
@@ -311,7 +322,8 @@ Provide:
             failed,
             skipped,
             failedTests,
-            coverage: this.aggregateCoverage([]),
+            coverage: this.aggregateCoverage(coverages),
+            fileCoverages: allFileCoverages.length > 0 ? allFileCoverages : undefined,
         };
     }
     async executeTestFile(file, framework, timeout) {
@@ -384,6 +396,17 @@ Provide:
                 }
                 // Parse results based on framework
                 const parseResult = this.parseTestOutput(stdout, stderr, file, framework, code);
+                // If no coverage in stdout JSON, try reading from disk
+                // (vitest/jest write coverage to coverage/coverage-summary.json)
+                if (parseResult.success && !parseResult.value.coverage) {
+                    const diskCoverage = this.readCoverageFromDisk();
+                    if (diskCoverage) {
+                        parseResult.value.coverage = diskCoverage.summary;
+                        if (diskCoverage.perFile.length > 0) {
+                            parseResult.value.fileCoverages = diskCoverage.perFile;
+                        }
+                    }
+                }
                 resolve(parseResult);
             });
             proc.on('error', (error) => {
@@ -400,14 +423,18 @@ Provide:
             case 'vitest':
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', file, '--reporter=json', '--no-color'],
+                    args: ['vitest', 'run', file, '--reporter=json', '--no-color',
+                        '--coverage', '--coverage.reporter=json'],
                 };
             case 'jest':
                 return {
                     command: 'npx',
-                    args: ['jest', file, '--json', '--no-colors', '--testLocationInResults'],
+                    args: ['jest', file, '--json', '--no-colors', '--testLocationInResults',
+                        '--coverage', '--coverageReporters=json'],
                 };
             case 'mocha':
+                // Note: mocha has no built-in coverage — requires external nyc/c8 wrapper.
+                // Coverage data will be unavailable for mocha-based test runs.
                 return {
                     command: 'npx',
                     args: ['mocha', file, '--reporter=json'],
@@ -416,7 +443,8 @@ Provide:
                 // Default to vitest
                 return {
                     command: 'npx',
-                    args: ['vitest', 'run', file, '--reporter=json', '--no-color'],
+                    args: ['vitest', 'run', file, '--reporter=json', '--no-color',
+                        '--coverage', '--coverage.reporter=json'],
                 };
         }
     }
@@ -476,13 +504,15 @@ Provide:
                         }
                     }
                 }
+                const covData = this.extractCoverageFromJson(json);
                 return ok({
                     total: passed + failed + skipped,
                     passed,
                     failed,
                     skipped,
                     failedTests,
-                    coverage: undefined,
+                    coverage: covData.summary,
+                    fileCoverages: covData.perFile.length > 0 ? covData.perFile : undefined,
                 });
             }
             catch {
@@ -525,13 +555,15 @@ Provide:
                     }
                 }
             }
+            const covData = this.extractCoverageFromJson(json);
             return ok({
                 total: passed + failed + skipped,
                 passed,
                 failed,
                 skipped,
                 failedTests,
-                coverage: undefined,
+                coverage: covData.summary,
+                fileCoverages: covData.perFile.length > 0 ? covData.perFile : undefined,
             });
         }
         catch {
@@ -564,7 +596,7 @@ Provide:
                 failed,
                 skipped,
                 failedTests,
-                coverage: undefined,
+                coverage: undefined, // mocha has no built-in coverage
             });
         }
         catch {
@@ -687,13 +719,20 @@ Provide:
                 duration: secureRandom() * 1000,
             });
         }
+        const fileCov = {
+            line: Math.round(secureRandom() * 4000 + 6000) / 100, // 60-100%
+            branch: Math.round(secureRandom() * 5000 + 4000) / 100, // 40-90%
+            function: Math.round(secureRandom() * 3000 + 7000) / 100, // 70-100%
+            statement: Math.round(secureRandom() * 4000 + 6000) / 100, // 60-100%
+        };
         return {
             total: testCount,
             passed: testCount - failCount - skipCount,
             failed: failCount,
             skipped: skipCount,
             failedTests,
-            coverage: undefined,
+            coverage: fileCov,
+            fileCoverages: [{ path: file, ...fileCov }],
         };
     }
     shardTests(testFiles, workers, strategy) {
@@ -743,8 +782,21 @@ Provide:
             aggregated.failedTests.push(...result.failedTests);
         }
         aggregated.coverage = this.aggregateCoverage(results.map(r => r.coverage).filter((c) => c !== undefined));
+        // Collect per-file coverages from all worker results
+        const allFileCoverages = results.flatMap(r => r.fileCoverages ?? []);
+        if (allFileCoverages.length > 0) {
+            aggregated.fileCoverages = allFileCoverages;
+        }
         return aggregated;
     }
+    /**
+     * Aggregate coverage from multiple test file results.
+     *
+     * Note: uses unweighted average across entries. When coverage comes from
+     * readCoverageFromDisk() the runner's own weighted total is used directly
+     * (bypassing this method), so the unweighted average only applies when
+     * individual file JSON outputs each report their own summary.
+     */
     aggregateCoverage(coverages) {
         if (coverages.length === 0) {
             return undefined;
@@ -756,17 +808,188 @@ Provide:
             statement: acc.statement + cov.statement,
         }), { line: 0, branch: 0, function: 0, statement: 0 });
         return {
-            line: sum.line / coverages.length,
-            branch: sum.branch / coverages.length,
-            function: sum.function / coverages.length,
-            statement: sum.statement / coverages.length,
+            line: Math.round((sum.line / coverages.length) * 100) / 100,
+            branch: Math.round((sum.branch / coverages.length) * 100) / 100,
+            function: Math.round((sum.function / coverages.length) * 100) / 100,
+            statement: Math.round((sum.statement / coverages.length) * 100) / 100,
         };
     }
+    /**
+     * Extract coverage percentages from vitest/jest JSON output.
+     *
+     * Both runners include a `coverageMap` (or `coverageSummary`) object when
+     * --coverage is passed. The shape varies, so we handle the common cases:
+     *   - Jest/vitest v8: json.coverageMap with per-file entries
+     *   - Jest coverageSummary: json.coverageSummary.total with pct fields
+     *
+     * Returns both aggregate and per-file coverage data.
+     */
+    extractCoverageFromJson(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    json) {
+        const perFile = [];
+        try {
+            // Jest shape: { coverageSummary: { total: { lines: { pct }, branches: { pct }, ... } } }
+            const total = json?.coverageSummary?.total ?? json?.coverageMap?.total;
+            if (total?.lines?.pct !== undefined) {
+                return {
+                    summary: {
+                        line: typeof total.lines?.pct === 'number' ? total.lines.pct : 0,
+                        branch: typeof total.branches?.pct === 'number' ? total.branches.pct : 0,
+                        function: typeof total.functions?.pct === 'number' ? total.functions.pct : 0,
+                        statement: typeof total.statements?.pct === 'number' ? total.statements.pct : 0,
+                    },
+                    perFile,
+                };
+            }
+            // Vitest v8 shape: coverageMap is keyed by file path
+            const coverageMap = json?.coverageMap;
+            if (coverageMap && typeof coverageMap === 'object') {
+                const files = Object.keys(coverageMap).filter(k => k !== 'total');
+                if (files.length > 0) {
+                    let lines = 0, branches = 0, functions = 0, statements = 0;
+                    let count = 0;
+                    for (const filePath of files) {
+                        const entry = coverageMap[filePath];
+                        const s = entry?.s ?? {};
+                        const f = entry?.f ?? {};
+                        const b = entry?.b ?? {};
+                        const stmtTotal = Object.keys(s).length;
+                        const stmtCovered = Object.values(s).filter((v) => v > 0).length;
+                        const fnTotal = Object.keys(f).length;
+                        const fnCovered = Object.values(f).filter((v) => v > 0).length;
+                        const brTotal = Object.keys(b).length;
+                        const brCovered = Object.values(b).filter((v) => Array.isArray(v) ? v.every(c => c > 0) : v > 0).length;
+                        if (stmtTotal > 0) {
+                            const fileLine = Math.round((stmtCovered / stmtTotal) * 10000) / 100;
+                            const fileFn = fnTotal > 0 ? Math.round((fnCovered / fnTotal) * 10000) / 100 : 100;
+                            const fileBr = brTotal > 0 ? Math.round((brCovered / brTotal) * 10000) / 100 : 100;
+                            const fileStmt = fileLine;
+                            perFile.push({ path: filePath, line: fileLine, branch: fileBr, function: fileFn, statement: fileStmt });
+                            statements += fileStmt;
+                            lines += fileLine;
+                            functions += fileFn;
+                            branches += fileBr;
+                            count++;
+                        }
+                    }
+                    if (count > 0) {
+                        return {
+                            summary: {
+                                line: Math.round((lines / count) * 100) / 100,
+                                branch: Math.round((branches / count) * 100) / 100,
+                                function: Math.round((functions / count) * 100) / 100,
+                                statement: Math.round((statements / count) * 100) / 100,
+                            },
+                            perFile,
+                        };
+                    }
+                }
+            }
+        }
+        catch {
+            // Coverage parsing is best-effort — never break test results for it
+        }
+        return { perFile };
+    }
+    /**
+     * Read coverage from disk files written by vitest/jest.
+     * Both runners write coverage-summary.json to a coverage/ directory when
+     * --coverage is passed, rather than embedding it in stdout JSON.
+     */
+    readCoverageFromDisk() {
+        try {
+            // Check common coverage output paths
+            const candidates = [
+                join(process.cwd(), 'coverage', 'coverage-summary.json'),
+                join(process.cwd(), 'coverage', 'coverage-final.json'),
+            ];
+            for (const filePath of candidates) {
+                if (!existsSync(filePath))
+                    continue;
+                const raw = readFileSync(filePath, 'utf-8');
+                const json = safeJsonParse(raw);
+                // coverage-summary.json shape: { total: { lines: { pct }, ... }, "/path": { lines: { pct }, ... } }
+                if (json?.total?.lines?.pct !== undefined) {
+                    const perFile = [];
+                    for (const [key, value] of Object.entries(json)) {
+                        if (key === 'total')
+                            continue;
+                        // Normalize path: strip cwd prefix, reject traversal sequences
+                        const normalizedPath = key.replace(process.cwd() + '/', '').replace(process.cwd() + '\\', '');
+                        if (normalizedPath.includes('..'))
+                            continue;
+                        const entry = value;
+                        if (entry?.lines?.pct !== undefined) {
+                            perFile.push({
+                                path: normalizedPath,
+                                line: entry.lines.pct,
+                                branch: entry.branches?.pct ?? 0,
+                                function: entry.functions?.pct ?? 0,
+                                statement: entry.statements?.pct ?? 0,
+                            });
+                        }
+                    }
+                    return {
+                        summary: {
+                            line: json.total.lines.pct,
+                            branch: json.total.branches?.pct ?? 0,
+                            function: json.total.functions?.pct ?? 0,
+                            statement: json.total.statements?.pct ?? 0,
+                        },
+                        perFile,
+                    };
+                }
+                // coverage-final.json shape: Istanbul raw map — extract from extractCoverageFromJson
+                if (typeof json === 'object' && !json.total) {
+                    const result = this.extractCoverageFromJson({ coverageMap: json });
+                    if (result.summary) {
+                        return { summary: result.summary, perFile: result.perFile };
+                    }
+                }
+            }
+        }
+        catch {
+            // Coverage from disk is best-effort
+        }
+        return undefined;
+    }
     async storeResults(runId, result) {
         await this.memory.set(`test-run:${runId}`, result, {
             namespace: 'test-execution',
             persist: true,
         });
+        // Store coverage data so quality-assess and quality-gate can read it.
+        // Note: coverage:previous rotation is owned by coverage-analyzer (the
+        // canonical coverage service) to avoid double-rotation race conditions.
+        if (result.coverage) {
+            try {
+                // Write project-level summary using the same CoverageSummary shape
+                // as coverage-analyzer to avoid type mismatches
+                await this.memory.set('coverage:latest', {
+                    line: result.coverage.line ?? 0,
+                    branch: result.coverage.branch ?? 0,
+                    function: result.coverage.function ?? 0,
+                    statement: result.coverage.statement ?? 0,
+                    files: result.fileCoverages?.length ?? 0,
+                }, { persist: true });
+                // Store per-file coverage via memory.set() (not storeVector) so that
+                // quality-analyzer's getStoredCoverage() can read it with memory.get()
+                if (result.fileCoverages) {
+                    for (const fc of result.fileCoverages) {
+                        await this.memory.set(`coverage:file:${fc.path}`, {
+                            line: fc.line,
+                            branch: fc.branch,
+                            function: fc.function,
+                            statement: fc.statement,
+                        }, { persist: true });
+                    }
+                }
+            }
+            catch {
+                // Non-critical — don't break test storage if coverage store fails
+            }
+        }
     }
 }
 // ============================================================================

package/dist/governance/proof-envelope-integration.js

@@ -1,4 +1,4 @@
-import { randomUUID } from 'node:crypto';
+import { randomUUID, createHash } from 'node:crypto';
 import { safeJsonParse } from '../shared/safe-json.js';
 /**
  * Proof Envelope Integration for Agentic QE Fleet
@@ -48,17 +48,23 @@ export class ProofEnvelopeIntegration {
      *
      * @param signingKey - Key used for signing envelopes
      */
-    async initialize(signingKey = 'agentic-qe-default-key') {
+    async initialize(signingKey) {
         if (this.initialized)
             return;
         await this.kernel.initialize();
-        this.signingKey = signingKey;
+        // Derive a deterministic per-installation signing key from the project
+        // directory. This is consistent across restarts (so envelopes remain
+        // verifiable) but unique per installation (unlike a global hardcoded key).
+        // For production use, pass an explicit key managed outside the process.
+        this.signingKey = signingKey || createHash('sha256')
+            .update(`aqe-proof-envelope:${process.cwd()}`)
+            .digest('hex');
         // Try loading guidance ProofChain for parallel audit trail
         try {
             const modulePath = '@claude-flow/guidance/proof';
             const mod = await import(/* @vite-ignore */ modulePath);
             if (mod && typeof mod.createProofChain === 'function') {
-                this.guidanceProofChain = mod.createProofChain({ signingKey });
+                this.guidanceProofChain = mod.createProofChain({ signingKey: this.signingKey });
                 console.log('[ProofEnvelopeIntegration] Guidance ProofChain loaded');
             }
         }

package/dist/integrations/coherence/engines/witness-adapter.d.ts

@@ -1,11 +1,11 @@
 /**
  * Agentic QE v3 - Witness Engine Adapter
  *
- * Wraps the Prime Radiant WitnessEngine for Blake3 witness chain operations.
+ * Wraps the Prime Radiant WitnessEngine for SHA-256 witness chain operations.
  * Used for creating tamper-evident audit trails of agent decisions.
  *
- * Blake3 Witness Chains:
- * - Each decision is hashed with Blake3
+ * Witness Chains:
+ * - Each decision is hashed with SHA-256
  * - Hash includes reference to previous witness
  * - Creates immutable audit trail
  * - Enables deterministic replay
@@ -94,8 +94,8 @@ export declare class WitnessAdapter implements IWitnessAdapter {
      */
     private createFallbackEngine;
     /**
-     * Compute a hash for witness creation
-     * Uses a simple hash when crypto is not available
+     * Compute a SHA-256 hash for witness creation.
+     * Chains the previous hash into the computation for tamper-evidence.
      */
     private computeHash;
     /**

package/dist/integrations/coherence/engines/witness-adapter.js

@@ -1,11 +1,11 @@
 /**
  * Agentic QE v3 - Witness Engine Adapter
  *
- * Wraps the Prime Radiant WitnessEngine for Blake3 witness chain operations.
+ * Wraps the Prime Radiant WitnessEngine for SHA-256 witness chain operations.
  * Used for creating tamper-evident audit trails of agent decisions.
  *
- * Blake3 Witness Chains:
- * - Each decision is hashed with Blake3
+ * Witness Chains:
+ * - Each decision is hashed with SHA-256
  * - Hash includes reference to previous witness
  * - Creates immutable audit trail
  * - Enables deterministic replay
@@ -13,7 +13,7 @@
  * @module integrations/coherence/engines/witness-adapter
  */
 import { WasmNotLoadedError, DEFAULT_COHERENCE_LOGGER } from '../types';
-import { secureRandom } from '../../../shared/utils/crypto-random.js';
+import { createHash } from 'crypto';
 // ============================================================================
 // Witness Adapter Implementation
 // ============================================================================
@@ -131,28 +131,16 @@ export class WitnessAdapter {
         };
     }
     /**
-     * Compute a hash for witness creation
-     * Uses a simple hash when crypto is not available
+     * Compute a SHA-256 hash for witness creation.
+     * Chains the previous hash into the computation for tamper-evidence.
      */
     computeHash(data, previousHash) {
-        // Simple hash implementation for environments without crypto
-        // In production, this would use Blake3 or SHA-256
-        let hash = 0;
-        for (let i = 0; i < data.length; i++) {
-            hash = ((hash << 5) - hash + data[i]) | 0;
-        }
+        const hasher = createHash('sha256');
+        hasher.update(data);
         if (previousHash) {
-            for (let i = 0; i < previousHash.length; i++) {
-                hash = ((hash << 5) - hash + previousHash.charCodeAt(i)) | 0;
-            }
+            hasher.update(previousHash, 'utf-8');
         }
-        // Convert to hex string
-        const unsignedHash = hash >>> 0;
-        return unsignedHash.toString(16).padStart(8, '0') +
-            '-' +
-            Date.now().toString(16) +
-            '-' +
-            secureRandom().toString(16).slice(2, 10);
+        return hasher.digest('hex');
     }
     /**
      * Check if the adapter is initialized