moflo 4.9.37 → 4.10.1

package/dist/src/cli/commands/doctor-checks-writers-audit.js

@@ -0,0 +1,170 @@
+/**
+ * Writers Audit runtime doctor check (epic #1054.S5 / #1059).
+ *
+ * Runtime sibling of S1's static lint (`tests/system/moflo-db-writer-audit.test.ts`).
+ * Enumerates running node processes whose command line invokes one of the
+ * known cross-process writers (build-embeddings, migrations) and fails if any
+ * are alive while the daemon owns the lock.
+ *
+ * Why not lsof / handle.exe?
+ *   - `lsof` not installed on every Linux distro and not on Windows.
+ *   - `handle.exe` (Sysinternals) requires manual install.
+ *   - `openfiles.exe` is disabled by default on Windows and requires a reboot to
+ *     enable.
+ *
+ * Command-line signature scan is cross-platform, dependency-free, and matches
+ * the writers we actually care about — S3 ported them all to the daemon-offline
+ * pattern, so any of them being alive concurrently with the daemon is a
+ * regression of S3's wrapper logic.
+ *
+ * @module cli/commands/doctor-checks-writers-audit
+ */
+import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getDaemonLockHolder } from '../services/daemon-lock.js';
+import { errorDetail } from '../shared/utils/error-detail.js';
+const SCAN_TIMEOUT_MS_WIN = 10_000;
+const SCAN_TIMEOUT_MS_POSIX = 5_000;
+const CMDLINE_CAPTURE_LEN = 300;
+/**
+ * Command-line fragments that identify a CROSS-PROCESS moflo.db writer.
+ * These should never run while the daemon owns the lock (S3 wraps every
+ * invocation in an explicit daemon-stop). Indexer scripts (index-guidance,
+ * index-tests, etc.) are daemon-spawned children — they appear in
+ * `background-pids.json` and are filtered out below.
+ */
+const FOREIGN_WRITER_PATTERNS = [
+    /build-embeddings\.mjs/i,
+    /bin[\\\/]migrations[\\\/][^\s"']+\.mjs/i,
+    /lib[\\\/]db-repair\.mjs/i,
+];
+function readTrackedBackgroundPids(cwd) {
+    const result = new Set();
+    const registryFile = join(cwd, '.moflo', 'background-pids.json');
+    try {
+        if (!existsSync(registryFile))
+            return result;
+        const entries = JSON.parse(readFileSync(registryFile, 'utf-8'));
+        if (!Array.isArray(entries))
+            return result;
+        for (const entry of entries) {
+            if (entry && typeof entry.pid === 'number' && entry.pid > 0) {
+                result.add(entry.pid);
+            }
+        }
+    }
+    catch { /* unreadable — treat as empty */ }
+    return result;
+}
+function enumerateNodeProcesses() {
+    try {
+        if (process.platform === 'win32') {
+            const csv = execSync('powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"Name=\'node.exe\'\\" | Select-Object ProcessId,CommandLine | ConvertTo-Csv -NoTypeInformation"', { encoding: 'utf-8', timeout: SCAN_TIMEOUT_MS_WIN, windowsHide: true });
+            const out = [];
+            for (const line of csv.split(/\r?\n/)) {
+                const m = line.match(/^"(\d+)","?(.*?)"?$/);
+                if (!m)
+                    continue;
+                const pid = parseInt(m[1], 10);
+                if (!Number.isFinite(pid) || pid <= 0)
+                    continue;
+                out.push({ pid, cmdline: m[2].replace(/""/g, '"').slice(0, CMDLINE_CAPTURE_LEN) });
+            }
+            return out;
+        }
+        // POSIX
+        const ps = execSync('ps -ww -eo pid,command', { encoding: 'utf-8', timeout: SCAN_TIMEOUT_MS_POSIX });
+        const out = [];
+        for (const line of ps.split(/\r?\n/)) {
+            const m = line.trim().match(/^(\d+)\s+(.*)$/);
+            if (!m)
+                continue;
+            const cmd = m[2];
+            if (!/\bnode\b/.test(cmd))
+                continue;
+            const pid = parseInt(m[1], 10);
+            if (!Number.isFinite(pid) || pid <= 0)
+                continue;
+            out.push({ pid, cmdline: cmd.slice(0, CMDLINE_CAPTURE_LEN) });
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+function formatCmdline(raw, max = 80) {
+    const cleaned = raw.replace(/^"?[^"\s]*node(?:\.exe)?"?\s+/i, '').trim();
+    return cleaned.length > max ? cleaned.slice(0, max - 1) + '…' : cleaned;
+}
+export function findForeignWriters(procs, daemonPid, trackedPids, selfPid) {
+    const out = [];
+    for (const p of procs) {
+        if (p.pid === selfPid)
+            continue;
+        if (p.pid === daemonPid)
+            continue;
+        if (trackedPids.has(p.pid))
+            continue;
+        for (const re of FOREIGN_WRITER_PATTERNS) {
+            const m = p.cmdline.match(re);
+            if (m) {
+                out.push({ ...p, matchedPattern: m[0] });
+                break;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Pass: daemon down (single-writer invariant has nothing to enforce) OR no
+ * foreign writers detected.
+ *
+ * Fail: daemon owns the lock AND a non-daemon, non-tracked node process is
+ * running a known cross-process writer. Lists every offender so the user can
+ * SIGKILL them by PID.
+ */
+export async function checkWritersAudit(cwd = process.cwd()) {
+    const name = 'Writers Audit';
+    try {
+        const daemonPid = getDaemonLockHolder(cwd);
+        if (daemonPid === null) {
+            return {
+                name,
+                status: 'pass',
+                message: 'Daemon not running — single-writer invariant trivially satisfied',
+            };
+        }
+        const procs = enumerateNodeProcesses();
+        const trackedPids = readTrackedBackgroundPids(cwd);
+        const foreign = findForeignWriters(procs, daemonPid, trackedPids, process.pid);
+        if (foreign.length === 0) {
+            return {
+                name,
+                status: 'pass',
+                message: `Daemon PID ${daemonPid} is sole writer; no foreign writers detected`,
+            };
+        }
+        const detail = foreign
+            .map((p) => `pid=${p.pid} (${p.matchedPattern}): ${formatCmdline(p.cmdline)}`)
+            .join(' | ');
+        return {
+            name,
+            status: 'fail',
+            message: `${foreign.length} non-daemon writer(s) running concurrently with daemon (PID ${daemonPid}): ${detail}. ` +
+                `Each will clobber the daemon's sql.js snapshot on flush — #1054 bug class.`,
+            fix: process.platform === 'win32'
+                ? `taskkill /F /PID ${foreign.map((p) => p.pid).join(' /PID ')}`
+                : `kill ${foreign.map((p) => p.pid).join(' ')}`,
+        };
+    }
+    catch (e) {
+        return {
+            name,
+            status: 'warn',
+            message: `Unable to audit writers: ${errorDetail(e, { firstLineOnly: true })}`,
+        };
+    }
+}
+//# sourceMappingURL=doctor-checks-writers-audit.js.map

package/dist/src/cli/commands/doctor-embedding-hygiene.js

@@ -24,8 +24,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { existsSync } from 'fs';
 import { CANONICAL_EMBEDDING_MODEL } from '../embeddings/migration/types.js';
-import { mofloImport } from '../services/moflo-require.js';
 import { memoryDbCandidatePaths } from '../services/moflo-paths.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 /**
  * Known neural-model labels that all share the all-MiniLM-L6-v2 384-dim
  * vector space. The Story-2 migration retags any of these to the
@@ -59,7 +59,7 @@ export async function checkEmbeddingHygiene() {
         return {
             name: 'Embedding hygiene',
             status: 'pass',
-            message: 'Cannot inspect memory DB (sql.js not available)',
+            message: 'Cannot inspect memory DB (open failed)',
         };
     }
     if (groups.length === 0) {
@@ -127,21 +127,9 @@ function resolveMemoryDb() {
     return memoryDbCandidatePaths(process.cwd()).find((p) => existsSync(p)) ?? null;
 }
 async function loadModelGroups(dbPath) {
-    const fs = await import('fs');
-    let initSqlJs;
-    try {
-        initSqlJs = (await mofloImport('sql.js'))?.default;
-    }
-    catch {
-        return null;
-    }
-    if (!initSqlJs)
-        return null;
     let db;
     try {
-        const SQL = await initSqlJs();
-        const buffer = fs.readFileSync(dbPath);
-        db = new SQL.Database(buffer);
+        db = openDaemonDatabase(dbPath);
     }
     catch {
         return null;

package/dist/src/cli/commands/doctor-fixes.js

@@ -169,6 +169,36 @@ export async function autoFixCheck(check) {
             catch { /* best effort */ }
             return runFixCommand('npx moflo daemon start');
         },
+        // Epic #1054.S5 / #1059 — SIGTERM the stale daemon and let the launcher's
+        // existing respawn path (mirrored as `npx moflo daemon start`) pick up the
+        // installed-version code. Mirrors `recycleDaemon` in
+        // bin/session-start-launcher.mjs so the auto-fix matches the launcher's
+        // behavior exactly.
+        'Daemon Version Skew': async () => {
+            const cwd = process.cwd();
+            const { getDaemonLockPayload } = await import('../services/daemon-lock.js');
+            const payload = getDaemonLockPayload(cwd);
+            if (payload?.pid && payload.pid > 0) {
+                try {
+                    process.kill(payload.pid, 'SIGTERM');
+                }
+                catch { /* already dead */ }
+            }
+            const lockFile = join(cwd, '.moflo', 'daemon.lock');
+            try {
+                if (existsSync(lockFile))
+                    unlinkSync(lockFile);
+            }
+            catch { /* ok */ }
+            return runFixCommand('npx moflo daemon start');
+        },
+        'Embedding Coverage Truth': async () => {
+            // Same as the existing Embeddings fix — rebuild the cache by re-running
+            // the embeddings pipeline. Routes through `npx moflo` so the consumer
+            // CLI resolution stays consistent across platforms (see
+            // feedback_cross_platform_mandatory).
+            return runFixCommand('npx moflo embeddings init --force');
+        },
         'MCP Servers': async () => {
             return runFixCommand('claude mcp add moflo -- npx -y moflo mcp start');
         },
@@ -213,6 +243,63 @@ export async function autoFixCheck(check) {
                 return false;
             }
         },
+        // Tiered recovery for `.moflo/moflo.db` corruption (REINDEX → VACUUM
+        // INTO → row-level salvage). The TS service stops the daemon
+        // automatically (cross-platform via `process.kill('SIGTERM')`) so the
+        // atomic swap doesn't race a live writer; we restart it via the
+        // existing `npx moflo daemon start` shorthand after. The MCP server,
+        // started by Claude Code outside our process tree, isn't stopped here —
+        // explicit user guidance covers that case at the end.
+        'Memory DB Integrity': async () => {
+            try {
+                const { repairMemoryDbIntegrity } = await import('../services/memory-db-integrity-repair.js');
+                const result = await repairMemoryDbIntegrity(process.cwd());
+                if (result.repaired) {
+                    const tierLabel = result.tier === 'reindex' ? 'REINDEX (index rebuild)'
+                        : result.tier === 'vacuum' ? 'VACUUM INTO (fresh-file rebuild)'
+                            : result.tier === 'salvage' ? 'row-level salvage'
+                                : 'repaired';
+                    output.writeln(output.dim(`  Recovered via ${tierLabel}.`));
+                    if (result.corruptBackup) {
+                        output.writeln(output.dim(`  Pre-repair backup retained: ${result.corruptBackup}`));
+                    }
+                    if (result.lossStats) {
+                        for (const [tbl, s] of Object.entries(result.lossStats)) {
+                            if (s.read > 0) {
+                                const lost = Math.max(0, s.read - s.written);
+                                if (lost > 0) {
+                                    output.writeln(output.warning(`  ${tbl}: ${s.written}/${s.read} rows preserved (lost ${lost} across ${s.errors} unreadable chunk(s))`));
+                                }
+                            }
+                        }
+                        output.writeln(output.dim('  Embeddings for lost rows will be regenerated on next index pass — run `npx moflo embeddings init` to force.'));
+                    }
+                    // Restart the daemon if we stopped it. The launcher's own
+                    // section-4 spawn handles this on next session-start, but a
+                    // mid-session healer call shouldn't leave the daemon down.
+                    if (result.daemonStopped) {
+                        output.writeln(output.dim('  Restarting daemon...'));
+                        await runFixCommand('npx moflo daemon start');
+                    }
+                    // Cross-platform note for the MCP server (out-of-tree, can't
+                    // SIGTERM). On Windows the swap would have failed if MCP was
+                    // holding the file; on POSIX the swap succeeds but MCP keeps
+                    // reading the stale inode until restart. Either way: restart
+                    // Claude Code to fully apply.
+                    output.writeln(output.dim('  Restart Claude Code so the MCP server re-opens the recovered DB.'));
+                    return true;
+                }
+                if (result.persistent) {
+                    output.writeln(output.warning('  Corruption survived every recovery tier. Manual options: ' +
+                        '`npx moflo memory rebuild-index` (destructive) or restore from a known-good backup.'));
+                }
+                return false;
+            }
+            catch (e) {
+                output.writeln(output.warning(`  Repair failed: ${errorDetail(e)}`));
+                return false;
+            }
+        },
         'Status Line': async () => {
             const settingsPath = join(process.cwd(), '.claude', 'settings.json');
             if (!existsSync(settingsPath))

package/dist/src/cli/commands/doctor-registry.js

@@ -6,10 +6,13 @@
  */
 import { checkSubagentHealth, checkSpellExecution, checkMcpToolInvocation, checkHookExecution, checkMcpSpellIntegration, checkGateHealth, checkHookBlockDrift, checkMofloDbBridge, } from './doctor-checks-deep.js';
 import { checkEmbeddingHygiene } from './doctor-embedding-hygiene.js';
+import { checkDaemonVersionSkew } from './doctor-checks-version-skew.js';
+import { checkEmbeddingCoverageTruth } from './doctor-checks-coverage-truth.js';
+import { checkWritersAudit } from './doctor-checks-writers-audit.js';
 import { checkSwarmFunctional, checkHiveMindFunctional, } from './doctor-checks-swarm.js';
 import { checkMemoryAccessFunctional } from './doctor-checks-memory-access.js';
 import { checkBuildTools, checkClaudeCode, checkDiskSpace, checkGit, checkGitRepo, checkNodeVersion, checkNpmVersion, } from './doctor-checks-runtime.js';
-import { checkConfigFile, checkDaemonStatus, checkDaemonWriteRouting, checkMcpServers, checkMemoryDatabase, checkMofloYamlCompliance, checkStatusLine, checkTestDirs, } from './doctor-checks-config.js';
+import { checkConfigFile, checkDaemonStatus, checkDaemonWriteRouting, checkMcpServers, checkMemoryDatabase, checkMemoryDbIntegrity, checkMofloYamlCompliance, checkStatusLine, checkTestDirs, } from './doctor-checks-config.js';
 import { checkSpellEngine, checkSandboxTier } from './doctor-checks-platform.js';
 import { checkEmbeddings, checkSemanticQuality, } from './doctor-checks-memory.js';
 import { checkIntelligence } from './doctor-checks-intelligence.js';
@@ -33,10 +36,19 @@ export const allChecks = [
     checkMofloYamlCompliance,
     checkStatusLine,
     checkDaemonStatus,
+    checkDaemonVersionSkew,
     checkDaemonWriteRouting,
+    checkWritersAudit,
     checkMemoryDatabase,
+    // Owns the corruption signal so downstream checks (Embeddings, Semantic
+    // Quality, Memory Access Functional) don't surface it as the synthetic
+    // "Check" failure (doctor.ts:214). MUST run after checkMemoryDatabase
+    // (which confirms the file exists) and before any check that opens the
+    // DB via openBackend.
+    checkMemoryDbIntegrity,
     checkEmbeddings,
     checkEmbeddingHygiene,
+    checkEmbeddingCoverageTruth,
     checkTestDirs,
     checkMcpServers,
     checkDiskSpace,
@@ -77,11 +89,22 @@ export const componentMap = {
     'statusline': checkStatusLine,
     'status-line': checkStatusLine,
     'daemon': checkDaemonStatus,
+    'daemon-version-skew': checkDaemonVersionSkew,
+    'version-skew': checkDaemonVersionSkew,
+    'skew': checkDaemonVersionSkew,
     'daemon-write-routing': checkDaemonWriteRouting,
     'write-routing': checkDaemonWriteRouting,
+    'writers-audit': checkWritersAudit,
+    'writers': checkWritersAudit,
     'memory': checkMemoryDatabase,
+    'memory-db-integrity': checkMemoryDbIntegrity,
+    'integrity': checkMemoryDbIntegrity,
+    'memory-integrity': checkMemoryDbIntegrity,
     'embeddings': checkEmbeddings,
     'embedding-hygiene': checkEmbeddingHygiene,
+    'embedding-coverage': checkEmbeddingCoverageTruth,
+    'coverage': checkEmbeddingCoverageTruth,
+    'coverage-truth': checkEmbeddingCoverageTruth,
     'hygiene': checkEmbeddingHygiene,
     'git': checkGit,
     'mcp': checkMcpServers,

package/dist/src/cli/commands/doctor.js

@@ -40,7 +40,7 @@ export const doctorCommand = {
         {
             name: 'component',
             short: 'c',
-            description: 'Check specific component (version, node, npm, config, daemon, memory, embeddings, git, mcp, claude, disk, typescript, semantic, intelligence, swarm, hive-mind)',
+            description: 'Check specific component (version, version-skew, node, npm, config, daemon, writers-audit, memory, embeddings, coverage-truth, git, mcp, claude, disk, typescript, semantic, intelligence, swarm, hive-mind)',
             type: 'string',
         },
         {

package/dist/src/cli/commands/embeddings.js

@@ -13,10 +13,10 @@
  * Created with ❤️ by motailz.com
  */
 import { output } from '../output.js';
-import { mofloImport } from '../services/moflo-require.js';
 import { runEmbeddingsMigrationIfNeeded } from '../services/embeddings-migration.js';
 import { memoryDbPath, MEMORY_DB_FILE, MOFLO_DIR } from '../services/moflo-paths.js';
 import * as embeddings from '../embeddings/index.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 const DEFAULT_DB_PATH_FLAG = `${MOFLO_DIR}/${MEMORY_DB_FILE}`;
 // Generate subcommand - REAL implementation
@@ -90,7 +90,7 @@ const generateCommand = {
         }
     },
 };
-// Search subcommand - REAL implementation using sql.js
+// Search subcommand - REAL implementation using node:sqlite via openDaemonDatabase
 const searchCommand = {
     name: 'search',
     description: 'Semantic similarity search',
@@ -131,11 +131,8 @@ const searchCommand = {
                 output.printInfo('Run: claude-flow memory init');
                 return { success: false, exitCode: 1 };
             }
-            // Load sql.js
-            const initSqlJs = (await mofloImport('sql.js')).default;
-            const SQL = await initSqlJs();
-            const fileBuffer = fs.readFileSync(fullDbPath);
-            const db = new SQL.Database(fileBuffer);
+            // node:sqlite via the unified factory (Phase 5 / #1084).
+            const db = openDaemonDatabase(fullDbPath);
             const startTime = Date.now();
             // Generate embedding for query
             const { generateEmbedding } = await import('../memory/memory-initializer.js');
@@ -343,7 +340,7 @@ const compareCommand = {
         }
     },
 };
-// Collections subcommand - REAL implementation using sql.js
+// Collections subcommand - REAL implementation using node:sqlite via openDaemonDatabase
 const collectionsCommand = {
     name: 'collections',
     description: 'Manage embedding collections (namespaces)',
@@ -374,11 +371,8 @@ const collectionsCommand = {
                 output.writeln(output.dim('No collections yet - initialize memory first'));
                 return { success: true, data: [] };
             }
-            // Load sql.js and query real data
-            const initSqlJs = (await mofloImport('sql.js')).default;
-            const SQL = await initSqlJs();
-            const fileBuffer = fs.readFileSync(fullDbPath);
-            const db = new SQL.Database(fileBuffer);
+            // node:sqlite via the unified factory (Phase 5 / #1084).
+            const db = openDaemonDatabase(fullDbPath);
             // Get collection stats from database
             const statsQuery = db.exec(`
         SELECT
@@ -1159,17 +1153,18 @@ const cacheCommand = {
                 else {
                     sqliteSize = `${sizeBytes} B`;
                 }
-                // Try to count real entries via sql.js
+                // Try to count real entries via node:sqlite
                 try {
-                    const initSqlJs = (await mofloImport('sql.js')).default;
-                    const SQL = await initSqlJs();
-                    const fileBuffer = fs.readFileSync(resolvedDbPath);
-                    const db = new SQL.Database(fileBuffer);
-                    const result = db.exec('SELECT COUNT(*) as count FROM embeddings');
-                    if (result.length > 0 && result[0].values.length > 0) {
-                        sqliteEntries = result[0].values[0][0];
+                    const db = openDaemonDatabase(resolvedDbPath);
+                    try {
+                        const result = db.exec('SELECT COUNT(*) as count FROM embeddings');
+                        if (result.length > 0 && result[0].values.length > 0) {
+                            sqliteEntries = result[0].values[0][0];
+                        }
+                    }
+                    finally {
+                        db.close();
                     }
-                    db.close();
                 }
                 catch {
                     // Estimate entries from file size (~1600 bytes per entry for 384-dim embeddings)

package/dist/src/cli/commands/memory.js

@@ -7,8 +7,7 @@ import * as pathModule from 'path';
 import { output } from '../output.js';
 import { select, confirm, input } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { mofloImport } from '../services/moflo-require.js';
-import { atomicWriteFileSync } from '../services/atomic-file-write.js';
+import { openDaemonDatabase } from '../memory/daemon-backend.js';
 import { errorDetail } from '../shared/utils/error-detail.js';
 // Memory backends
 const BACKENDS = [
@@ -1265,23 +1264,10 @@ const initMemoryCommand = {
 const DB_FILENAME = 'memory.db';
 const SWARM_DIR = '.swarm';
 async function openDb(cwd) {
-    const fs = await import('fs');
     const path = await import('path');
-    const initSqlJs = (await mofloImport('sql.js')).default;
-    const SQL = await initSqlJs();
     const dbPath = path.join(cwd, SWARM_DIR, DB_FILENAME);
-    const dir = path.dirname(dbPath);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    let db;
-    if (fs.existsSync(dbPath)) {
-        const buffer = fs.readFileSync(dbPath);
-        db = new SQL.Database(buffer);
-    }
-    else {
-        db = new SQL.Database();
-    }
+    // openDaemonDatabase ensures the parent directory exists and applies WAL.
+    const db = openDaemonDatabase(dbPath);
     // Ensure table exists
     db.run(`
     CREATE TABLE IF NOT EXISTS memory_entries (
@@ -1307,10 +1293,14 @@ async function openDb(cwd) {
   `);
     db.run(`CREATE INDEX IF NOT EXISTS idx_memory_key_ns ON memory_entries(key, namespace)`);
     db.run(`CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace)`);
-    return { db, dbPath, SQL };
+    return { db, dbPath };
 }
-function saveAndCloseDb(db, dbPath) {
-    atomicWriteFileSync(dbPath, db.export());
+/**
+ * Close the DB handle. node:sqlite + WAL has already persisted every prior
+ * `db.run` incrementally — the explicit atomicWriteFileSync sql.js used to
+ * need is gone (Phase 5 / #1084).
+ */
+function saveAndCloseDb(db, _dbPath) {
     db.close();
 }
 function batchGenerateId() {
@@ -1937,9 +1927,9 @@ const rebuildIndexCommand = {
                 }
                 failed++;
             }
-            if ((i + 1) % BATCH_SIZE === 0) {
-                atomicWriteFileSync(dbPath, db.export());
-            }
+            // node:sqlite + WAL persists each db.run incrementally — the
+            // periodic batch flush sql.js needed here was the export-+-rewrite
+            // pattern Phase 5 (#1084) killed. No flush needed.
         }
         const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
         // Final stats