Persistent project knowledge graph for coding agents. MCP server with semantic search, in-process embeddings, and web explorer.
TypeScript agentic-codingaiai-agentsclaude-codecode-contextcoding-agentembeddingsknowledge-graphllmmcpmcp-serveropencodepersistent-memorysqlitetypescript
chore: add stress test scripts and sync lockfile version
0xk3vin8c819619cf3f
diff --git a/package-lock.json b/package-lock.jsonindex d2bf674..6da5c7b 100644--- a/package-lock.json+++ b/package-lock.json@@ -1,12 +1,12 @@{"name": "megamemory",- "version": "1.6.0",+ "version": "1.6.1","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "megamemory",- "version": "1.6.0",+ "version": "1.6.1","license": "MIT","dependencies": {"@modelcontextprotocol/sdk": "^1.12.1",diff --git a/scripts/stress-test-busy.js b/scripts/stress-test-busy.jsnew file mode 100644index 0000000..0343122--- /dev/null+++ b/scripts/stress-test-busy.js@@ -0,0 +1,209 @@+#!/usr/bin/env node++/**+ * Focused stress test to trigger SQLITE_BUSY+ * Uses long-running transactions to hold write locks beyond busy_timeout+ */++import { fork } from "node:child_process";+import { mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";+import path from "node:path";+import { fileURLToPath } from "node:url";+import Database from "libsql";++const __dirname = path.dirname(fileURLToPath(import.meta.url));+const PROJECT_ROOT = path.resolve(__dirname, "..");++const NUM_WORKERS = 10;+const ITERATIONS_PER_WORKER = 50;+const TEST_DIR = `/tmp/megamemory-busy-test-${Date.now()}`;+const DB_PATH = path.join(TEST_DIR, "knowledge.db");++async function main() {+ console.log("=".repeat(70));+ console.log(" SQLITE_BUSY TRIGGER TEST");+ console.log("=".repeat(70));+ console.log(`Workers: ${NUM_WORKERS}, Iterations: ${ITERATIONS_PER_WORKER}`);+ console.log(`DB: ${DB_PATH}`);+ console.log();++ mkdirSync(TEST_DIR, { recursive: true });++ const { KnowledgeDB } = await import(path.join(PROJECT_ROOT, "dist", "db.js"));+ const initDb = new KnowledgeDB(DB_PATH);+ for (let i = 0; i < 50; i++) {+ initDb.insertNode({+ id: `seed-${i}`,+ name: `Seed ${i}`,+ kind: "feature",+ summary: `Seed node ${i}`,+ });+ }+ for (let i = 0; i < 49; i++) {+ initDb.insertEdge({ from_id: `seed-${i}`, to_id: `seed-${i+1}`, relation: "depends_on" });+ }+ initDb.close();++ const barrierPath = path.join(TEST_DIR, "barrier");++ const workerPromises = [];+ for (let w = 0; w < NUM_WORKERS; w++) {+ workerPromises.push(new Promise((resolve) => {+ const child = fork(+ fileURLToPath(import.meta.url),+ ["--worker", String(w), DB_PATH, String(ITERATIONS_PER_WORKER), barrierPath],+ { cwd: PROJECT_ROOT, stdio: ["pipe", "pipe", "pipe", "ipc"] }+ );+ let result = null;+ child.on("message", (msg) => { result = msg; });+ child.on("exit", () => {+ resolve(result || { workerId: w, busyErrors: 0, otherErrors: 1, txnErrors: 0, ops: 0, errorDetails: [] });+ });+ }));+ }++ await new Promise(r => setTimeout(r, 600));+ writeFileSync(barrierPath, "GO");+ console.log("Barrier released!");++ const results = await Promise.all(workerPromises);++ let totalBusy = 0, totalOther = 0, totalTxn = 0, totalOps = 0;+ const allErrors = [];+ for (const r of results) {+ console.log(` W${r.workerId}: ${r.ops} ops, ${r.busyErrors} BUSY, ${r.txnErrors} txn-errors, ${r.otherErrors} other`);+ totalBusy += r.busyErrors;+ totalOther += r.otherErrors;+ totalTxn += r.txnErrors || 0;+ totalOps += r.ops;+ allErrors.push(...(r.errorDetails || []));+ }++ console.log();+ console.log(`Total: ${totalOps} ops, ${totalBusy} BUSY, ${totalTxn} txn-errors, ${totalOther} other`);++ if (allErrors.length > 0) {+ const grouped = {};+ for (const e of allErrors) {+ const key = e.message.slice(0, 80);+ grouped[key] = (grouped[key] || 0) + 1;+ }+ console.log("\nError breakdown:");+ for (const [msg, count] of Object.entries(grouped).sort((a,b) => b[1] - a[1])) {+ console.log(` [${count}x] ${msg}`);+ }+ }++ rmSync(TEST_DIR, { recursive: true, force: true });+}++async function workerMain() {+ const workerId = parseInt(process.argv[3]);+ const dbPath = process.argv[4];+ const iterations = parseInt(process.argv[5]);+ const barrierPath = process.argv[6];++ const { KnowledgeDB } = await import(path.join(PROJECT_ROOT, "dist", "db.js"));+ const db = new KnowledgeDB(dbPath);++ while (!existsSync(barrierPath)) {+ await new Promise(r => setTimeout(r, 5));+ }++ const stats = {+ workerId,+ ops: 0,+ busyErrors: 0,+ otherErrors: 0,+ txnErrors: 0,+ errorDetails: [],+ };++ const KINDS = ["feature", "module", "pattern", "config"];+ const RELATIONS = ["connects_to", "depends_on", "implements"];++ function trackError(op, err) {+ const msg = err.message || String(err);+ if (msg.includes("SQLITE_BUSY") || msg.includes("database is locked")) {+ stats.busyErrors++;+ } else if (msg.includes("cannot start a transaction within a transaction")) {+ stats.txnErrors++;+ } else {+ stats.otherErrors++;+ }+ stats.errorDetails.push({ worker: workerId, op, message: msg.slice(0, 200) });+ }++ for (let i = 0; i < iterations; i++) {+ const roll = Math.random();++ if (roll < 0.40) {+ // Heavy transactional operation — insertNodeAndEdges holds BEGIN IMMEDIATE+ // Each one creates node + 3-5 edges all in one transaction+ try {+ const nodeId = `w${workerId}-${i}-${Math.random().toString(36).slice(2,6)}`;+ const edges = [];+ for (let e = 0; e < 3 + Math.floor(Math.random() * 3); e++) {+ edges.push({+ to_id: `seed-${Math.floor(Math.random() * 50)}`,+ relation: RELATIONS[Math.floor(Math.random() * RELATIONS.length)],+ description: null,+ });+ }+ db.insertNodeAndEdges(+ { id: nodeId, name: `N${nodeId}`, kind: KINDS[i % 4], summary: `tx node`, why: null, file_refs: null, parent_id: null, created_by_task: null, embedding: null },+ edges+ );+ stats.ops++;+ } catch (err) {+ trackError("insertNodeAndEdges", err);+ stats.ops++;+ }+ } else if (roll < 0.65) {+ // softDeleteNode — non-atomic multi-statement+ try {+ db.softDeleteNode(`seed-${Math.floor(Math.random() * 50)}`, `w${workerId} delete`);+ stats.ops++;+ } catch (err) {+ trackError("softDeleteNode", err);+ stats.ops++;+ }+ } else if (roll < 0.80) {+ // Timeline write+ try {+ db.insertTimelineEntry({+ tool: "stress",+ params: JSON.stringify({w: workerId}),+ result_summary: "x".repeat(200),+ is_write: true,+ is_error: false,+ affected_ids: Array.from({length: 5}, (_, j) => `seed-${j}`),+ });+ stats.ops++;+ } catch (err) {+ trackError("timeline", err);+ stats.ops++;+ }+ } else {+ // Read — getStats (multi-statement read)+ try {+ db.getStats();+ db.getAllActiveNodes();+ stats.ops++;+ } catch (err) {+ trackError("read", err);+ stats.ops++;+ }+ }+ }++ try { db.close(); } catch (_) {}+ process.send(stats);+ process.exit(0);+}++if (process.argv.includes("--worker")) {+ workerMain().catch(err => { console.error(err); process.exit(1); });+} else {+ main().catch(err => { console.error(err); process.exit(1); });+}diff --git a/scripts/stress-test.js b/scripts/stress-test.jsnew file mode 100644index 0000000..c8034cd--- /dev/null+++ b/scripts/stress-test.js@@ -0,0 +1,593 @@+#!/usr/bin/env node++/**+ * Stress test for megamemory SQLite concurrency issues (GitHub #8)+ *+ * Spawns multiple child processes that all hammer the same database file+ * with concurrent reads and writes to reproduce:+ * 1. SQLITE_BUSY errors (1000ms busy_timeout too short)+ * 2. Inconsistent state from non-atomic softDeleteNode / hardDeleteNode+ * 3. PRAGMA integrity_check failures+ * 4. Orphaned edges pointing to deleted/soft-deleted nodes+ */++import { fork } from "node:child_process";+import { mkdirSync, rmSync } from "node:fs";+import path from "node:path";+import { fileURLToPath } from "node:url";+import Database from "libsql";++const __dirname = path.dirname(fileURLToPath(import.meta.url));+const PROJECT_ROOT = path.resolve(__dirname, "..");++// ============ Configuration ============+const NUM_WORKERS = 8;+const ITERATIONS_PER_WORKER = 200;+const TEST_DIR = `/tmp/megamemory-stress-test-${Date.now()}`;+const DB_PATH = path.join(TEST_DIR, "knowledge.db");++// ============ Main orchestrator ============++async function main() {+ console.log("=".repeat(70));+ console.log(" MEGAMEMORY CONCURRENCY STRESS TEST");+ console.log("=".repeat(70));+ console.log(`Workers: ${NUM_WORKERS}`);+ console.log(`Iterations: ${ITERATIONS_PER_WORKER} per worker`);+ console.log(`Database: ${DB_PATH}`);+ console.log(`Test dir: ${TEST_DIR}`);+ console.log();++ // Create test directory and initialize the database schema+ mkdirSync(TEST_DIR, { recursive: true });++ const { KnowledgeDB } = await import(path.join(PROJECT_ROOT, "dist", "db.js"));+ const initDb = new KnowledgeDB(DB_PATH);++ // Seed nodes so workers all contend on the same targets+ const SEED_COUNT = 30;+ for (let i = 0; i < SEED_COUNT; i++) {+ initDb.insertNode({+ id: `seed-${i}`,+ name: `Seed Node ${i}`,+ kind: "feature",+ summary: `Seed node #${i} for stress testing`,+ });+ }+ // Seed edges forming a chain + cross-links+ for (let i = 0; i < SEED_COUNT - 1; i++) {+ initDb.insertEdge({+ from_id: `seed-${i}`,+ to_id: `seed-${i + 1}`,+ relation: "depends_on",+ description: "seed chain edge",+ });+ }+ for (let i = 0; i < 15; i++) {+ const a = Math.floor(Math.random() * SEED_COUNT);+ let b = Math.floor(Math.random() * SEED_COUNT);+ if (b === a) b = (a + 1) % SEED_COUNT;+ try {+ initDb.insertEdge({+ from_id: `seed-${a}`,+ to_id: `seed-${b}`,+ relation: "connects_to",+ description: "seed cross edge",+ });+ } catch (_) {}+ }++ const seedStats = initDb.getStats();+ console.log(`Seeded: ${seedStats.nodes} nodes, ${seedStats.edges} edges`);+ initDb.close();+ console.log();++ // Use a barrier file so all workers start their hot loops simultaneously+ const barrierPath = path.join(TEST_DIR, "barrier");++ // Spawn workers+ console.log(`Spawning ${NUM_WORKERS} worker processes...`);+ const startTime = Date.now();++ const workerPromises = [];+ for (let w = 0; w < NUM_WORKERS; w++) {+ workerPromises.push(runWorker(w, barrierPath));+ }++ // Give workers 500ms to start up and open DB connections, then signal go+ await new Promise(r => setTimeout(r, 500));+ const { writeFileSync } = await import("node:fs");+ writeFileSync(barrierPath, "GO");+ console.log(`Barrier released! All workers starting simultaneously...`);++ const results = await Promise.all(workerPromises);+ const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);++ // Aggregate results+ console.log();+ console.log("=".repeat(70));+ console.log(" WORKER RESULTS");+ console.log("=".repeat(70));++ let totalBusyErrors = 0;+ let totalOtherErrors = 0;+ let totalOps = 0;+ let totalInserts = 0;+ let totalEdgeInserts = 0;+ let totalSoftDeletes = 0;+ let totalHardDeletes = 0;+ let totalReads = 0;+ let totalTimelineWrites = 0;+ let totalTransactionalOps = 0;+ const allErrors = [];++ for (const r of results) {+ console.log(` Worker ${r.workerId}: ${r.ops} ops, ${r.busyErrors} BUSY, ${r.otherErrors} other errors (${r.softDeletes} soft-del, ${r.hardDeletes} hard-del)`);+ totalBusyErrors += r.busyErrors;+ totalOtherErrors += r.otherErrors;+ totalOps += r.ops;+ totalInserts += r.inserts;+ totalEdgeInserts += r.edgeInserts;+ totalSoftDeletes += r.softDeletes;+ totalHardDeletes += r.hardDeletes;+ totalReads += r.reads;+ totalTimelineWrites += r.timelineWrites;+ totalTransactionalOps += r.transactionalOps || 0;+ allErrors.push(...r.errorDetails);+ }++ console.log();+ console.log(` Total operations: ${totalOps}`);+ console.log(` Node inserts: ${totalInserts}`);+ console.log(` Edge inserts: ${totalEdgeInserts}`);+ console.log(` Soft deletes: ${totalSoftDeletes}`);+ console.log(` Hard deletes: ${totalHardDeletes}`);+ console.log(` Transactional inserts: ${totalTransactionalOps}`);+ console.log(` Reads: ${totalReads}`);+ console.log(` Timeline writes: ${totalTimelineWrites}`);+ console.log(` SQLITE_BUSY errors: ${totalBusyErrors}`);+ console.log(` Other errors: ${totalOtherErrors}`);+ console.log(` Elapsed: ${elapsed}s`);++ if (allErrors.length > 0) {+ console.log();+ console.log(" --- Error samples (up to 30) ---");+ // Group errors by type+ const errorCounts = {};+ for (const e of allErrors) {+ const key = `${e.op}: ${e.message}`;+ errorCounts[key] = (errorCounts[key] || 0) + 1;+ }+ const sorted = Object.entries(errorCounts).sort((a, b) => b[1] - a[1]);+ for (const [msg, count] of sorted.slice(0, 30)) {+ console.log(` [${count}x] ${msg}`);+ }+ }++ // ============ Post-mortem analysis ============+ console.log();+ console.log("=".repeat(70));+ console.log(" POST-MORTEM ANALYSIS");+ console.log("=".repeat(70));++ const db = new Database(DB_PATH);+ db.pragma("journal_mode = WAL");+ db.pragma("foreign_keys = ON");++ // 1. PRAGMA integrity_check+ console.log();+ const integrityResult = db.pragma("integrity_check");+ const integrityOk = Array.isArray(integrityResult)+ ? integrityResult.every(r => {+ const val = typeof r === "object" ? Object.values(r)[0] : r;+ return val === "ok";+ })+ : integrityResult === "ok";+ console.log(` PRAGMA integrity_check: ${integrityOk ? "✅ PASS" : "❌ FAIL"}`);+ if (!integrityOk) {+ console.log(` Details: ${JSON.stringify(integrityResult)}`);+ }++ // 2. Foreign key check+ const fkViolations = db.pragma("foreign_key_check");+ const fkClean = !fkViolations || (Array.isArray(fkViolations) && fkViolations.length === 0);+ console.log(` PRAGMA foreign_key_check: ${fkClean ? "✅ PASS" : "❌ FAIL — " + (Array.isArray(fkViolations) ? fkViolations.length : "?") + " violations"}`);+ if (!fkClean && Array.isArray(fkViolations)) {+ const samples = fkViolations.slice(0, 10);+ for (const v of samples) {+ console.log(` ${JSON.stringify(v)}`);+ }+ if (fkViolations.length > 10) {+ console.log(` ... and ${fkViolations.length - 10} more`);+ }+ }++ // 3. Orphaned edges — edges pointing to non-existent node IDs (hard-delete race)+ const orphanedEdges = db.prepare(`+ SELECT e.* FROM edges e+ LEFT JOIN nodes n1 ON e.from_id = n1.id+ LEFT JOIN nodes n2 ON e.to_id = n2.id+ WHERE n1.id IS NULL OR n2.id IS NULL+ `).all();+ console.log(` Orphaned edges (missing node): ${orphanedEdges.length === 0 ? "✅ 0" : "❌ " + orphanedEdges.length + " (hardDeleteNode race condition)"}`);+ if (orphanedEdges.length > 0) {+ const samples = orphanedEdges.slice(0, 10);+ for (const e of samples) {+ console.log(` edge ${e.id}: ${e.from_id} → ${e.to_id} (${e.relation})`);+ }+ if (orphanedEdges.length > 10) {+ console.log(` ... and ${orphanedEdges.length - 10} more`);+ }+ }++ // 4. Edges pointing to soft-deleted nodes (softDeleteNode race condition)+ const edgesToDeleted = db.prepare(`+ SELECT e.*,+ n1.removed_at as from_removed,+ n2.removed_at as to_removed+ FROM edges e+ JOIN nodes n1 ON e.from_id = n1.id+ JOIN nodes n2 ON e.to_id = n2.id+ WHERE n1.removed_at IS NOT NULL OR n2.removed_at IS NOT NULL+ `).all();+ console.log(` Edges to/from soft-deleted nodes: ${edgesToDeleted.length === 0 ? "✅ 0" : "⚠️ " + edgesToDeleted.length + " (INCONSISTENT — softDeleteNode race)"}`);+ if (edgesToDeleted.length > 0) {+ const samples = edgesToDeleted.slice(0, 10);+ for (const e of samples) {+ const fromDel = e.from_removed ? `from_removed=${e.from_removed}` : "";+ const toDel = e.to_removed ? `to_removed=${e.to_removed}` : "";+ console.log(` edge ${e.id}: ${e.from_id} → ${e.to_id} (${e.relation}) ${fromDel} ${toDel}`);+ }+ if (edgesToDeleted.length > 10) {+ console.log(` ... and ${edgesToDeleted.length - 10} more`);+ }+ }++ // 5. Soft-deleted nodes that still have edges (THE SPECIFIC BUG)+ // This catches the case where UPDATE succeeded but DELETE edges didn't run+ const softDeletedWithEdges = db.prepare(`+ SELECT n.id, n.name, n.removed_at, COUNT(e.id) as edge_count+ FROM nodes n+ JOIN edges e ON (e.from_id = n.id OR e.to_id = n.id)+ WHERE n.removed_at IS NOT NULL+ GROUP BY n.id+ `).all();+ console.log(` Soft-deleted nodes still having edges: ${softDeletedWithEdges.length === 0 ? "✅ 0" : "❌ " + softDeletedWithEdges.length + " (NON-ATOMIC softDeleteNode confirmed!)"}`);+ if (softDeletedWithEdges.length > 0) {+ for (const n of softDeletedWithEdges.slice(0, 10)) {+ console.log(` ${n.id}: removed_at=${n.removed_at}, still has ${n.edge_count} edge(s)`);+ }+ }++ // 6. Final counts+ const finalNodes = db.prepare("SELECT COUNT(*) as c FROM nodes WHERE removed_at IS NULL").get();+ const finalRemoved = db.prepare("SELECT COUNT(*) as c FROM nodes WHERE removed_at IS NOT NULL").get();+ const finalEdges = db.prepare("SELECT COUNT(*) as c FROM edges").get();+ const finalTimeline = db.prepare("SELECT COUNT(*) as c FROM timeline").get();++ // Count edges that SHOULD have been deleted but weren't+ const edgesShouldBeDeleted = db.prepare(`+ SELECT COUNT(*) as c FROM edges e+ WHERE EXISTS (SELECT 1 FROM nodes n WHERE n.id = e.from_id AND n.removed_at IS NOT NULL)+ OR EXISTS (SELECT 1 FROM nodes n WHERE n.id = e.to_id AND n.removed_at IS NOT NULL)+ `).get();++ console.log();+ console.log(` Final state:`);+ console.log(` Active nodes: ${finalNodes.c}`);+ console.log(` Removed nodes: ${finalRemoved.c}`);+ console.log(` Total edges: ${finalEdges.c}`);+ console.log(` Stale edges: ${edgesShouldBeDeleted.c} (should have been cleaned up)`);+ console.log(` Timeline rows: ${finalTimeline.c}`);++ db.close();++ // Summary+ console.log();+ console.log("=".repeat(70));+ console.log(" SUMMARY");+ console.log("=".repeat(70));++ const issues = [];+ if (totalBusyErrors > 0) issues.push(`${totalBusyErrors} SQLITE_BUSY errors (busy_timeout=1000ms too short)`);+ if (totalOtherErrors > 0) issues.push(`${totalOtherErrors} other errors`);+ if (!integrityOk) issues.push("PRAGMA integrity_check FAILED — database corruption");+ if (!fkClean) issues.push(`Foreign key violations: ${Array.isArray(fkViolations) ? fkViolations.length : "?"}`);+ if (orphanedEdges.length > 0) issues.push(`${orphanedEdges.length} orphaned edges (hardDeleteNode race)`);+ if (edgesToDeleted.length > 0) issues.push(`${edgesToDeleted.length} edges pointing to soft-deleted nodes`);+ if (softDeletedWithEdges.length > 0) issues.push(`${softDeletedWithEdges.length} soft-deleted nodes still have edges (non-atomic softDeleteNode BUG)`);++ if (issues.length === 0) {+ console.log(" ✅ No issues detected in this run");+ console.log(" (Run again — race conditions are non-deterministic)");+ } else {+ console.log(" ❌ Issues found:");+ for (const issue of issues) {+ console.log(` • ${issue}`);+ }+ }+ console.log();++ // Cleanup+ if (process.env.KEEP_DB !== "1") {+ rmSync(TEST_DIR, { recursive: true, force: true });+ console.log(` Cleaned up ${TEST_DIR}`);+ } else {+ console.log(` Database preserved at ${DB_PATH}`);+ }+ console.log();+}+++function runWorker(workerId, barrierPath) {+ return new Promise((resolve) => {+ const child = fork(+ fileURLToPath(import.meta.url),+ ["--worker", String(workerId), DB_PATH, String(ITERATIONS_PER_WORKER), String(NUM_WORKERS), barrierPath],+ {+ cwd: PROJECT_ROOT,+ stdio: ["pipe", "pipe", "pipe", "ipc"],+ }+ );++ let result = null;++ child.on("message", (msg) => {+ result = msg;+ });++ let stderr = "";+ child.stderr.on("data", (data) => {+ stderr += data.toString();+ });++ child.on("exit", (code) => {+ if (result) {+ resolve(result);+ } else {+ console.error(` Worker ${workerId} exited with code ${code}`);+ if (stderr) console.error(` stderr: ${stderr.slice(0, 500)}`);+ resolve({+ workerId,+ ops: 0,+ inserts: 0,+ edgeInserts: 0,+ softDeletes: 0,+ hardDeletes: 0,+ reads: 0,+ timelineWrites: 0,+ transactionalOps: 0,+ busyErrors: 0,+ otherErrors: 1,+ errorDetails: [{ worker: workerId, op: "spawn", message: `Worker crashed: code=${code}` }],+ });+ }+ });+ });+}++// ============ Worker process ============++async function workerMain() {+ const workerId = parseInt(process.argv[3]);+ const dbPath = process.argv[4];+ const iterations = parseInt(process.argv[5]);+ const barrierPath = process.argv[7];++ // Import KnowledgeDB from compiled dist+ const { KnowledgeDB } = await import(path.join(PROJECT_ROOT, "dist", "db.js"));+ const db = new KnowledgeDB(dbPath);++ // Wait for the barrier (spin-wait on file existence)+ const { existsSync } = await import("node:fs");+ while (!existsSync(barrierPath)) {+ await new Promise(r => setTimeout(r, 10));+ }++ const stats = {+ workerId,+ ops: 0,+ inserts: 0,+ edgeInserts: 0,+ softDeletes: 0,+ hardDeletes: 0,+ reads: 0,+ timelineWrites: 0,+ transactionalOps: 0,+ busyErrors: 0,+ otherErrors: 0,+ errorDetails: [],+ };++ const myNodes = [];+ const KINDS = ["feature", "module", "pattern", "config", "decision", "component"];+ const RELATIONS = ["connects_to", "depends_on", "implements", "calls", "configured_by"];+ const SEED_COUNT = 30;++ function randomId() {+ return `w${workerId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;+ }++ function randomChoice(arr) {+ return arr[Math.floor(Math.random() * arr.length)];+ }++ function randomSeedId() {+ return `seed-${Math.floor(Math.random() * SEED_COUNT)}`;+ }++ function trackError(op, err) {+ const msg = err.message || String(err);+ if (msg.includes("SQLITE_BUSY") || msg.includes("database is locked")) {+ stats.busyErrors++;+ } else {+ stats.otherErrors++;+ }+ stats.errorDetails.push({+ worker: workerId,+ op,+ message: msg.slice(0, 200),+ });+ }++ for (let i = 0; i < iterations; i++) {+ const roll = Math.random();++ if (roll < 0.20) {+ // INSERT NODE+ try {+ const nodeId = randomId();+ db.insertNode({+ id: nodeId,+ name: `Node ${nodeId}`,+ kind: randomChoice(KINDS),+ summary: `Stress test node created by worker ${workerId} iteration ${i}`,+ why: "stress testing",+ });+ myNodes.push(nodeId);+ stats.inserts++;+ stats.ops++;+ } catch (err) {+ trackError("insertNode", err);+ stats.ops++;+ }+ } else if (roll < 0.35) {+ // INSERT EDGE — high contention on seed nodes+ try {+ const fromId = Math.random() < 0.6 ? randomSeedId() : (myNodes.length > 0 ? randomChoice(myNodes) : randomSeedId());+ const toId = Math.random() < 0.6 ? randomSeedId() : (myNodes.length > 0 ? randomChoice(myNodes) : randomSeedId());++ if (fromId !== toId) {+ db.insertEdge({+ from_id: fromId,+ to_id: toId,+ relation: randomChoice(RELATIONS),+ description: `stress edge from worker ${workerId}`,+ });+ stats.edgeInserts++;+ }+ stats.ops++;+ } catch (err) {+ trackError("insertEdge", err);+ stats.ops++;+ }+ } else if (roll < 0.52) {+ // SOFT DELETE — the non-atomic operation, HIGH rate to maximize race window+ try {+ // Heavily target seed nodes so multiple workers race on the same node+ const targetId = Math.random() < 0.7 ? randomSeedId() : (myNodes.length > 0 ? myNodes.shift() : randomSeedId());+ db.softDeleteNode(targetId, `stress delete by worker ${workerId}`);+ stats.softDeletes++;+ stats.ops++;+ } catch (err) {+ trackError("softDeleteNode", err);+ stats.ops++;+ }+ } else if (roll < 0.60) {+ // HARD DELETE — also non-atomic+ try {+ const targetId = myNodes.length > 0 ? myNodes.shift() : randomSeedId();+ db.hardDeleteNode(targetId);+ stats.hardDeletes++;+ stats.ops++;+ } catch (err) {+ trackError("hardDeleteNode", err);+ stats.ops++;+ }+ } else if (roll < 0.72) {+ // READ — getAllActiveNodes+ try {+ db.getAllActiveNodes();+ stats.reads++;+ stats.ops++;+ } catch (err) {+ trackError("getAllActiveNodes", err);+ stats.ops++;+ }+ } else if (roll < 0.82) {+ // TIMELINE WRITE — amplifies write contention+ try {+ db.insertTimelineEntry({+ tool: "stress_test",+ params: JSON.stringify({ worker: workerId, iter: i }),+ result_summary: "stress test timeline entry to amplify write contention",+ is_write: true,+ is_error: false,+ affected_ids: [`w${workerId}-${i}`],+ });+ stats.timelineWrites++;+ stats.ops++;+ } catch (err) {+ trackError("insertTimelineEntry", err);+ stats.ops++;+ }+ } else if (roll < 0.90) {+ // READ — getNode + edges (typical MCP usage pattern)+ try {+ const targetId = Math.random() < 0.5 ? randomSeedId() : (myNodes.length > 0 ? randomChoice(myNodes) : "seed-0");+ db.getNode(targetId);+ db.getOutgoingEdges(targetId);+ db.getIncomingEdges(targetId);+ stats.reads++;+ stats.ops++;+ } catch (err) {+ trackError("getNode+edges", err);+ stats.ops++;+ }+ } else {+ // INSERT NODE + EDGES in transaction (via insertNodeAndEdges)+ try {+ const nodeId = randomId();+ const edges = [];+ const edgeCount = 1 + Math.floor(Math.random() * 4);+ for (let e = 0; e < edgeCount; e++) {+ edges.push({+ to_id: randomSeedId(),+ relation: randomChoice(RELATIONS),+ description: `stress txn edge`,+ });+ }+ db.insertNodeAndEdges(+ {+ id: nodeId,+ name: `TxnNode ${nodeId}`,+ kind: randomChoice(KINDS),+ summary: `Transactional node from worker ${workerId}`,+ why: null,+ file_refs: null,+ parent_id: null,+ created_by_task: null,+ embedding: null,+ },+ edges+ );+ myNodes.push(nodeId);+ stats.inserts++;+ stats.edgeInserts += edgeCount;+ stats.transactionalOps++;+ stats.ops++;+ } catch (err) {+ trackError("insertNodeAndEdges", err);+ stats.ops++;+ }+ }+ }++ try { db.close(); } catch (_) {}+ process.send(stats);+ process.exit(0);+}++// ============ Entry point ============++if (process.argv.includes("--worker")) {+ workerMain().catch((err) => {+ console.error("Worker fatal:", err);+ process.exit(1);+ });+} else {+ main().catch((err) => {+ console.error("Fatal:", err);+ process.exit(1);+ });+}