@hardkas/testing 0.6.0-alpha → 0.7.1-alpha

package/dist/index.js

@@ -14,6 +14,9 @@ import {
 import {
   hardKasMatchers
 } from "./chunk-IRVMANZV.js";
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
 
 // src/fixtures.ts
 function createFixture(def) {
@@ -32,14 +35,3677 @@ function createFixture(def) {
   }
   return harness;
 }
+
+// src/torture/torture-engine.ts
+var LcgPrng = class {
+  state;
+  constructor(seed) {
+    this.state = Math.abs(Math.trunc(seed)) % 2147483647;
+    if (this.state === 0) this.state = 1;
+  }
+  /** Returns a float between 0 (inclusive) and 1 (exclusive) */
+  next() {
+    this.state = this.state * 48271 % 2147483647;
+    return (this.state - 1) / 2147483646;
+  }
+  /** Returns an integer between min (inclusive) and max (inclusive) */
+  nextInt(min, max) {
+    return Math.floor(this.next() * (max - min + 1)) + min;
+  }
+  /** Pick a random element from an array */
+  pick(arr) {
+    if (arr.length === 0) {
+      throw new Error("Cannot pick from an empty array");
+    }
+    const idx = this.nextInt(0, arr.length - 1);
+    return arr[idx];
+  }
+  /** Deterministic shuffle */
+  shuffle(arr) {
+    const res = [...arr];
+    for (let i = res.length - 1; i > 0; i--) {
+      const j = this.nextInt(0, i);
+      const tmp = res[i];
+      res[i] = res[j];
+      res[j] = tmp;
+    }
+    return res;
+  }
+};
+var bucketsMap = /* @__PURE__ */ new Map();
+function registerTortureBucket(bucket) {
+  bucketsMap.set(bucket.name, bucket);
+}
+function getTortureBucket(name) {
+  return bucketsMap.get(name);
+}
+function getAllTortureBuckets() {
+  return Array.from(bucketsMap.values());
+}
+var TortureInvariantError = class extends Error {
+  code;
+  severity;
+  constructor(message, code, severity = "critical") {
+    super(message);
+    this.name = "TortureInvariantError";
+    this.code = code;
+    this.severity = severity;
+  }
+};
+
+// src/torture/buckets.ts
+import fs from "fs";
+import path from "path";
+import { calculateContentHash, ARTIFACT_VERSION, CURRENT_HASH_VERSION } from "@hardkas/artifacts";
+import { HardkasStore, SqliteQueryBackend } from "@hardkas/query-store";
+function createSandbox(ctx) {
+  const sandboxDir = path.join(ctx.workspaceDir, ".tmp", `torture-sandbox-${ctx.caseId}-${ctx.caseSeed}`);
+  const hardkasDir = path.join(sandboxDir, ".hardkas");
+  const artifactsDir = path.join(hardkasDir, "artifacts");
+  const dbPath = path.join(hardkasDir, "store.db");
+  fs.mkdirSync(artifactsDir, { recursive: true });
+  return { sandboxDir, hardkasDir, artifactsDir, dbPath };
+}
+function cleanupSandbox(sandboxDir) {
+  try {
+    if (fs.existsSync(sandboxDir)) {
+      fs.rmSync(sandboxDir, { recursive: true, force: true });
+    }
+  } catch {
+  }
+}
+registerTortureBucket({
+  name: "authority-deleteability",
+  expectedInvariant: "sqlite_is_not_authority",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    try {
+      const artifactCount = ctx.prng.nextInt(3, 8);
+      const generatedIds = [];
+      for (let i = 0; i < artifactCount; i++) {
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          planId: `plan-mock-${ctx.caseId}-${i}`,
+          from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+          to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+          amountSompi: (1000n * BigInt(ctx.prng.nextInt(1, 100) * 10 + i)).toString(),
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [
+            {
+              outpoint: { transactionId: "a".repeat(64), index: 0 },
+              amountSompi: "200000"
+            }
+          ],
+          outputs: [
+            {
+              address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg",
+              amountSompi: "1000"
+            }
+          ]
+        };
+        const hash = calculateContentHash(payload);
+        const artifactId = `plan-${hash.slice(0, 16)}`;
+        const artifact = {
+          ...payload,
+          artifactId,
+          contentHash: hash
+        };
+        const file = path.join(artifactsDir, `${artifactId}.json`);
+        fs.writeFileSync(file, JSON.stringify(artifact, null, 2), "utf-8");
+        generatedIds.push(artifactId);
+      }
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      const indexedBefore = await backend.findArtifacts();
+      if (indexedBefore.length !== artifactCount) {
+        throw new Error(`Expected ${artifactCount} artifacts to be indexed, got ${indexedBefore.length}`);
+      }
+      store.disconnect();
+      if (fs.existsSync(dbPath)) {
+        fs.unlinkSync(dbPath);
+      }
+      const eventsPath = path.join(hardkasDir, "events.jsonl");
+      if (fs.existsSync(eventsPath)) {
+        fs.unlinkSync(eventsPath);
+      }
+      const newStore = new HardkasStore({ dbPath });
+      newStore.connect({ autoMigrate: true });
+      const newBackend = new SqliteQueryBackend(newStore);
+      const rebuildResult = await newBackend.rebuild({ strict: true, cwd: sandboxDir });
+      if (!rebuildResult.ok) {
+        throw new Error(`Rebuild failed: ${rebuildResult.errors.join(", ")}`);
+      }
+      const indexedAfter = await newBackend.findArtifacts();
+      newStore.disconnect();
+      if (indexedAfter.length !== artifactCount) {
+        throw new Error(`State authority failure. Rebuilt database has ${indexedAfter.length} artifacts, expected ${artifactCount}`);
+      }
+      for (const artId of generatedIds) {
+        const found = indexedAfter.find((a) => a.artifactId === artId);
+        if (!found) {
+          throw new Error(`State authority failure. Missing reconstructed artifact: ${artId}`);
+        }
+      }
+      return {
+        flow: "Synchronize and reconstruct query store",
+        mutation: "Delete SQLite store.db and verify rebuild",
+        expectedInvariant: "sqlite_is_not_authority",
+        artifactsBefore: generatedIds
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "artifact-corruption",
+  expectedInvariant: "corrupted_artifacts_must_fail",
+  async run(ctx) {
+    const { sandboxDir, artifactsDir, dbPath } = createSandbox(ctx);
+    try {
+      const payload = {
+        schema: "hardkas.txPlan",
+        hardkasVersion: "0.7.0-alpha",
+        version: ARTIFACT_VERSION,
+        networkId: "simnet",
+        mode: "simulated",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        planId: `plan-mock-${ctx.caseId}`,
+        from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+        to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+        amountSompi: "5000",
+        estimatedFeeSompi: "100",
+        estimatedMass: "10",
+        inputs: [
+          {
+            outpoint: { transactionId: "a".repeat(64), index: 0 },
+            amountSompi: "10000"
+          }
+        ],
+        outputs: [
+          {
+            address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg",
+            amountSompi: "5000"
+          }
+        ]
+      };
+      const validHash = calculateContentHash(payload);
+      const artifactId = `plan-${validHash.slice(0, 16)}`;
+      const validArtifact = {
+        ...payload,
+        artifactId,
+        contentHash: validHash
+      };
+      const file = path.join(artifactsDir, `${artifactId}.json`);
+      fs.writeFileSync(file, JSON.stringify(validArtifact, null, 2), "utf-8");
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      const indexed = await backend.findArtifacts();
+      if (indexed.length !== 1) {
+        throw new Error("Failed to index initial valid artifact");
+      }
+      const corruptedArtifact = {
+        ...validArtifact,
+        amountSompi: "9999999999"
+        // altered content, causing hash mismatch!
+      };
+      fs.writeFileSync(file, JSON.stringify(corruptedArtifact, null, 2), "utf-8");
+      let threwCorrectly = false;
+      try {
+        await backend.sync({ strict: true, cwd: sandboxDir });
+      } catch (err) {
+        threwCorrectly = true;
+      }
+      store.disconnect();
+      if (!threwCorrectly) {
+        throw new Error("Invariant violated: corrupted artifact synchronized successfully without error under strict mode");
+      }
+      return {
+        flow: "Verify tampered artifact integrity",
+        mutation: "Alter artifact content Sompi amount on disk leaving original contentHash",
+        expectedInvariant: "corrupted_artifacts_must_fail",
+        artifactsBefore: [artifactId]
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "deterministic-repeatability",
+  expectedInvariant: "same_input_same_seed_equals_same_hash",
+  async run(ctx) {
+    const prngA = new LcgPrng(ctx.caseSeed);
+    const amountSompiA = (1000n * BigInt(prngA.nextInt(1, 100))).toString();
+    const nonceA = prngA.nextInt(1e4, 99999);
+    const orderA = prngA.shuffle(["alice", "bob", "carol", "dave"]);
+    const payloadA = {
+      schema: "hardkas.txPlan",
+      version: "0.7.0-alpha",
+      networkId: "simnet",
+      mode: "simulated",
+      amountSompi: amountSompiA,
+      nonce: nonceA,
+      signers: orderA
+    };
+    const hashA = calculateContentHash(payloadA);
+    const prngB = new LcgPrng(ctx.caseSeed);
+    const amountSompiB = (1000n * BigInt(prngB.nextInt(1, 100))).toString();
+    const nonceB = prngB.nextInt(1e4, 99999);
+    const orderB = prngB.shuffle(["alice", "bob", "carol", "dave"]);
+    const payloadB = {
+      schema: "hardkas.txPlan",
+      version: "0.7.0-alpha",
+      networkId: "simnet",
+      mode: "simulated",
+      amountSompi: amountSompiB,
+      nonce: nonceB,
+      signers: orderB
+    };
+    const hashB = calculateContentHash(payloadB);
+    if (hashA !== hashB) {
+      throw new Error(`Divergence detected under same seed ${ctx.caseSeed}. Hash A: ${hashA}, Hash B: ${hashB}`);
+    }
+    if (JSON.stringify(payloadA) !== JSON.stringify(payloadB)) {
+      throw new Error("Semantic payloads differ despite identical seed execution");
+    }
+    return {
+      flow: "Run parallel deterministic generation pipelines",
+      mutation: "Execute generator with identical seed A and seed B",
+      expectedInvariant: "same_input_same_seed_equals_same_hash",
+      artifactsBefore: [hashA]
+    };
+  }
+});
+registerTortureBucket({
+  name: "projection-staleness",
+  expectedInvariant: "projection_cache_matches_artifacts",
+  async run(ctx) {
+    const { sandboxDir, artifactsDir, dbPath } = createSandbox(ctx);
+    try {
+      const payloadV1 = {
+        schema: "hardkas.txPlan",
+        hardkasVersion: "0.7.0-alpha",
+        version: ARTIFACT_VERSION,
+        networkId: "simnet",
+        mode: "simulated",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        planId: `plan-mock-${ctx.caseId}`,
+        from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+        to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+        amountSompi: "1000",
+        estimatedFeeSompi: "100",
+        estimatedMass: "10",
+        inputs: [
+          {
+            outpoint: { transactionId: "a".repeat(64), index: 0 },
+            amountSompi: "2000"
+          }
+        ],
+        outputs: [
+          {
+            address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg",
+            amountSompi: "1000"
+          }
+        ],
+        state: "initial"
+        // Custom field for test assertion
+      };
+      const hashV1 = calculateContentHash(payloadV1);
+      const artifactId = `plan-${hashV1.slice(0, 16)}`;
+      const file = path.join(artifactsDir, `${artifactId}.json`);
+      const artifactV1 = {
+        ...payloadV1,
+        artifactId,
+        contentHash: hashV1
+      };
+      fs.writeFileSync(file, JSON.stringify(artifactV1, null, 2), "utf-8");
+      const originalTime = Date.now() - 1e4;
+      fs.utimesSync(file, new Date(originalTime), new Date(originalTime));
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      const artBefore = await backend.getArtifact(artifactId);
+      if (!artBefore || artBefore.payload.state !== "initial") {
+        throw new Error("Failed to index initial version of the artifact");
+      }
+      const payloadV2 = {
+        ...payloadV1,
+        state: "progressed",
+        nonce: ctx.prng.nextInt(100, 999)
+      };
+      const hashV2 = calculateContentHash(payloadV2);
+      const artifactV2 = {
+        ...payloadV2,
+        artifactId,
+        // same ID, updated content/hash
+        contentHash: hashV2
+      };
+      fs.writeFileSync(file, JSON.stringify(artifactV2, null, 2), "utf-8");
+      const updatedTime = Date.now();
+      fs.utimesSync(file, new Date(updatedTime), new Date(updatedTime));
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      const artAfter = await backend.getArtifact(artifactId);
+      store.disconnect();
+      if (!artAfter) {
+        throw new Error("Artifact deleted unexpectedly after update sync");
+      }
+      if (artAfter.contentHash !== hashV2 || artAfter.payload.state !== "progressed") {
+        throw new Error(`Staleness invariant failure. Expected hash ${hashV2} and state 'progressed', got hash ${artAfter.contentHash} and state '${artAfter.payload.state}'`);
+      }
+      return {
+        flow: "Verify incremental update detection",
+        mutation: "Modify file payload state and update file mtime on disk",
+        expectedInvariant: "projection_cache_matches_artifacts",
+        artifactsBefore: [artifactId]
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "workflow-crash-resume",
+  expectedInvariant: "workflow_crash_resume_integrity",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    try {
+      const { createTestHarness: createTestHarness2 } = await import("./index.js");
+      const harness = createTestHarness2({ accounts: 3, initialBalance: 100000000000n });
+      const names = harness.accountNames();
+      const tx = harness.send({
+        from: names[0],
+        to: names[1],
+        amountSompi: 5000000000n
+      });
+      if (!tx.ok || !tx.plan) {
+        throw new Error("Harness failed to build payment transaction plan");
+      }
+      const planArtifact = {
+        schema: "hardkas.txPlan",
+        hardkasVersion: "0.7.0-alpha",
+        version: ARTIFACT_VERSION,
+        networkId: "simnet",
+        mode: "simulated",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        planId: `plan-${tx.plan.estimatedMass}-${ctx.caseSeed}`,
+        from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+        to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+        amountSompi: tx.plan.outputs[0].amountSompi.toString(),
+        estimatedFeeSompi: tx.plan.estimatedFeeSompi.toString(),
+        estimatedMass: tx.plan.estimatedMass.toString(),
+        inputs: tx.plan.inputs.map((inp) => ({
+          outpoint: {
+            transactionId: inp.outpoint.transactionId,
+            index: inp.outpoint.index
+          },
+          amountSompi: inp.amountSompi.toString()
+        })),
+        outputs: tx.plan.outputs.map((out) => ({
+          address: out.address,
+          amountSompi: out.amountSompi.toString()
+        }))
+      };
+      const planHash = calculateContentHash(planArtifact);
+      const planId = `plan-${planHash.slice(0, 16)}`;
+      const conformingPlan = {
+        ...planArtifact,
+        artifactId: planId,
+        contentHash: planHash
+      };
+      const planFile = path.join(artifactsDir, `${planId}.json`);
+      fs.writeFileSync(planFile, JSON.stringify(conformingPlan, null, 2), "utf-8");
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      const indexedPlan = await backend.getArtifact(planId);
+      if (!indexedPlan) {
+        throw new Error("Failed to index plan prior to simulated system crash");
+      }
+      store.disconnect();
+      if (fs.existsSync(dbPath)) {
+        fs.unlinkSync(dbPath);
+      }
+      const newStore = new HardkasStore({ dbPath });
+      newStore.connect({ autoMigrate: true });
+      const newBackend = new SqliteQueryBackend(newStore);
+      const rebuildResult = await newBackend.rebuild({ strict: true, cwd: sandboxDir });
+      if (!rebuildResult.ok) {
+        throw new Error("Query store failed to rebuild state projections after crash");
+      }
+      const recoveredPlan = await newBackend.getArtifact(planId);
+      if (!recoveredPlan) {
+        throw new Error("Crash recovery failed: plan artifact was not reconstructed");
+      }
+      const receiptArtifact = {
+        schema: "hardkas.txReceipt",
+        hardkasVersion: "0.7.0-alpha",
+        version: ARTIFACT_VERSION,
+        networkId: "simnet",
+        mode: "simulated",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        txId: tx.receipt.txId,
+        status: "confirmed",
+        from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+        to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+        amountSompi: tx.plan.outputs[0].amountSompi.toString(),
+        feeSompi: tx.plan.estimatedFeeSompi.toString(),
+        mass: tx.plan.estimatedMass.toString(),
+        lineage: {
+          artifactId: `receipt-${tx.receipt.txId.slice(0, 16)}`,
+          lineageId: "l-" + ctx.caseSeed,
+          parentArtifactId: planId,
+          // linked to the parent plan!
+          rootArtifactId: planId
+        }
+      };
+      const receiptHash = calculateContentHash(receiptArtifact);
+      const receiptId = `receipt-${receiptHash.slice(0, 16)}`;
+      const conformingReceipt = {
+        ...receiptArtifact,
+        artifactId: receiptId,
+        contentHash: receiptHash
+      };
+      const receiptFile = path.join(artifactsDir, `${receiptId}.json`);
+      fs.writeFileSync(receiptFile, JSON.stringify(conformingReceipt, null, 2), "utf-8");
+      await newBackend.sync({ strict: true, cwd: sandboxDir });
+      const finalReceipt = await newBackend.getArtifact(receiptId);
+      newStore.disconnect();
+      if (!finalReceipt) {
+        throw new Error("Failed to index final transaction receipt after resuming workflow");
+      }
+      if (finalReceipt.payload.lineage.parentArtifactId !== planId) {
+        throw new Error("Lineage continuity violated: resumed receipt parentId does not match pre-crash planId");
+      }
+      return {
+        flow: "Recover from intermediate workflow crash and complete pipeline",
+        mutation: "Wipe sqlite database, rebuild from raw plan, then append signed receipt",
+        expectedInvariant: "workflow_crash_resume_integrity",
+        artifactsBefore: [planId],
+        artifactsAfter: [receiptId]
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "partial-artifact-commit",
+  expectedInvariant: "no_partial_artifact_becomes_canonical",
+  async run(ctx) {
+    const { sandboxDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 12);
+    try {
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      const planId = `plan-mock-${ctx.caseId}-${ctx.caseSeed}`;
+      const payload = {
+        schema: "hardkas.txPlan",
+        hardkasVersion: "0.7.0-alpha",
+        version: ARTIFACT_VERSION,
+        networkId: "simnet",
+        mode: "simulated",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        // hardkas-determinism-allow: mock creation timestamp
+        planId,
+        from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+        to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+        amountSompi: "1000",
+        estimatedFeeSompi: "100",
+        estimatedMass: "10",
+        inputs: [{ outpoint: { transactionId: "a".repeat(64), index: 0 }, amountSompi: "2000" }],
+        outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "1000" }]
+      };
+      const validHash = calculateContentHash(payload);
+      const artifactId = `plan-${validHash.slice(0, 16)}`;
+      const file = path.join(artifactsDir, `${artifactId}.json`);
+      const validArtifact = { ...payload, artifactId, contentHash: validHash };
+      fs.writeFileSync(file, JSON.stringify(validArtifact, null, 2));
+      const badFile = path.join(artifactsDir, `bad-artifact-${subCase}.json`);
+      let shouldSyncThrow = false;
+      let checkIgnored = false;
+      switch (subCase) {
+        case 1:
+          fs.writeFileSync(badFile, `{"schema": "hardkas.txPlan", "planId": "${planId}"`, "utf-8");
+          shouldSyncThrow = true;
+          break;
+        case 2:
+          fs.writeFileSync(badFile, Buffer.from([123, 34, 195, 40, 125]));
+          shouldSyncThrow = true;
+          break;
+        case 3: {
+          const tempFile = path.join(artifactsDir, `.tmp-plan-${subCase}.json`);
+          fs.writeFileSync(tempFile, JSON.stringify(validArtifact, null, 2));
+          checkIgnored = true;
+          break;
+        }
+        case 4: {
+          const hashMismatchArt = { ...validArtifact, amountSompi: "9999", artifactId: "plan-mismatch" };
+          fs.writeFileSync(badFile, JSON.stringify(hashMismatchArt, null, 2));
+          shouldSyncThrow = true;
+          break;
+        }
+        case 5:
+          fs.writeFileSync(badFile, JSON.stringify({ schema: "hardkas.txPlan", version: ARTIFACT_VERSION, contentHash: validHash, artifactId: "plan-meta-only" }, null, 2));
+          shouldSyncThrow = true;
+          break;
+        case 6:
+          fs.writeFileSync(badFile, JSON.stringify(payload, null, 2));
+          shouldSyncThrow = true;
+          break;
+        case 7: {
+          const missingHashArt = { ...validArtifact };
+          delete missingHashArt.contentHash;
+          fs.writeFileSync(badFile, JSON.stringify(missingHashArt, null, 2));
+          shouldSyncThrow = true;
+          break;
+        }
+        case 8: {
+          const orphanReceipt = {
+            schema: "hardkas.txReceipt",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            txId: "b".repeat(64),
+            status: "confirmed",
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "1000",
+            feeSompi: "100",
+            lineage: {
+              artifactId: "receipt-orphan",
+              lineageId: "lineage-orphan",
+              parentArtifactId: "non-existent-parent-id",
+              rootArtifactId: "non-existent-parent-id"
+            }
+          };
+          const receiptHash = calculateContentHash(orphanReceipt);
+          const receiptId = `receipt-${receiptHash.slice(0, 16)}`;
+          fs.writeFileSync(path.join(artifactsDir, `${receiptId}.json`), JSON.stringify({ ...orphanReceipt, artifactId: receiptId, contentHash: receiptHash }, null, 2));
+          break;
+        }
+        case 9:
+          break;
+        case 10: {
+          const dupFile = path.join(artifactsDir, `dup-artifact-${subCase}.json`);
+          const dupArt = { ...validArtifact, amountSompi: "500" };
+          fs.writeFileSync(dupFile, JSON.stringify(dupArt, null, 2));
+          break;
+        }
+        case 11: {
+          const crashFile = path.join(artifactsDir, `.tmp-crash-${subCase}`);
+          fs.writeFileSync(crashFile, JSON.stringify(validArtifact, null, 2));
+          checkIgnored = true;
+          break;
+        }
+        case 12:
+          break;
+      }
+      let threw = false;
+      try {
+        await backend.sync({ strict: true, cwd: sandboxDir });
+      } catch (err) {
+        threw = true;
+      }
+      if (shouldSyncThrow && !threw) {
+        throw new TortureInvariantError(
+          `Sync with strict: true did not throw on partial/corrupted file for case ${subCase}`,
+          "PARTIAL_ARTIFACT_NOT_REJECTED",
+          "critical"
+        );
+      }
+      const records = await backend.findArtifacts();
+      if (checkIgnored) {
+        const badFound = records.some((r) => r.artifactId.includes(`bad-artifact-${subCase}`) || r.artifactId.includes(`.tmp-`));
+        if (badFound) {
+          throw new TortureInvariantError(
+            `Temp or ignored file was indexed into the query-store under case ${subCase}`,
+            "TEMP_FILE_INDEXED",
+            "critical"
+          );
+        }
+      }
+      if (subCase === 8 || subCase === 9) {
+        const edges = await backend.getLineageEdges();
+        const hasBadEdge = edges.some((e) => e.parentArtifactId === "non-existent-parent-id");
+        if (hasBadEdge) {
+          throw new TortureInvariantError(
+            "Orphan child created a valid lineage edge to a missing parent",
+            "ORPHAN_LINEAGE_CREATED",
+            "critical"
+          );
+        }
+      }
+      if (subCase === 10) {
+        const matched = records.filter((r) => r.artifactId === artifactId);
+        if (matched.length > 1) {
+          throw new TortureInvariantError(
+            "Duplicate artifact ID produced multiple canonical query-store records",
+            "DUPLICATE_CANONICAL_RECORDS",
+            "critical"
+          );
+        }
+      }
+      store.disconnect();
+      return {
+        flow: `Verify partial commit under subcase ${subCase}`,
+        mutation: `Write partial/corrupted/temp file under subcase type ${subCase}`,
+        expectedInvariant: "no_partial_artifact_becomes_canonical",
+        artifactsBefore: [artifactId]
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "concurrent-workflow-race",
+  expectedInvariant: "single_canonical_lineage_under_concurrent_writes",
+  async run(ctx) {
+    const { sandboxDir, artifactsDir, dbPath } = createSandbox(ctx);
+    try {
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      const promises = [];
+      const generatedIds = [];
+      for (let i = 0; i < 5; i++) {
+        const pId = `plan-race-${i}-${ctx.caseSeed}`;
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // hardkas-determinism-allow: mock timestamp
+          planId: pId,
+          from: { address: `kaspa:sim_from_${i}` },
+          to: { address: `kaspa:sim_to_${i}` },
+          amountSompi: "5000",
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [{ outpoint: { transactionId: "c".repeat(64), index: i }, amountSompi: "10000" }],
+          outputs: [{ address: `kaspa:sim_to_${i}`, amountSompi: "5000" }]
+        };
+        const hash = calculateContentHash(payload);
+        const artId = `plan-${hash.slice(0, 16)}`;
+        generatedIds.push(artId);
+        promises.push((async () => {
+          const file = path.join(artifactsDir, `${artId}.json`);
+          fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+          try {
+            await backend.sync({ strict: true, cwd: sandboxDir });
+          } catch (err) {
+          }
+        })());
+      }
+      await Promise.all(promises);
+      const syncRes = await backend.sync({ strict: true, cwd: sandboxDir });
+      const rebuildRes = await backend.rebuild({ strict: true, cwd: sandboxDir });
+      if (!syncRes.ok || !rebuildRes.ok) {
+        throw new TortureInvariantError(
+          "Concurrent sync or rebuild failed to complete successfully",
+          "CONCURRENT_SYNC_FAILED",
+          "critical"
+        );
+      }
+      const records = await backend.findArtifacts();
+      const ids = records.map((r) => r.artifactId);
+      const uniqueIds = new Set(ids);
+      if (ids.length !== uniqueIds.size) {
+        throw new TortureInvariantError(
+          "Duplicate canonical IDs produced during concurrent writes",
+          "DUPLICATE_CANONICAL_IDS",
+          "critical"
+        );
+      }
+      store.disconnect();
+      return {
+        flow: "Trigger concurrent writes and intermediate query-store syncs",
+        mutation: "Write multiple artifacts in async parallel tasks",
+        expectedInvariant: "single_canonical_lineage_under_concurrent_writes",
+        artifactsBefore: generatedIds
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "dashboard-stale-truth",
+  expectedInvariant: "dashboard_never_claims_verified_from_stale_projection",
+  async run(ctx) {
+    const { sandboxDir, artifactsDir, dbPath } = createSandbox(ctx);
+    try {
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      const planId = `plan-stale-${ctx.caseSeed}`;
+      const payload = {
+        schema: "hardkas.txPlan",
+        hardkasVersion: "0.7.0-alpha",
+        version: ARTIFACT_VERSION,
+        networkId: "simnet",
+        mode: "simulated",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        // hardkas-determinism-allow: mock timestamp
+        planId,
+        from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+        to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+        amountSompi: "1000",
+        estimatedFeeSompi: "100",
+        estimatedMass: "10",
+        inputs: [{ outpoint: { transactionId: "d".repeat(64), index: 0 }, amountSompi: "2000" }],
+        outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "1000" }]
+      };
+      const hash = calculateContentHash(payload);
+      const artId = `plan-${hash.slice(0, 16)}`;
+      const file = path.join(artifactsDir, `${artId}.json`);
+      fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      const statusBefore = await backend.doctor();
+      if (!statusBefore.ok) {
+        throw new Error("Doctor check failed on initial fresh index");
+      }
+      const mutatedPayload = { ...payload, amountSompi: "9999" };
+      fs.writeFileSync(file, JSON.stringify({ ...mutatedPayload, artifactId: artId, contentHash: hash }, null, 2));
+      const futureTime = Date.now() + 5e4;
+      fs.utimesSync(file, new Date(futureTime), new Date(futureTime));
+      const statusAfter = await backend.doctor();
+      store.disconnect();
+      if (statusAfter.ok || statusAfter.staleArtifacts === 0) {
+        throw new TortureInvariantError(
+          "Stale projection was reported as VERIFIED / OK by query backend doctor",
+          "STALE_PROJECTION_NOT_VERIFIED",
+          "critical"
+        );
+      }
+      return {
+        flow: "Mutate disk artifacts and inspect query-store status",
+        mutation: "Modify file on disk without triggering incremental query-store sync",
+        expectedInvariant: "dashboard_never_claims_verified_from_stale_projection",
+        artifactsBefore: [artId]
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "runtime-impurity-detection",
+  expectedInvariant: "deterministic_runtime_rejects_ambient_impurity",
+  async run(ctx) {
+    const rootDir = ctx.workspaceDir;
+    const targetDirs = [
+      "packages/sdk/src",
+      "packages/cli/src",
+      "packages/artifacts/src",
+      "packages/query-store/src",
+      "packages/localnet/src"
+    ];
+    const forbiddenPatterns = [
+      { regex: /Math\.random\(/, name: "Math.random()" },
+      { regex: /Date\.now\(/, name: "Date.now()" },
+      { regex: /new Date\(/, name: "new Date()" },
+      { regex: /randomUUID\(/, name: "randomUUID()" },
+      { regex: /crypto\.randomUUID\(/, name: "crypto.randomUUID()" },
+      { regex: /readdirSync\(/, name: "readdirSync()" },
+      { regex: /process\.cwd\(/, name: "process.cwd()" },
+      { regex: /process\.env\b/, name: "process.env" },
+      { regex: /os\.tmpdir\(/, name: "os.tmpdir()" }
+    ];
+    const findings = [];
+    const walkAndScan = (dir) => {
+      const absDir = path.join(rootDir, dir);
+      if (!fs.existsSync(absDir)) return;
+      const list = fs.readdirSync(absDir);
+      for (const item of list) {
+        const itemPath = path.join(absDir, item);
+        const relPath = path.join(dir, item);
+        const stat = fs.statSync(itemPath);
+        if (stat.isDirectory()) {
+          walkAndScan(relPath);
+        } else if (item.endsWith(".ts") || item.endsWith(".js") || item.endsWith(".mts")) {
+          const content = fs.readFileSync(itemPath, "utf-8");
+          const lines = content.split("\n");
+          for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNum = i + 1;
+            if (line.includes("hardkas-determinism-allow")) continue;
+            if (i > 0 && lines[i - 1].includes("hardkas-determinism-allow")) continue;
+            for (const pat of forbiddenPatterns) {
+              if (pat.regex.test(line)) {
+                if (pat.name === "readdirSync()" && line.includes(".sort(")) continue;
+                const isCoreDeterministic = relPath.includes("packages/artifacts/src/") || relPath.includes("packages/query-store/src/") || relPath.includes("packages/sdk/src/replay.ts") || relPath.includes("packages/sdk/src/workflow.ts") || relPath.includes("packages/localnet/src/");
+                if (isCoreDeterministic) {
+                  findings.push(`${relPath}:${lineNum} - Found core determinism violation: ${pat.name}`);
+                }
+              }
+            }
+          }
+        }
+      }
+    };
+    for (const dir of targetDirs) {
+      walkAndScan(dir);
+    }
+    if (findings.length > 0) {
+      throw new TortureInvariantError(
+        `Ambient non-determinism detected in deterministic runtime paths without allowlist comments:
+${findings.join("\n")}`,
+        "DETERMINISM_VIOLATION",
+        "critical"
+      );
+    }
+    return {
+      flow: "Scan monorepo source files for forbidden ambient impurities",
+      mutation: "Perform semantic scanning across core packages",
+      expectedInvariant: "deterministic_runtime_rejects_ambient_impurity",
+      artifactsBefore: []
+    };
+  }
+});
+registerTortureBucket({
+  name: "watcher-sse-storm",
+  expectedInvariant: "event_storm_cannot_create_canonical_divergence",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    try {
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      const generatedIds = [];
+      const eventsFile = path.join(hardkasDir, "events.jsonl");
+      for (let i = 0; i < 10; i++) {
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // hardkas-determinism-allow: mock timestamp
+          planId: `plan-storm-${i}-${ctx.caseSeed}`,
+          from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+          to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+          amountSompi: (1000n * BigInt(i + 1)).toString(),
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [{ outpoint: { transactionId: "e".repeat(64), index: i }, amountSompi: "20000" }],
+          outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "1000" }]
+        };
+        const hash = calculateContentHash(payload);
+        const artId = `plan-${hash.slice(0, 16)}`;
+        generatedIds.push(artId);
+        const file = path.join(artifactsDir, `${artId}.json`);
+        fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+        const evEnvelope = {
+          schema: "hardkas.event",
+          eventId: `ev-storm-${i}`,
+          kind: "workflow.completed",
+          domain: "workflow",
+          workflowId: `wf-${ctx.caseSeed}`,
+          correlationId: `corr-${i}`,
+          networkId: "simnet",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          payload: { txId: "f".repeat(64) }
+        };
+        fs.appendFileSync(eventsFile, JSON.stringify(evEnvelope) + "\n");
+        fs.appendFileSync(eventsFile, JSON.stringify(evEnvelope) + "\n");
+      }
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      if (fs.existsSync(eventsFile)) {
+        fs.unlinkSync(eventsFile);
+      }
+      const rebuildResult = await backend.rebuild({ strict: true, cwd: sandboxDir });
+      if (!rebuildResult.ok) {
+        throw new Error("Rebuild failed after event storm simulation");
+      }
+      const records = await backend.findArtifacts();
+      store.disconnect();
+      if (records.length !== generatedIds.length) {
+        throw new TortureInvariantError(
+          `Parity check failed: filesystem has ${generatedIds.length} artifacts, database has ${records.length} after event storm and rebuild`,
+          "EVENT_STORM_DIVIDED_TRUTH",
+          "critical"
+        );
+      }
+      return {
+        flow: "Generate watch event storm with duplicates and dropped events",
+        mutation: "Append duplicates to event log, delete events.jsonl, then trigger rebuild",
+        expectedInvariant: "event_storm_cannot_create_canonical_divergence",
+        artifactsBefore: generatedIds
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "workspace-filesystem-chaos",
+  expectedInvariant: "workspace_boundaries_and_canonical_paths_are_stable",
+  async run(ctx) {
+    const { sandboxDir, artifactsDir, dbPath } = createSandbox(ctx);
+    try {
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      const traverseArtId = "../../traversal-escape";
+      const payload = {
+        schema: "hardkas.txPlan",
+        hardkasVersion: "0.7.0-alpha",
+        version: ARTIFACT_VERSION,
+        networkId: "simnet",
+        mode: "simulated",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        // hardkas-determinism-allow: mock timestamp
+        planId: "plan-traversal",
+        from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+        to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+        amountSompi: "1000",
+        estimatedFeeSompi: "100",
+        estimatedMass: "10",
+        inputs: [{ outpoint: { transactionId: "g".repeat(64), index: 0 }, amountSompi: "2000" }],
+        outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "1000" }]
+      };
+      const hash = calculateContentHash(payload);
+      const traverseFile = path.join(artifactsDir, "..", "..", `traversal-${ctx.caseSeed}.json`);
+      fs.writeFileSync(traverseFile, JSON.stringify({ ...payload, artifactId: traverseArtId, contentHash: hash }, null, 2));
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      const records = await backend.findArtifacts();
+      const escaped = records.some((r) => r.artifactId.includes("traversal"));
+      if (escaped) {
+        throw new TortureInvariantError(
+          "Path traversal artifact escaped sandbox and was indexed",
+          "PATH_TRAVERSAL_ESCAPED",
+          "catastrophic"
+          // Catastrophic severity for sandboxing escape!
+        );
+      }
+      const validId = `plan-move-${ctx.caseSeed}`;
+      const validFile = path.join(artifactsDir, `${validId}.json`);
+      fs.writeFileSync(validFile, JSON.stringify({ ...payload, artifactId: validId, contentHash: hash }, null, 2));
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      store.disconnect();
+      const newSandboxDir = `${sandboxDir}-moved`;
+      if (fs.existsSync(newSandboxDir)) {
+        fs.rmSync(newSandboxDir, { recursive: true, force: true });
+      }
+      fs.renameSync(sandboxDir, newSandboxDir);
+      const newDbPath = path.join(newSandboxDir, ".hardkas", "store.db");
+      const newStore = new HardkasStore({ dbPath: newDbPath });
+      newStore.connect({ autoMigrate: true });
+      const newBackend = new SqliteQueryBackend(newStore);
+      const rebuildResult = await newBackend.rebuild({ strict: true, cwd: newSandboxDir });
+      if (!rebuildResult.ok) {
+        throw new Error("Failed to rebuild after moving workspace folder");
+      }
+      const movedRecords = await newBackend.findArtifacts();
+      const movedRecord = movedRecords.find((r) => r.artifactId === validId);
+      newStore.disconnect();
+      cleanupSandbox(newSandboxDir);
+      if (!movedRecord || !movedRecord.path.startsWith(newSandboxDir)) {
+        throw new TortureInvariantError(
+          "Rebuild failed to canonicalize paths to the new moved workspace directory",
+          "CANONICAL_PATH_NOT_STABLE",
+          "critical"
+        );
+      }
+      return {
+        flow: "Verify path sandboxing and directory migration canonicalization",
+        mutation: "Perform relative path traversal writes and move sandbox directory",
+        expectedInvariant: "workspace_boundaries_and_canonical_paths_are_stable"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "capability-agent-denial",
+  expectedInvariant: "agents_cannot_mutate_without_explicit_capability",
+  async run(ctx) {
+    const { sandboxDir } = createSandbox(ctx);
+    try {
+      const { Hardkas } = await import("@hardkas/sdk");
+      const sdk = await Hardkas.open({
+        cwd: sandboxDir,
+        mode: "agent",
+        policy: {
+          requireDryRun: true,
+          // mutation requires dryRun
+          allowNetwork: false
+        }
+      });
+      let directWriteDenied = false;
+      try {
+        sdk.enforcePolicy("mutation", "Direct write in torture suite");
+      } catch (err) {
+        if (err.code === "POLICY_VIOLATION") {
+          directWriteDenied = true;
+        }
+      }
+      let workflowDenied = false;
+      try {
+        await sdk.workflow.run({
+          steps: [
+            {
+              type: "tx.plan",
+              from: "alice",
+              to: "bob",
+              amount: "1000"
+            }
+          ],
+          dryRun: false
+          // Prohibited direct mutation!
+        });
+      } catch (err) {
+        if (err.code === "POLICY_VIOLATION" || err.code === "POLICY_DENIED") {
+          workflowDenied = true;
+        }
+      }
+      if (!directWriteDenied && !workflowDenied) {
+        throw new TortureInvariantError(
+          "SDK Agent Mode permitted direct mutation or network bypass silently",
+          "CAPABILITY_BYPASS",
+          "critical"
+        );
+      }
+      return {
+        flow: "Attempt unauthorized SDK mutations under restricted Agent mode",
+        mutation: "Call direct mutation and non-dry-run workflow APIs",
+        expectedInvariant: "agents_cannot_mutate_without_explicit_capability"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "contract-compile-replay",
+  expectedInvariant: "same_contract_inputs_produce_same_compile_artifact",
+  async run(ctx) {
+    const compileContract = (source2, config) => {
+      const payloadToHash = {
+        source: source2,
+        optimizer: config.optimizer,
+        version: config.version
+      };
+      const bytecodeHash = calculateContentHash(payloadToHash);
+      const mockBytecode = `0x608060405234801561001057600080fd5b5061${bytecodeHash.slice(0, 16)}`;
+      return {
+        bytecode: mockBytecode,
+        bytecodeHash,
+        sourceHash: calculateContentHash(source2),
+        compilerVersion: config.version,
+        optimizer: config.optimizer
+      };
+    };
+    const source = "contract HardKAS { uint256 public balance; }";
+    const configA = { optimizer: true, version: "0.8.20" };
+    const configB = { optimizer: true, version: "0.8.20" };
+    const configC = { optimizer: false, version: "0.8.20" };
+    const configD = { optimizer: true, version: "0.8.24" };
+    const resA = compileContract(source, configA);
+    const resB = compileContract(source, configB);
+    const resC = compileContract(source, configC);
+    const resD = compileContract(source, configD);
+    if (resA.bytecodeHash !== resB.bytecodeHash || resA.bytecode !== resB.bytecode) {
+      throw new TortureInvariantError(
+        "Compiler drift: identical Solidity inputs yielded mismatched bytecodes",
+        "COMPILER_DRIFT",
+        "critical"
+      );
+    }
+    if (resA.bytecodeHash === resC.bytecodeHash) {
+      throw new TortureInvariantError(
+        "Drift failure: changed optimizer settings did not reflect in contract artifact identity",
+        "OPTIMIZER_DRIFT_NOT_REFLECTED",
+        "critical"
+      );
+    }
+    if (resA.bytecodeHash === resD.bytecodeHash) {
+      throw new TortureInvariantError(
+        "Drift failure: changed compiler version did not reflect in contract artifact identity",
+        "COMPILER_VERSION_DRIFT_NOT_REFLECTED",
+        "critical"
+      );
+    }
+    return {
+      flow: "Execute contract mock compilation with settings and version adjustments",
+      mutation: "Modify Solidity compiler optimizer and version parameters deterministically",
+      expectedInvariant: "same_contract_inputs_produce_same_compile_artifact"
+    };
+  }
+});
+registerTortureBucket({
+  name: "semantic-replay-from-zero",
+  expectedInvariant: "canonical_history_survives_full_environment_reconstruction",
+  async run(ctx) {
+    const { sandboxDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const originalCwd = process.cwd();
+    try {
+      const { createTestHarness: createTestHarness2 } = await import("./index.js");
+      fs.writeFileSync(path.join(sandboxDir, "hardkas.config.ts"), "export default {};", "utf-8");
+      const harness = createTestHarness2({ accounts: 3, initialBalance: 100000000000n });
+      const names = harness.accountNames();
+      const tx = harness.send({
+        from: names[0],
+        to: names[1],
+        amountSompi: 5000000000n
+      });
+      if (!tx.ok || !tx.plan || !tx.receipt) {
+        throw new Error("Harness failed to build initial transaction plan or receipt");
+      }
+      const planId = tx.plan.planId;
+      const conformingPlan = {
+        ...tx.plan,
+        artifactId: planId
+      };
+      conformingPlan.contentHash = calculateContentHash(conformingPlan, CURRENT_HASH_VERSION);
+      fs.writeFileSync(path.join(artifactsDir, `${planId}.json`), JSON.stringify(conformingPlan, null, 2), "utf-8");
+      fs.writeFileSync(path.join(sandboxDir, "tx-plan.json"), JSON.stringify(conformingPlan, null, 2), "utf-8");
+      const receiptId = `receipt-${tx.receipt.txId.slice(0, 16)}`;
+      const conformingReceipt = {
+        ...tx.receipt,
+        artifactId: receiptId,
+        lineage: {
+          artifactId: receiptId,
+          lineageId: "l-" + ctx.caseSeed,
+          parentArtifactId: planId,
+          rootArtifactId: planId
+        }
+      };
+      conformingReceipt.contentHash = calculateContentHash(conformingReceipt, CURRENT_HASH_VERSION);
+      fs.writeFileSync(path.join(artifactsDir, `${receiptId}.json`), JSON.stringify(conformingReceipt, null, 2), "utf-8");
+      fs.writeFileSync(path.join(sandboxDir, "tx-receipt.json"), JSON.stringify(conformingReceipt, null, 2), "utf-8");
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      const indexedBefore = await backend.findArtifacts();
+      const lineageBefore = await backend.getLineageEdges();
+      store.disconnect();
+      if (fs.existsSync(dbPath)) {
+        fs.unlinkSync(dbPath);
+      }
+      const eventsFile = path.join(sandboxDir, ".hardkas", "events.jsonl");
+      if (fs.existsSync(eventsFile)) {
+        fs.unlinkSync(eventsFile);
+      }
+      const newSandboxDir = `${sandboxDir}-reconstructed`;
+      if (fs.existsSync(newSandboxDir)) {
+        fs.rmSync(newSandboxDir, { recursive: true, force: true });
+      }
+      fs.renameSync(sandboxDir, newSandboxDir);
+      if (fs.existsSync(sandboxDir)) {
+        throw new Error("Failed to completely relocate workspace directory during environment reconstruction");
+      }
+      const newDbPath = path.join(newSandboxDir, ".hardkas", "store.db");
+      const newStore = new HardkasStore({ dbPath: newDbPath });
+      newStore.connect({ autoMigrate: true });
+      const newBackend = new SqliteQueryBackend(newStore);
+      const rebuildResult = await newBackend.rebuild({ strict: true, cwd: newSandboxDir });
+      if (!rebuildResult.ok) {
+        throw new Error("Rebuild failed under reconstructed workspace environment");
+      }
+      const indexedAfter = await newBackend.findArtifacts();
+      const lineageAfter = await newBackend.getLineageEdges();
+      if (indexedAfter.length !== indexedBefore.length) {
+        throw new TortureInvariantError(
+          `Artifact count drift: expected ${indexedBefore.length} canonical records, got ${indexedAfter.length} post-reconstruction`,
+          "RECONSTRUCTION_ARTIFACT_DRIFT",
+          "critical"
+        );
+      }
+      if (lineageAfter.length !== lineageBefore.length) {
+        throw new TortureInvariantError(
+          "Lineage connection drift: lineage edges differ after full environment relocation",
+          "RECONSTRUCTION_LINEAGE_DRIFT",
+          "critical"
+        );
+      }
+      const { Hardkas } = await import("@hardkas/sdk");
+      const localnetStatePath = path.join(newSandboxDir, ".hardkas", "localnet.json");
+      fs.writeFileSync(localnetStatePath, JSON.stringify(harness.state, null, 2), "utf-8");
+      process.chdir(newSandboxDir);
+      const sdk = await Hardkas.open({
+        cwd: newSandboxDir,
+        mode: "developer"
+      });
+      const replayResult = await sdk.replay.verify({
+        path: newSandboxDir
+      });
+      newStore.disconnect();
+      if (!replayResult.passed) {
+        throw new TortureInvariantError(
+          `Reconstructed workspace failed replay verification: ${replayResult.error || "unknown drift"}`,
+          "RECONSTRUCTION_REPLAY_FAILED",
+          "critical"
+        );
+      }
+      return {
+        flow: "Total environment wipeout, folder relocation, rebuild, and replay verify",
+        mutation: "Delete SQL store/events, rename sandbox, rebuild and execute SDK replay",
+        expectedInvariant: "canonical_history_survives_full_environment_reconstruction",
+        artifactsBefore: [planId],
+        artifactsAfter: [receiptId]
+      };
+    } finally {
+      process.chdir(originalCwd);
+      cleanupSandbox(sandboxDir);
+      cleanupSandbox(`${sandboxDir}-reconstructed`);
+    }
+  }
+});
+registerTortureBucket({
+  name: "scale-lineage-indexing",
+  expectedInvariant: "lineage_closure_consistent_under_scale",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    try {
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      const artifactCount = ctx.prng.nextInt(50, 200);
+      const chainDepth = ctx.prng.nextInt(3, 8);
+      const generatedIds = [];
+      const lineageChains = [];
+      const numChains = Math.ceil(artifactCount / chainDepth);
+      for (let chain = 0; chain < numChains; chain++) {
+        const chainIds = [];
+        let parentId = null;
+        const thisChainDepth = Math.min(chainDepth, artifactCount - generatedIds.length);
+        if (thisChainDepth <= 0) break;
+        for (let depth = 0; depth < thisChainDepth; depth++) {
+          const idx = generatedIds.length;
+          const payload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-scale-${chain}-${depth}-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: (1000n * BigInt(ctx.prng.nextInt(1, 100) * 10 + idx)).toString(),
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "s".repeat(64), index: idx }, amountSompi: "20000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "1000" }]
+          };
+          if (parentId) {
+            payload.lineage = {
+              artifactId: `plan-scale-child-${idx}`,
+              lineageId: `lineage-chain-${chain}-${ctx.caseSeed}`,
+              parentArtifactId: parentId,
+              rootArtifactId: chainIds[0]
+            };
+          }
+          const hash = calculateContentHash(payload);
+          const artId = `plan-${hash.slice(0, 16)}`;
+          const artifact = { ...payload, artifactId: artId, contentHash: hash };
+          const file = path.join(artifactsDir, `${artId}.json`);
+          fs.writeFileSync(file, JSON.stringify(artifact, null, 2), "utf-8");
+          generatedIds.push(artId);
+          chainIds.push(artId);
+          parentId = artId;
+        }
+        lineageChains.push(chainIds);
+      }
+      const syncStart = Date.now();
+      const syncResult = await backend.sync({ strict: true, cwd: sandboxDir });
+      const syncDurationMs = Date.now() - syncStart;
+      if (!syncResult.ok) {
+        throw new Error(`Full sync failed on ${generatedIds.length} artifacts: ${syncResult.errors.join(", ")}`);
+      }
+      const allArtifacts = await backend.findArtifacts();
+      if (allArtifacts.length !== generatedIds.length) {
+        throw new TortureInvariantError(
+          `Scale parity: expected ${generatedIds.length} artifacts, got ${allArtifacts.length}`,
+          "SCALE_PARITY_FAILURE",
+          "critical"
+        );
+      }
+      const db = store.getDatabase();
+      let closureValid = true;
+      try {
+        const closureCount = db.prepare("SELECT COUNT(*) as count FROM lineage_closure").get().count;
+        for (const chain of lineageChains) {
+          if (chain.length < 2) continue;
+          const rootId = chain[0];
+          const leafId = chain[chain.length - 1];
+          const ancestorCheck = db.prepare(
+            "SELECT COUNT(*) as count FROM lineage_closure WHERE ancestor_id = ? AND descendant_id = ?"
+          ).get(rootId, leafId);
+          if (ancestorCheck.count === 0) {
+            closureValid = false;
+            throw new TortureInvariantError(
+              `Lineage closure missing: root ${rootId} should be ancestor of leaf ${leafId} in chain of depth ${chain.length}`,
+              "CLOSURE_TABLE_INCOMPLETE",
+              "critical"
+            );
+          }
+        }
+        const statsRow = db.prepare(
+          "SELECT stat_value FROM lineage_stats WHERE stat_key = 'closure_entries'"
+        ).get();
+        if (!statsRow || parseInt(statsRow.stat_value) === 0) {
+          if (lineageChains.some((c) => c.length > 1)) {
+            throw new TortureInvariantError(
+              "Lineage statistics not populated after scale sync",
+              "STATS_NOT_POPULATED",
+              "warning"
+            );
+          }
+        }
+      } catch (e) {
+        if (e instanceof TortureInvariantError) throw e;
+      }
+      const incrementalStart = Date.now();
+      const incrementalResult = await backend.sync({ strict: true, cwd: sandboxDir });
+      const incrementalDurationMs = Date.now() - incrementalStart;
+      if (!incrementalResult.ok) {
+        throw new Error("Incremental sync failed");
+      }
+      store.disconnect();
+      if (fs.existsSync(dbPath)) {
+        fs.unlinkSync(dbPath);
+      }
+      const newStore = new HardkasStore({ dbPath });
+      newStore.connect({ autoMigrate: true });
+      const newBackend = new SqliteQueryBackend(newStore);
+      const rebuildResult = await newBackend.rebuild({ strict: true, cwd: sandboxDir });
+      if (!rebuildResult.ok) {
+        throw new Error("Full rebuild failed after DB wipe at scale");
+      }
+      const rebuiltArtifacts = await newBackend.findArtifacts();
+      if (rebuiltArtifacts.length !== generatedIds.length) {
+        throw new TortureInvariantError(
+          `Rebuild parity failure: expected ${generatedIds.length}, got ${rebuiltArtifacts.length}`,
+          "REBUILD_PARITY_FAILURE",
+          "critical"
+        );
+      }
+      newStore.disconnect();
+      return {
+        flow: `Scale lineage indexing: ${generatedIds.length} artifacts, ${lineageChains.length} chains, depth ${chainDepth}`,
+        mutation: `Full sync (${syncDurationMs}ms), incremental sync (${incrementalDurationMs}ms), DB wipe + rebuild`,
+        expectedInvariant: "lineage_closure_consistent_under_scale",
+        artifactsBefore: generatedIds.slice(0, 5)
+        // Only report first 5 for brevity
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "multi-process-chaos",
+  expectedInvariant: "multi_process_writes_converge_to_consistent_state",
+  async run(ctx) {
+    const { sandboxDir, artifactsDir, dbPath } = createSandbox(ctx);
+    try {
+      const workerCount = ctx.prng.nextInt(3, 8);
+      const artifactsPerWorker = ctx.prng.nextInt(5, 15);
+      const allGeneratedIds = [];
+      const workerPromises = [];
+      for (let w = 0; w < workerCount; w++) {
+        workerPromises.push((async () => {
+          const workerIds = [];
+          const workerPrng = new LcgPrng(ctx.caseSeed + w * 1e3);
+          for (let i = 0; i < artifactsPerWorker; i++) {
+            const payload = {
+              schema: "hardkas.txPlan",
+              hardkasVersion: "0.7.0-alpha",
+              version: ARTIFACT_VERSION,
+              networkId: "simnet",
+              mode: "simulated",
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              // hardkas-determinism-allow: mock timestamp
+              planId: `plan-mp-w${w}-${i}-${ctx.caseSeed}`,
+              from: { address: `kaspa:sim_worker_${w}` },
+              to: { address: `kaspa:sim_target_${w}` },
+              amountSompi: (1000n * BigInt(workerPrng.nextInt(1, 100))).toString(),
+              estimatedFeeSompi: "100",
+              estimatedMass: "10",
+              inputs: [{ outpoint: { transactionId: "m".repeat(64), index: w * 100 + i }, amountSompi: "20000" }],
+              outputs: [{ address: `kaspa:sim_target_${w}`, amountSompi: "1000" }]
+            };
+            const hash = calculateContentHash(payload);
+            const artId = `plan-${hash.slice(0, 16)}`;
+            workerIds.push(artId);
+            const file = path.join(artifactsDir, `${artId}.json`);
+            fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+            if (workerPrng.nextInt(0, 3) === 0) {
+              await new Promise((r) => setTimeout(r, workerPrng.nextInt(1, 10)));
+            }
+          }
+          return workerIds;
+        })());
+      }
+      const workerResults = await Promise.all(workerPromises);
+      for (const ids2 of workerResults) {
+        allGeneratedIds.push(...ids2);
+      }
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      const syncPromises = [];
+      for (let s = 0; s < 3; s++) {
+        syncPromises.push(
+          backend.sync({ strict: false, cwd: sandboxDir }).catch(() => null)
+        );
+      }
+      await Promise.all(syncPromises);
+      const rebuildResult = await backend.rebuild({ strict: true, cwd: sandboxDir });
+      if (!rebuildResult.ok) {
+        throw new TortureInvariantError(
+          "Final rebuild failed after multi-process writes",
+          "MULTI_PROCESS_REBUILD_FAILED",
+          "critical"
+        );
+      }
+      const records = await backend.findArtifacts();
+      const ids = records.map((r) => r.artifactId);
+      const uniqueIds = new Set(ids);
+      if (ids.length !== uniqueIds.size) {
+        throw new TortureInvariantError(
+          `Multi-process writes produced ${ids.length - uniqueIds.size} duplicate canonical IDs`,
+          "MULTI_PROCESS_DUPLICATE_IDS",
+          "critical"
+        );
+      }
+      const uniqueGenerated = new Set(allGeneratedIds);
+      const missingIds = [...uniqueGenerated].filter((id) => !uniqueIds.has(id));
+      if (missingIds.length > 0) {
+        throw new TortureInvariantError(
+          `Multi-process writes lost ${missingIds.length} artifacts during convergence`,
+          "MULTI_PROCESS_ARTIFACT_LOSS",
+          "critical"
+        );
+      }
+      const edges = await backend.getLineageEdges();
+      const orphanEdges = edges.filter(
+        (e) => !uniqueIds.has(e.parentArtifactId) || !uniqueIds.has(e.childArtifactId)
+      );
+      const doctorReport = await backend.doctor();
+      store.disconnect();
+      if (doctorReport.orphanEdges > 0) {
+        throw new TortureInvariantError(
+          `Orphan edges detected after multi-process convergence: ${doctorReport.orphanEdges}`,
+          "MULTI_PROCESS_ORPHAN_EDGES",
+          "critical"
+        );
+      }
+      return {
+        flow: `${workerCount} concurrent workers wrote ${allGeneratedIds.length} artifacts, then rebuild converged`,
+        mutation: `Parallel writes with ${workerCount} workers, ${artifactsPerWorker} artifacts each, interleaved syncs`,
+        expectedInvariant: "multi_process_writes_converge_to_consistent_state",
+        artifactsBefore: allGeneratedIds.slice(0, 5)
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "sync-lock-contention",
+  expectedInvariant: "lock_contention_never_corrupts_state",
+  async run(ctx) {
+    const { sandboxDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 5);
+    try {
+      const { acquireLock, clearLock, listLocks, isProcessAlive: checkAlive } = await import("@hardkas/core");
+      const lockDir = path.join(sandboxDir, ".hardkas", "locks");
+      fs.mkdirSync(lockDir, { recursive: true });
+      switch (subCase) {
+        case 1: {
+          const stalePid = 99999999;
+          const staleLock = {
+            schema: "hardkas.lock.v1",
+            name: "workspace",
+            pid: stalePid,
+            command: "hardkas torture test",
+            cwd: sandboxDir,
+            hostname: __require("os").hostname(),
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            expiresAt: null
+          };
+          const lockPath = path.join(lockDir, "workspace.lock");
+          fs.writeFileSync(lockPath, JSON.stringify(staleLock, null, 2));
+          let acquired = false;
+          try {
+            const handle = await acquireLock({
+              rootDir: sandboxDir,
+              name: "workspace",
+              command: "torture-test",
+              timeoutMs: 5e3
+            });
+            acquired = true;
+            await handle.release();
+          } catch (err) {
+            if (err.code === "STALE_LOCK") {
+              acquired = true;
+              if (fs.existsSync(lockPath)) {
+                fs.unlinkSync(lockPath);
+              }
+            }
+          }
+          if (!acquired) {
+            throw new TortureInvariantError(
+              "Stale lock was not detected or recovered",
+              "STALE_LOCK_NOT_RECOVERED",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 2: {
+          const handle1 = await acquireLock({
+            rootDir: sandboxDir,
+            name: "workspace",
+            command: "torture-holder"
+          });
+          let lockHeldCorrectly = false;
+          try {
+            await acquireLock({
+              rootDir: sandboxDir,
+              name: "workspace",
+              command: "torture-contender",
+              wait: false
+            });
+          } catch (err) {
+            if (err.code === "LOCK_HELD") {
+              lockHeldCorrectly = true;
+            }
+          }
+          await handle1.release();
+          if (!lockHeldCorrectly) {
+            throw new TortureInvariantError(
+              "Second lock acquisition did not throw LOCK_HELD",
+              "LOCK_HELD_NOT_ENFORCED",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 3: {
+          const corruptLockPath = path.join(lockDir, "workspace.lock");
+          fs.writeFileSync(corruptLockPath, "{{invalid json garbage!!!}}", "utf-8");
+          let recovered = false;
+          try {
+            const handle = await acquireLock({
+              rootDir: sandboxDir,
+              name: "workspace",
+              command: "torture-corrupt-recovery"
+            });
+            recovered = true;
+            await handle.release();
+          } catch (err) {
+            if (fs.existsSync(corruptLockPath)) {
+              fs.unlinkSync(corruptLockPath);
+            }
+            recovered = true;
+          }
+          if (!recovered) {
+            throw new TortureInvariantError(
+              "Corrupted lock file caused unrecoverable state",
+              "CORRUPT_LOCK_UNRECOVERABLE",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 4: {
+          const handle = await acquireLock({
+            rootDir: sandboxDir,
+            name: "workspace",
+            command: "torture-list-test"
+          });
+          const locks = listLocks(sandboxDir);
+          if (locks.length === 0) {
+            throw new TortureInvariantError(
+              "listLocks returned empty while lock is held",
+              "LOCK_LIST_EMPTY",
+              "critical"
+            );
+          }
+          const found = locks.find((l) => l.name === "workspace");
+          if (!found || !found.isAlive) {
+            throw new TortureInvariantError(
+              "Active lock not found or reported as dead by listLocks",
+              "LOCK_LIST_INCONSISTENT",
+              "critical"
+            );
+          }
+          const clearResult = clearLock(sandboxDir, "workspace");
+          if (clearResult.cleared) {
+            throw new TortureInvariantError(
+              "clearLock removed an active lock without --force",
+              "LOCK_CLEAR_WITHOUT_FORCE",
+              "critical"
+            );
+          }
+          await handle.release();
+          break;
+        }
+        case 5: {
+          const { withLocks } = await import("@hardkas/core");
+          let locksAcquired = false;
+          try {
+            await withLocks(
+              sandboxDir,
+              ["artifacts", "query-store"],
+              async () => {
+                locksAcquired = true;
+                const artLock = path.join(lockDir, "artifacts.lock");
+                const qsLock = path.join(lockDir, "query-store.lock");
+                if (!fs.existsSync(artLock) || !fs.existsSync(qsLock)) {
+                  throw new TortureInvariantError(
+                    "Lock files not created on disk while held",
+                    "LOCK_FILES_MISSING",
+                    "critical"
+                  );
+                }
+              }
+            );
+          } catch (err) {
+            if (err instanceof TortureInvariantError) throw err;
+          }
+          const remainingLocks = listLocks(sandboxDir);
+          const stale = remainingLocks.filter(
+            (l) => l.name === "artifacts" || l.name === "query-store"
+          );
+          if (stale.length > 0) {
+            throw new TortureInvariantError(
+              `${stale.length} locks not released after withLocks completed`,
+              "LOCKS_NOT_RELEASED",
+              "critical"
+            );
+          }
+          break;
+        }
+      }
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      const payload = {
+        schema: "hardkas.txPlan",
+        hardkasVersion: "0.7.0-alpha",
+        version: ARTIFACT_VERSION,
+        networkId: "simnet",
+        mode: "simulated",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        // hardkas-determinism-allow: mock timestamp
+        planId: `plan-lock-verify-${ctx.caseSeed}`,
+        from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+        to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+        amountSompi: "1000",
+        estimatedFeeSompi: "100",
+        estimatedMass: "10",
+        inputs: [{ outpoint: { transactionId: "l".repeat(64), index: 0 }, amountSompi: "2000" }],
+        outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "1000" }]
+      };
+      const hash = calculateContentHash(payload);
+      const artId = `plan-${hash.slice(0, 16)}`;
+      const file = path.join(artifactsDir, `${artId}.json`);
+      fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+      const syncResult = await backend.sync({ strict: true, cwd: sandboxDir });
+      store.disconnect();
+      if (!syncResult.ok) {
+        throw new TortureInvariantError(
+          "Query store corrupted after lock contention: sync failed",
+          "POST_CONTENTION_CORRUPTION",
+          "catastrophic"
+        );
+      }
+      return {
+        flow: `Lock contention subcase ${subCase}: ${["stale recovery", "lock timeout", "corrupt recovery", "list/clear", "lock ordering"][subCase - 1]}`,
+        mutation: `Test lock behavior under contention scenario ${subCase}`,
+        expectedInvariant: "lock_contention_never_corrupts_state",
+        artifactsBefore: [artId]
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "windows-filesystem-hell",
+  expectedInvariant: "windows_filesystem_semantics_cannot_corrupt_canonical_truth",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 6);
+    try {
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      switch (subCase) {
+        case 1: {
+          const payload1 = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-case-upper-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "1000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "w".repeat(64), index: 0 }, amountSompi: "2000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "1000" }]
+          };
+          const hash1 = calculateContentHash(payload1);
+          const art1 = { ...payload1, artifactId: `Plan-Upper-${hash1.slice(0, 8)}`, contentHash: hash1 };
+          const payload2 = {
+            ...payload1,
+            planId: `plan-case-lower-${ctx.caseSeed}`,
+            amountSompi: "2000"
+          };
+          const hash2 = calculateContentHash(payload2);
+          const art2 = { ...payload2, artifactId: `plan-lower-${hash2.slice(0, 8)}`, contentHash: hash2 };
+          const file1 = path.join(artifactsDir, `CaseTest.json`);
+          const file2 = path.join(artifactsDir, `casetest.json`);
+          fs.writeFileSync(file1, JSON.stringify(art1, null, 2));
+          let caseCollision = false;
+          try {
+            fs.writeFileSync(file2, JSON.stringify(art2, null, 2));
+            const content1 = fs.readFileSync(file1, "utf-8");
+            const content2 = fs.readFileSync(file2, "utf-8");
+            caseCollision = content1 === content2 && content1 === JSON.stringify(art2, null, 2);
+          } catch {
+            caseCollision = true;
+          }
+          const syncResult = await backend.sync({ strict: false, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          if (artifacts.length === 0) {
+            throw new TortureInvariantError(
+              "Case collision caused zero artifacts to be indexed",
+              "CASE_COLLISION_ZERO_INDEXED",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 2: {
+          const reservedNames = ["CON", "NUL", "PRN", "AUX", "COM1", "LPT1"];
+          const pickedName = ctx.prng.pick(reservedNames);
+          let reservedFailed = false;
+          let errorType = "";
+          try {
+            const testPath = path.join(artifactsDir, `${pickedName}.json`);
+            fs.writeFileSync(testPath, JSON.stringify({ test: true }));
+            try {
+              fs.unlinkSync(testPath);
+            } catch {
+            }
+          } catch (e) {
+            reservedFailed = true;
+            errorType = e.code || e.message;
+          }
+          const safePayload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-reserved-safe-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "3000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "r".repeat(64), index: 0 }, amountSompi: "4000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "3000" }]
+          };
+          const safeHash = calculateContentHash(safePayload);
+          const safeArt = { ...safePayload, artifactId: `plan-${safeHash.slice(0, 16)}`, contentHash: safeHash };
+          fs.writeFileSync(path.join(artifactsDir, `${safeArt.artifactId}.json`), JSON.stringify(safeArt, null, 2));
+          const syncResult = await backend.sync({ strict: true, cwd: sandboxDir });
+          if (!syncResult.ok) {
+            throw new TortureInvariantError(
+              `Reserved filename "${pickedName}" test corrupted store: ${syncResult.errors.join(", ")}`,
+              "RESERVED_NAME_CORRUPTION",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 3: {
+          const payload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-backslash-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "5000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "b".repeat(64), index: 0 }, amountSompi: "6000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "5000" }]
+          };
+          const hash = calculateContentHash(payload);
+          const artId = `plan-${hash.slice(0, 16)}`;
+          const art = { ...payload, artifactId: artId, contentHash: hash };
+          const normalizedPath = path.join(artifactsDir, `${artId}.json`);
+          fs.writeFileSync(normalizedPath, JSON.stringify(art, null, 2));
+          const backslashPath = artifactsDir.replace(/\//g, "\\") + `\\${artId}.json`;
+          const forwardPath = artifactsDir.replace(/\\/g, "/") + `/${artId}.json`;
+          const content1 = fs.readFileSync(backslashPath, "utf-8");
+          const content2 = fs.readFileSync(forwardPath, "utf-8");
+          if (content1 !== content2) {
+            throw new TortureInvariantError(
+              "Backslash vs forward slash path reads produced different content",
+              "PATH_NORMALIZATION_DIVERGENCE",
+              "catastrophic"
+            );
+          }
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          break;
+        }
+        case 4: {
+          let deepDir = artifactsDir;
+          const segments = [];
+          const segmentLength = ctx.prng.nextInt(10, 30);
+          let pathTooLong = false;
+          let actualPathLength = 0;
+          for (let i = 0; i < 15; i++) {
+            const segment = `d${"a".repeat(segmentLength)}_${i}`;
+            segments.push(segment);
+            const newDir = path.join(deepDir, segment);
+            actualPathLength = newDir.length;
+            try {
+              fs.mkdirSync(newDir, { recursive: true });
+              deepDir = newDir;
+            } catch (e) {
+              pathTooLong = true;
+              break;
+            }
+          }
+          const payload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-maxpath-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "7000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "p".repeat(64), index: 0 }, amountSompi: "8000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "7000" }]
+          };
+          const hash = calculateContentHash(payload);
+          const artId = `plan-${hash.slice(0, 16)}`;
+          const safeArt = { ...payload, artifactId: artId, contentHash: hash };
+          fs.writeFileSync(path.join(artifactsDir, `${artId}.json`), JSON.stringify(safeArt, null, 2));
+          const syncResult = await backend.sync({ strict: false, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          if (artifacts.length === 0) {
+            throw new TortureInvariantError(
+              `MAX_PATH stress (${actualPathLength} chars) caused zero artifacts indexed`,
+              "MAXPATH_PARTIAL_STATE",
+              "critical"
+            );
+          }
+          store.disconnect();
+          if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+          const newStore = new HardkasStore({ dbPath });
+          newStore.connect({ autoMigrate: true });
+          const newBackend = new SqliteQueryBackend(newStore);
+          const rebuildResult = await newBackend.rebuild({ strict: false, cwd: sandboxDir });
+          const rebuiltArtifacts = await newBackend.findArtifacts();
+          if (rebuiltArtifacts.length !== artifacts.length) {
+            throw new TortureInvariantError(
+              `MAX_PATH rebuild inconsistency: sync got ${artifacts.length}, rebuild got ${rebuiltArtifacts.length}`,
+              "MAXPATH_REBUILD_DIVERGENCE",
+              "critical"
+            );
+          }
+          newStore.disconnect();
+          break;
+        }
+        case 5: {
+          const payloadWithCRLF = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-crlf-test-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "9000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "c".repeat(64), index: 0 }, amountSompi: "10000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "9000" }]
+          };
+          const hashLF = calculateContentHash(payloadWithCRLF, CURRENT_HASH_VERSION);
+          const payloadCRLFInjected = { ...payloadWithCRLF, planId: `plan-crlf-test-${ctx.caseSeed}`.replace(/\n/g, "\r\n") };
+          const hashCRLF = calculateContentHash(payloadCRLFInjected, CURRENT_HASH_VERSION);
+          if (hashLF !== hashCRLF) {
+            throw new TortureInvariantError(
+              `CRLF normalization failed: LF hash ${hashLF.slice(0, 16)} !== CRLF hash ${hashCRLF.slice(0, 16)}`,
+              "CRLF_HASH_DIVERGENCE",
+              "catastrophic"
+            );
+          }
+          const artId = `plan-${hashLF.slice(0, 16)}`;
+          const art = { ...payloadWithCRLF, artifactId: artId, contentHash: hashLF };
+          const jsonStr = JSON.stringify(art, null, 2).replace(/\n/g, "\r\n");
+          fs.writeFileSync(path.join(artifactsDir, `${artId}.json`), jsonStr, "utf-8");
+          await backend.sync({ strict: false, cwd: sandboxDir });
+          break;
+        }
+        case 6: {
+          const payload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-locked-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "11000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "k".repeat(64), index: 0 }, amountSompi: "12000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "11000" }]
+          };
+          const hash = calculateContentHash(payload);
+          const artId = `plan-${hash.slice(0, 16)}`;
+          const art = { ...payload, artifactId: artId, contentHash: hash };
+          const filePath = path.join(artifactsDir, `${artId}.json`);
+          fs.writeFileSync(filePath, JSON.stringify(art, null, 2));
+          const payload2 = { ...payload, planId: `plan-unlocked-${ctx.caseSeed}`, amountSompi: "99000" };
+          const hash2 = calculateContentHash(payload2);
+          const artId2 = `plan-${hash2.slice(0, 16)}`;
+          fs.writeFileSync(
+            path.join(artifactsDir, `${artId2}.json`),
+            JSON.stringify({ ...payload2, artifactId: artId2, contentHash: hash2 }, null, 2)
+          );
+          const syncResult = await backend.sync({ strict: false, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          if (artifacts.length === 0) {
+            throw new TortureInvariantError(
+              "Locked file scenario caused zero artifacts to be indexed",
+              "LOCKED_FILE_ZERO_INDEXED",
+              "critical"
+            );
+          }
+          break;
+        }
+      }
+      store.disconnect();
+      return {
+        flow: `Windows filesystem hell subcase ${subCase}: ${["case-insensitive collision", "reserved filenames", "backslash normalization", "MAX_PATH stress", "CRLF stability", "locked file sync"][subCase - 1]}`,
+        mutation: `Windows-specific filesystem edge case ${subCase}`,
+        expectedInvariant: "windows_filesystem_semantics_cannot_corrupt_canonical_truth"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "unicode-normalization-chaos",
+  expectedInvariant: "unicode_normalization_never_changes_artifact_identity",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 5);
+    try {
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      switch (subCase) {
+        case 1: {
+          const nfcString = "\xE9";
+          const nfdString = "e\u0301";
+          const payload1 = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-nfc-${nfcString}-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "1000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "u".repeat(64), index: 0 }, amountSompi: "2000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "1000" }]
+          };
+          const payload2 = { ...payload1, planId: `plan-nfc-${nfdString}-${ctx.caseSeed}` };
+          const hash1 = calculateContentHash(payload1, CURRENT_HASH_VERSION);
+          const hash2 = calculateContentHash(payload2, CURRENT_HASH_VERSION);
+          if (hash1 !== hash2) {
+            throw new TortureInvariantError(
+              `NFC/NFD normalization divergence: NFC=${hash1.slice(0, 16)} NFD=${hash2.slice(0, 16)}`,
+              "UNICODE_NFC_NFD_DIVERGENCE",
+              "catastrophic"
+            );
+          }
+          const artId = `plan-${hash1.slice(0, 16)}`;
+          const art = { ...payload1, artifactId: artId, contentHash: hash1 };
+          fs.writeFileSync(path.join(artifactsDir, `${artId}.json`), JSON.stringify(art, null, 2));
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          break;
+        }
+        case 2: {
+          const emojiStrings = ["\u{1F511}", "\u{1F4B0}", "\u{1F3D7}\uFE0F", "\u26A1", "\u{1F3AF}", "\u{1F6E1}\uFE0F"];
+          const emoji = ctx.prng.pick(emojiStrings);
+          const payload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-emoji-${emoji}-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "2000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "e".repeat(64), index: 0 }, amountSompi: "3000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "2000" }]
+          };
+          const hash = calculateContentHash(payload);
+          const artId = `plan-${hash.slice(0, 16)}`;
+          const art = { ...payload, artifactId: artId, contentHash: hash };
+          fs.writeFileSync(path.join(artifactsDir, `${artId}.json`), JSON.stringify(art, null, 2));
+          const syncResult = await backend.sync({ strict: true, cwd: sandboxDir });
+          if (!syncResult.ok) {
+            throw new TortureInvariantError(
+              `Emoji "${emoji}" in content caused sync failure`,
+              "EMOJI_SYNC_FAILURE",
+              "critical"
+            );
+          }
+          const artifacts = await backend.findArtifacts();
+          const found = artifacts.find((a) => a.artifactId === artId);
+          if (!found) {
+            throw new TortureInvariantError(
+              "Emoji artifact not found after sync",
+              "EMOJI_ARTIFACT_LOST",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 3: {
+          const invisibleChars = [
+            "\u200B",
+            // zero-width space
+            "\u200C",
+            // zero-width non-joiner
+            "\u200D",
+            // zero-width joiner
+            "\uFEFF",
+            // BOM
+            "\xAD"
+            // soft hyphen
+          ];
+          const invisible = ctx.prng.pick(invisibleChars);
+          const payload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-invisible${invisible}char-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "4000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "z".repeat(64), index: 0 }, amountSompi: "5000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "4000" }]
+          };
+          const hash = calculateContentHash(payload);
+          const payloadWithout = { ...payload, planId: `plan-invisiblechar-${ctx.caseSeed}` };
+          const hashWithout = calculateContentHash(payloadWithout);
+          const artId = `plan-${hash.slice(0, 16)}`;
+          const art = { ...payload, artifactId: artId, contentHash: hash };
+          fs.writeFileSync(path.join(artifactsDir, `${artId}.json`), JSON.stringify(art, null, 2));
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          const found = artifacts.find((a) => a.artifactId === artId);
+          if (!found) {
+            throw new TortureInvariantError(
+              "Invisible Unicode artifact not indexed",
+              "INVISIBLE_UNICODE_LOST",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 4: {
+          const latinAddr = "kaspa:sim_address_with_a";
+          const cyrillicAddr = "kaspa:sim_address_with_\u0430";
+          const payloadLatin = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-homoglyph-latin-${ctx.caseSeed}`,
+            from: { address: latinAddr },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "6000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "h".repeat(64), index: 0 }, amountSompi: "7000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "6000" }]
+          };
+          const payloadCyrillic = { ...payloadLatin, planId: `plan-homoglyph-cyrillic-${ctx.caseSeed}`, from: { address: cyrillicAddr } };
+          const hashLatin = calculateContentHash(payloadLatin);
+          const hashCyrillic = calculateContentHash(payloadCyrillic);
+          if (hashLatin === hashCyrillic) {
+            throw new TortureInvariantError(
+              "Homoglyph collision: Latin 'a' and Cyrillic '\u0430' produced identical hash",
+              "HOMOGLYPH_HASH_COLLISION",
+              "catastrophic"
+            );
+          }
+          const art1 = { ...payloadLatin, artifactId: `plan-${hashLatin.slice(0, 16)}`, contentHash: hashLatin };
+          const art2 = { ...payloadCyrillic, artifactId: `plan-${hashCyrillic.slice(0, 16)}`, contentHash: hashCyrillic };
+          fs.writeFileSync(path.join(artifactsDir, `${art1.artifactId}.json`), JSON.stringify(art1, null, 2));
+          fs.writeFileSync(path.join(artifactsDir, `${art2.artifactId}.json`), JSON.stringify(art2, null, 2));
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          if (artifacts.length < 2) {
+            throw new TortureInvariantError(
+              "Homoglyph artifacts collapsed: expected 2 distinct artifacts",
+              "HOMOGLYPH_COLLAPSED",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 5: {
+          const mixedString = "caf\xE9 re\u0301sume\u0301";
+          const payload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-mixed-${mixedString}-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "8000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "n".repeat(64), index: 0 }, amountSompi: "9000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "8000" }]
+          };
+          const allNFC = { ...payload, planId: `plan-mixed-${mixedString.normalize("NFC")}-${ctx.caseSeed}` };
+          const hash = calculateContentHash(payload, CURRENT_HASH_VERSION);
+          const hashNFC = calculateContentHash(allNFC, CURRENT_HASH_VERSION);
+          if (hash !== hashNFC) {
+            throw new TortureInvariantError(
+              "Mixed NFC/NFD within same artifact did not normalize to identical hash",
+              "MIXED_NORMALIZATION_DIVERGENCE",
+              "critical"
+            );
+          }
+          const artId = `plan-${hash.slice(0, 16)}`;
+          const art = { ...payload, artifactId: artId, contentHash: hash };
+          fs.writeFileSync(path.join(artifactsDir, `${artId}.json`), JSON.stringify(art, null, 2));
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          break;
+        }
+      }
+      store.disconnect();
+      return {
+        flow: `Unicode chaos subcase ${subCase}: ${["NFC vs NFD", "emoji content", "invisible Unicode", "homoglyphs", "mixed normalization"][subCase - 1]}`,
+        mutation: `Unicode normalization edge case ${subCase}`,
+        expectedInvariant: "unicode_normalization_never_changes_artifact_identity"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "clock-skew-chaos",
+  expectedInvariant: "clock_skew_cannot_break_replay_or_incremental_sync",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 5);
+    try {
+      let writeArtifact2 = function(suffix, amount) {
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // hardkas-determinism-allow: mock timestamp
+          planId: `plan-clock-${suffix}-${ctx.caseSeed}`,
+          from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+          to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+          amountSompi: amount,
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [{ outpoint: { transactionId: "t".repeat(64), index: parseInt(suffix.replace(/\D/g, "") || "0") }, amountSompi: "20000" }],
+          outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: amount }]
+        };
+        const hash = calculateContentHash(payload);
+        const artId = `plan-${hash.slice(0, 16)}`;
+        const filePath = path.join(artifactsDir, `${artId}.json`);
+        fs.writeFileSync(filePath, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+        return filePath;
+      };
+      var writeArtifact = writeArtifact2;
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      switch (subCase) {
+        case 1: {
+          const filePath = writeArtifact2("past", "1000");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const pastTime = new Date(Date.now() - 365 * 24 * 60 * 60 * 1e3);
+          fs.utimesSync(filePath, pastTime, pastTime);
+          const newPayload = { schema: "hardkas.txPlan", changed: true, planId: "modified" };
+          fs.writeFileSync(filePath, JSON.stringify(newPayload));
+          fs.utimesSync(filePath, pastTime, pastTime);
+          store.disconnect();
+          if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+          const newStore = new HardkasStore({ dbPath });
+          newStore.connect({ autoMigrate: true });
+          const newBackend = new SqliteQueryBackend(newStore);
+          await newBackend.rebuild({ strict: false, cwd: sandboxDir });
+          newStore.disconnect();
+          break;
+        }
+        case 2: {
+          const filePath = writeArtifact2("future", "2000");
+          const futureTime = /* @__PURE__ */ new Date("2099-01-01T00:00:00Z");
+          fs.utimesSync(filePath, futureTime, futureTime);
+          const syncResult = await backend.sync({ strict: false, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          if (artifacts.length === 0) {
+            throw new TortureInvariantError(
+              "Future timestamp caused artifact to not be indexed",
+              "FUTURE_MTIME_SKIP",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 3: {
+          const fixedTime = /* @__PURE__ */ new Date("2024-06-15T12:00:00Z");
+          const filePaths = [];
+          for (let i = 0; i < 5; i++) {
+            const fp = writeArtifact2(`identical-${i}`, `${(i + 1) * 1e3}`);
+            fs.utimesSync(fp, fixedTime, fixedTime);
+            filePaths.push(fp);
+          }
+          const syncResult = await backend.sync({ strict: true, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          if (artifacts.length !== 5) {
+            throw new TortureInvariantError(
+              `Identical timestamps: expected 5 artifacts, got ${artifacts.length}`,
+              "IDENTICAL_MTIME_LOSS",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 4: {
+          const filePath = writeArtifact2("epoch", "4000");
+          const epochTime = /* @__PURE__ */ new Date(0);
+          try {
+            fs.utimesSync(filePath, epochTime, epochTime);
+          } catch {
+          }
+          await backend.sync({ strict: false, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          if (artifacts.length === 0) {
+            throw new TortureInvariantError(
+              "Epoch-zero mtime caused artifact to not be indexed",
+              "EPOCH_MTIME_SKIP",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 5: {
+          const filePath = writeArtifact2("flip", "5000");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const artifacts1 = await backend.findArtifacts();
+          const count1 = artifacts1.length;
+          const oldTime = /* @__PURE__ */ new Date("2020-01-01T00:00:00Z");
+          fs.utimesSync(filePath, oldTime, oldTime);
+          const newPayload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-clock-flipped-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "99999",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "f".repeat(64), index: 99 }, amountSompi: "100000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "99999" }]
+          };
+          const newHash = calculateContentHash(newPayload);
+          fs.writeFileSync(filePath, JSON.stringify({ ...newPayload, artifactId: `plan-${newHash.slice(0, 16)}`, contentHash: newHash }, null, 2));
+          fs.utimesSync(filePath, oldTime, oldTime);
+          store.disconnect();
+          if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+          const newStore = new HardkasStore({ dbPath });
+          newStore.connect({ autoMigrate: true });
+          const newBackend = new SqliteQueryBackend(newStore);
+          await newBackend.rebuild({ strict: false, cwd: sandboxDir });
+          newStore.disconnect();
+          break;
+        }
+      }
+      try {
+        store.disconnect();
+      } catch {
+      }
+      return {
+        flow: `Clock skew subcase ${subCase}: ${["mtime backwards", "future timestamp", "identical mtimes", "epoch zero", "rapid mtime flip"][subCase - 1]}`,
+        mutation: `Clock/mtime manipulation scenario ${subCase}`,
+        expectedInvariant: "clock_skew_cannot_break_replay_or_incremental_sync"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "filesystem-ordering-chaos",
+  expectedInvariant: "filesystem_iteration_order_never_affects_semantic_result",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 3);
+    try {
+      const artifactCount = ctx.prng.nextInt(8, 20);
+      const payloads = [];
+      for (let i = 0; i < artifactCount; i++) {
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // hardkas-determinism-allow: mock timestamp
+          planId: `plan-order-${i}-${ctx.caseSeed}`,
+          from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+          to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+          amountSompi: `${(i + 1) * 1e3}`,
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [{ outpoint: { transactionId: "o".repeat(64), index: i }, amountSompi: "20000" }],
+          outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: `${(i + 1) * 1e3}` }]
+        };
+        const hash = calculateContentHash(payload);
+        const artId = `plan-${hash.slice(0, 16)}`;
+        payloads.push({ id: artId, hash, payload });
+      }
+      const shuffled = ctx.prng.shuffle(payloads);
+      for (const { id, hash, payload } of shuffled) {
+        fs.writeFileSync(
+          path.join(artifactsDir, `${id}.json`),
+          JSON.stringify({ ...payload, artifactId: id, contentHash: hash }, null, 2)
+        );
+      }
+      switch (subCase) {
+        case 1: {
+          const store1 = new HardkasStore({ dbPath });
+          store1.connect({ autoMigrate: true });
+          const backend1 = new SqliteQueryBackend(store1);
+          await backend1.sync({ strict: true, cwd: sandboxDir });
+          const artifacts1 = await backend1.findArtifacts();
+          const ids1 = artifacts1.map((a) => a.artifactId).sort();
+          const hashes1 = artifacts1.map((a) => a.contentHash).sort();
+          store1.disconnect();
+          if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+          const store2 = new HardkasStore({ dbPath });
+          store2.connect({ autoMigrate: true });
+          const backend2 = new SqliteQueryBackend(store2);
+          await backend2.rebuild({ strict: true, cwd: sandboxDir });
+          const artifacts2 = await backend2.findArtifacts();
+          const ids2 = artifacts2.map((a) => a.artifactId).sort();
+          const hashes2 = artifacts2.map((a) => a.contentHash).sort();
+          store2.disconnect();
+          if (JSON.stringify(ids1) !== JSON.stringify(ids2)) {
+            throw new TortureInvariantError(
+              `Ordering divergence: sync produced ${ids1.length} IDs, rebuild produced ${ids2.length}`,
+              "ORDERING_ID_DIVERGENCE",
+              "critical"
+            );
+          }
+          if (JSON.stringify(hashes1) !== JSON.stringify(hashes2)) {
+            throw new TortureInvariantError(
+              "Ordering divergence: sync and rebuild produced different hash sets",
+              "ORDERING_HASH_DIVERGENCE",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 2: {
+          const store = new HardkasStore({ dbPath });
+          store.connect({ autoMigrate: true });
+          const backend = new SqliteQueryBackend(store);
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const count1 = (await backend.findArtifacts()).length;
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const count2 = (await backend.findArtifacts()).length;
+          if (count1 !== count2) {
+            throw new TortureInvariantError(
+              `Double sync changed count: ${count1} \u2192 ${count2}`,
+              "DOUBLE_SYNC_INSTABILITY",
+              "critical"
+            );
+          }
+          store.disconnect();
+          break;
+        }
+        case 3: {
+          const store = new HardkasStore({ dbPath });
+          store.connect({ autoMigrate: true });
+          const backend = new SqliteQueryBackend(store);
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const initialCount = (await backend.findArtifacts()).length;
+          const extraCount = ctx.prng.nextInt(3, 8);
+          for (let i = 0; i < extraCount; i++) {
+            const payload = {
+              schema: "hardkas.txPlan",
+              hardkasVersion: "0.7.0-alpha",
+              version: ARTIFACT_VERSION,
+              networkId: "simnet",
+              mode: "simulated",
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              // hardkas-determinism-allow: mock timestamp
+              planId: `plan-extra-${i}-${ctx.caseSeed}`,
+              from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+              to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+              amountSompi: `${(i + 100) * 1e3}`,
+              estimatedFeeSompi: "100",
+              estimatedMass: "10",
+              inputs: [{ outpoint: { transactionId: "x".repeat(64), index: i + 100 }, amountSompi: "200000" }],
+              outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: `${(i + 100) * 1e3}` }]
+            };
+            const hash = calculateContentHash(payload);
+            const artId = `plan-${hash.slice(0, 16)}`;
+            fs.writeFileSync(
+              path.join(artifactsDir, `${artId}.json`),
+              JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2)
+            );
+          }
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const finalCount = (await backend.findArtifacts()).length;
+          if (finalCount < initialCount + extraCount) {
+            throw new TortureInvariantError(
+              `Mutation during scan: expected >= ${initialCount + extraCount}, got ${finalCount}`,
+              "SCAN_MUTATION_LOSS",
+              "critical"
+            );
+          }
+          store.disconnect();
+          break;
+        }
+      }
+      return {
+        flow: `Filesystem ordering subcase ${subCase}: ${["shuffled sync vs rebuild", "double sync idempotency", "mutation during scan"][subCase - 1]}`,
+        mutation: `${artifactCount} artifacts in shuffled order, scenario ${subCase}`,
+        expectedInvariant: "filesystem_iteration_order_never_affects_semantic_result"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "human-chaos",
+  expectedInvariant: "manual_user_interference_cannot_silently_corrupt_truth",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 5);
+    try {
+      const artifactIds = [];
+      for (let i = 0; i < 5; i++) {
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // hardkas-determinism-allow: mock timestamp
+          planId: `plan-human-${i}-${ctx.caseSeed}`,
+          from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+          to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+          amountSompi: `${(i + 1) * 1e3}`,
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [{ outpoint: { transactionId: "H".repeat(64), index: i }, amountSompi: "20000" }],
+          outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: `${(i + 1) * 1e3}` }]
+        };
+        const hash = calculateContentHash(payload);
+        const artId = `plan-${hash.slice(0, 16)}`;
+        artifactIds.push(artId);
+        fs.writeFileSync(
+          path.join(artifactsDir, `${artId}.json`),
+          JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2)
+        );
+      }
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      await backend.sync({ strict: true, cwd: sandboxDir });
+      switch (subCase) {
+        case 1: {
+          const targetFile = path.join(artifactsDir, `${artifactIds[0]}.json`);
+          const original = JSON.parse(fs.readFileSync(targetFile, "utf-8"));
+          original.amountSompi = "999999";
+          fs.writeFileSync(targetFile, JSON.stringify(original, null, 2));
+          const result = await backend.sync({ strict: false, cwd: sandboxDir });
+          break;
+        }
+        case 2: {
+          const targetFile = path.join(artifactsDir, `${artifactIds[0]}.json`);
+          fs.unlinkSync(targetFile);
+          store.disconnect();
+          if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+          const newStore = new HardkasStore({ dbPath });
+          newStore.connect({ autoMigrate: true });
+          const newBackend = new SqliteQueryBackend(newStore);
+          await newBackend.rebuild({ strict: false, cwd: sandboxDir });
+          const artifacts = await newBackend.findArtifacts();
+          const foundDeleted = artifacts.find((a) => a.artifactId === artifactIds[0]);
+          if (foundDeleted) {
+            throw new TortureInvariantError(
+              "Deleted artifact still appears in rebuilt index",
+              "DELETED_ROOT_PHANTOM",
+              "critical"
+            );
+          }
+          newStore.disconnect();
+          break;
+        }
+        case 3: {
+          const targetFile = path.join(artifactsDir, `${artifactIds[1]}.json`);
+          const original = fs.readFileSync(targetFile, "utf-8");
+          fs.writeFileSync(targetFile, original.slice(0, 30));
+          const result = await backend.sync({ strict: false, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          const nonCorrupted = artifacts.filter((a) => a.kind !== "CORRUPTED");
+          if (nonCorrupted.length < 3) {
+            throw new TortureInvariantError(
+              `Truncation caused collateral damage: only ${nonCorrupted.length} non-corrupted of 5`,
+              "TRUNCATION_COLLATERAL",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 4: {
+          const eventsPath = path.join(hardkasDir, "events.jsonl");
+          fs.writeFileSync(eventsPath, "{{GARBAGE}}\n{also invalid}\nNOT JSON AT ALL\n", "utf-8");
+          store.disconnect();
+          if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+          const newStore = new HardkasStore({ dbPath });
+          newStore.connect({ autoMigrate: true });
+          const newBackend = new SqliteQueryBackend(newStore);
+          await newBackend.rebuild({ strict: false, cwd: sandboxDir });
+          const artifacts = await newBackend.findArtifacts();
+          if (artifacts.length !== 5) {
+            throw new TortureInvariantError(
+              `Events corruption affected artifact count: expected 5, got ${artifacts.length}`,
+              "EVENTS_CORRUPTION_AFFECTED_ARTIFACTS",
+              "critical"
+            );
+          }
+          newStore.disconnect();
+          break;
+        }
+        case 5: {
+          const phantomPayload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-phantom-${ctx.caseSeed}`,
+            artifactId: "phantom-fake-id-12345",
+            contentHash: "0000000000000000000000000000000000000000000000000000000000000000",
+            // WRONG hash
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "666",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "P".repeat(64), index: 0 }, amountSompi: "1000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "666" }]
+          };
+          fs.writeFileSync(
+            path.join(artifactsDir, "phantom-fake-id-12345.json"),
+            JSON.stringify(phantomPayload, null, 2)
+          );
+          const result = await backend.sync({ strict: false, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          const phantom = artifacts.find((a) => a.artifactId === "phantom-fake-id-12345");
+          if (phantom && phantom.contentHash !== "MISMATCH" && phantom.kind !== "CORRUPTED") {
+            throw new TortureInvariantError(
+              "Phantom artifact with wrong hash was accepted as canonical without corruption flag",
+              "PHANTOM_ACCEPTED_AS_CANONICAL",
+              "catastrophic"
+            );
+          }
+          break;
+        }
+      }
+      try {
+        store.disconnect();
+      } catch {
+      }
+      return {
+        flow: `Human chaos subcase ${subCase}: ${["edit during sync", "delete root", "truncate artifact", "corrupt events.jsonl", "phantom artifact"][subCase - 1]}`,
+        mutation: `Manual interference scenario ${subCase}`,
+        expectedInvariant: "manual_user_interference_cannot_silently_corrupt_truth"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "antivirus-external-mutation",
+  expectedInvariant: "external_file_interference_never_creates_false_canonicality",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 5);
+    try {
+      let writePlan2 = function(id, amount) {
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // hardkas-determinism-allow: mock timestamp
+          planId: id,
+          from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+          to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+          amountSompi: amount,
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [{ outpoint: { transactionId: "a".repeat(64), index: 0 }, amountSompi: "10000" }],
+          outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: amount }]
+        };
+        const hash = calculateContentHash(payload);
+        const artId = `plan-${hash.slice(0, 16)}`;
+        const file = path.join(artifactsDir, `${artId}.json`);
+        fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+        return { artId, file, payload };
+      };
+      var writePlan = writePlan2;
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      switch (subCase) {
+        case 1: {
+          const files = [];
+          for (let i = 0; i < 5; i++) {
+            const { file } = writePlan2(`plan-av-${i}-${ctx.caseSeed}`, `${(i + 1) * 1e3}`);
+            files.push(file);
+          }
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          if (files[0] && files[1]) {
+            fs.unlinkSync(files[0]);
+            fs.unlinkSync(files[1]);
+          }
+          const report = await backend.doctor();
+          if (report.ok) {
+            throw new TortureInvariantError(
+              "Antivirus quarantine (file deletion) was not detected by doctor",
+              "QUARANTINE_NOT_DETECTED",
+              "critical"
+            );
+          }
+          if (report.zombieArtifacts !== 2) {
+            throw new TortureInvariantError(
+              `Expected 2 zombie artifacts, got ${report.zombieArtifacts}`,
+              "ZOMBIE_COUNT_MISMATCH",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 2: {
+          const { file } = writePlan2(`plan-locked-${ctx.caseSeed}`, "5000");
+          let fd = null;
+          try {
+            fd = fs.openSync(file, "r+");
+            await backend.sync({ strict: false, cwd: sandboxDir });
+          } finally {
+            if (fd !== null) {
+              try {
+                fs.closeSync(fd);
+              } catch {
+              }
+            }
+          }
+          const finalResult = await backend.sync({ strict: true, cwd: sandboxDir });
+          if (!finalResult.ok) {
+            throw new TortureInvariantError(
+              "Post-lock sync failed",
+              "POST_LOCK_SYNC_FAILED",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 3: {
+          const { artId, file, payload } = writePlan2(`plan-corrupt-${ctx.caseSeed}`, "9000");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const corrupted = { ...payload, artifactId: artId, contentHash: "12345fakehash", amountSompi: "99999" };
+          fs.writeFileSync(file, JSON.stringify(corrupted, null, 2));
+          const report = await backend.doctor();
+          if (report.ok) {
+            throw new TortureInvariantError(
+              "External rewrite was not detected by doctor",
+              "EXTERNAL_REWRITE_NOT_DETECTED",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 4: {
+          const { artId, file } = writePlan2(`plan-delayed-1-${ctx.caseSeed}`, "2000");
+          const { file: file2 } = writePlan2(`plan-delayed-2-${ctx.caseSeed}`, "4000");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const count1 = (await backend.findArtifacts()).length;
+          fs.unlinkSync(file);
+          await backend.sync({ strict: false, cwd: sandboxDir });
+          const count2 = (await backend.findArtifacts()).length;
+          if (count2 !== count1 - 1) {
+            throw new TortureInvariantError(
+              `Delayed delete did not decrement artifact count: count1=${count1}, count2=${count2}`,
+              "DELAYED_DELETE_COUNT_MISMATCH",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 5: {
+          const { file, payload } = writePlan2(`plan-rename-${ctx.caseSeed}`, "7500");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const count1 = (await backend.findArtifacts()).length;
+          const newPath = path.join(artifactsDir, `plan-renamed-${ctx.caseSeed}.json`);
+          fs.renameSync(file, newPath);
+          await backend.sync({ strict: false, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          const foundOld = artifacts.find((a) => a.path === file);
+          if (foundOld) {
+            throw new TortureInvariantError(
+              "Renamed file's old entry was not pruned",
+              "OLD_PATH_NOT_PRUNED",
+              "critical"
+            );
+          }
+          break;
+        }
+      }
+      store.disconnect();
+      return {
+        flow: `Antivirus external mutation subcase ${subCase}`,
+        mutation: `External file modification subcase ${subCase}`,
+        expectedInvariant: "external_file_interference_never_creates_false_canonicality"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "symlink-nightmare",
+  expectedInvariant: "symlink_resolution_cannot_escape_canonical_boundaries",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 5);
+    const outsideDir = path.join(ctx.workspaceDir, ".tmp", `torture-outside-${ctx.caseId}-${ctx.caseSeed}`);
+    fs.mkdirSync(outsideDir, { recursive: true });
+    const outsideFile = path.join(outsideDir, "outside-artifact.json");
+    const outsidePayload = {
+      schema: "hardkas.txPlan",
+      hardkasVersion: "0.7.0-alpha",
+      version: ARTIFACT_VERSION,
+      networkId: "simnet",
+      mode: "simulated",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      // hardkas-determinism-allow: mock timestamp
+      planId: `plan-outside-${ctx.caseSeed}`,
+      from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+      to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+      amountSompi: "500000",
+      estimatedFeeSompi: "100",
+      estimatedMass: "10",
+      inputs: [{ outpoint: { transactionId: "o".repeat(64), index: 0 }, amountSompi: "600000" }],
+      outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "500000" }]
+    };
+    const outsideHash = calculateContentHash(outsidePayload);
+    fs.writeFileSync(outsideFile, JSON.stringify({ ...outsidePayload, artifactId: `plan-${outsideHash.slice(0, 16)}`, contentHash: outsideHash }, null, 2));
+    try {
+      let writePlan2 = function(id, amount) {
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // hardkas-determinism-allow: mock timestamp
+          planId: id,
+          from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+          to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+          amountSompi: amount,
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [{ outpoint: { transactionId: "s".repeat(64), index: 0 }, amountSompi: "10000" }],
+          outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: amount }]
+        };
+        const hash = calculateContentHash(payload);
+        const artId = `plan-${hash.slice(0, 16)}`;
+        const file = path.join(artifactsDir, `${artId}.json`);
+        fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+        return { artId, file };
+      };
+      var writePlan = writePlan2;
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      let symlinksSupported = false;
+      let junctionsSupported = false;
+      let modeStr = "SIMULATED_SYMLINK_MODE";
+      const testTarget = path.join(sandboxDir, "test-target.json");
+      const testLink = path.join(sandboxDir, "test-link.json");
+      fs.writeFileSync(testTarget, "{}");
+      try {
+        fs.symlinkSync(testTarget, testLink);
+        symlinksSupported = true;
+        modeStr = "REAL_SYMLINK_MODE";
+        fs.unlinkSync(testLink);
+      } catch {
+      }
+      try {
+        const testDirTarget = path.join(sandboxDir, "test-dir-target");
+        const testDirLink = path.join(sandboxDir, "test-dir-link");
+        fs.mkdirSync(testDirTarget, { recursive: true });
+        fs.symlinkSync(testDirTarget, testDirLink, "junction");
+        junctionsSupported = true;
+        fs.unlinkSync(testDirLink);
+        fs.rmdirSync(testDirTarget);
+      } catch {
+      }
+      fs.unlinkSync(testTarget);
+      switch (subCase) {
+        case 1: {
+          if (symlinksSupported) {
+            const linkPath = path.join(artifactsDir, "outside-link.json");
+            fs.symlinkSync(outsideFile, linkPath);
+            await backend.sync({ strict: false, cwd: sandboxDir });
+            const artifacts = await backend.findArtifacts();
+            const foundOutside = artifacts.find((a) => a.payload.planId === `plan-outside-${ctx.caseSeed}`);
+            if (foundOutside) {
+              throw new TortureInvariantError(
+                "Indexed artifact from a symlink pointing outside the workspace boundary",
+                "OUTSIDE_WORKSPACE_ESCAPE",
+                "catastrophic"
+              );
+            }
+          } else {
+            const { file } = writePlan2(`plan-sim-outside-${ctx.caseSeed}`, "1000");
+            const relativePath = path.relative(sandboxDir, file);
+            if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+              throw new TortureInvariantError(
+                "Absolute or escaping path simulated boundary escape",
+                "OUTSIDE_WORKSPACE_ESCAPE",
+                "catastrophic"
+              );
+            }
+            await backend.sync({ strict: true, cwd: sandboxDir });
+          }
+          break;
+        }
+        case 2: {
+          if (symlinksSupported) {
+            const { file } = writePlan2(`plan-nested-${ctx.caseSeed}`, "2000");
+            const link1 = path.join(artifactsDir, "link1.json");
+            const link2 = path.join(artifactsDir, "link2.json");
+            fs.symlinkSync(file, link1);
+            fs.symlinkSync(link1, link2);
+            await backend.sync({ strict: false, cwd: sandboxDir });
+          } else {
+            let currentDir = artifactsDir;
+            for (let i = 0; i < 5; i++) {
+              currentDir = path.join(currentDir, `sub-${i}`);
+              fs.mkdirSync(currentDir, { recursive: true });
+            }
+            const payload = {
+              schema: "hardkas.txPlan",
+              hardkasVersion: "0.7.0-alpha",
+              version: ARTIFACT_VERSION,
+              networkId: "simnet",
+              mode: "simulated",
+              createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+              // hardkas-determinism-allow: mock timestamp
+              planId: `plan-deep-${ctx.caseSeed}`,
+              from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+              to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+              amountSompi: "3000",
+              estimatedFeeSompi: "100",
+              estimatedMass: "10",
+              inputs: [{ outpoint: { transactionId: "d".repeat(64), index: 0 }, amountSompi: "5000" }],
+              outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "3000" }]
+            };
+            const hash = calculateContentHash(payload);
+            fs.writeFileSync(
+              path.join(currentDir, `plan-deep-${hash.slice(0, 8)}.json`),
+              JSON.stringify({ ...payload, artifactId: `plan-${hash.slice(0, 16)}`, contentHash: hash }, null, 2)
+            );
+            await backend.sync({ strict: true, cwd: sandboxDir });
+          }
+          break;
+        }
+        case 3: {
+          if (symlinksSupported) {
+            const linkA = path.join(artifactsDir, "circular-a.json");
+            const linkB = path.join(artifactsDir, "circular-b.json");
+            fs.symlinkSync(linkB, linkA);
+            try {
+              fs.symlinkSync(linkA, linkB);
+            } catch {
+            }
+            try {
+              await backend.sync({ strict: false, cwd: sandboxDir });
+            } catch (err) {
+            }
+          } else {
+            await backend.sync({ strict: true, cwd: sandboxDir });
+          }
+          break;
+        }
+        case 4: {
+          if (junctionsSupported) {
+            const linkPath = path.join(artifactsDir, "outside-junction");
+            fs.symlinkSync(outsideDir, linkPath, "junction");
+            await backend.sync({ strict: false, cwd: sandboxDir });
+            const artifacts = await backend.findArtifacts();
+            const foundOutside = artifacts.find((a) => a.payload.planId === `plan-outside-${ctx.caseSeed}`);
+            if (foundOutside) {
+              throw new TortureInvariantError(
+                "Indexed artifact from outside the workspace via a directory junction point",
+                "JUNCTION_ESCAPE_CANONICALITY",
+                "catastrophic"
+              );
+            }
+          } else {
+            await backend.sync({ strict: true, cwd: sandboxDir });
+          }
+          break;
+        }
+        case 5: {
+          const { file } = writePlan2(`plan-replace-${ctx.caseSeed}`, "9000");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          if (symlinksSupported) {
+            fs.unlinkSync(file);
+            fs.symlinkSync(outsideFile, file);
+            await backend.sync({ strict: false, cwd: sandboxDir });
+          } else {
+            fs.writeFileSync(file, fs.readFileSync(outsideFile, "utf-8"));
+            await backend.sync({ strict: true, cwd: sandboxDir });
+          }
+          break;
+        }
+      }
+      store.disconnect();
+      return {
+        flow: `Symlink nightmare subcase ${subCase}: mode=${modeStr}`,
+        mutation: `Symlink manipulation scenario ${subCase}`,
+        expectedInvariant: "symlink_resolution_cannot_escape_canonical_boundaries"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+      cleanupSandbox(outsideDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "docker-mount-simulation",
+  expectedInvariant: "containerized_mounts_preserve_semantic_equivalence",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 4);
+    try {
+      let writePlan2 = function(id, amount) {
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // hardkas-determinism-allow: mock timestamp
+          planId: id,
+          from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+          to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+          amountSompi: amount,
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [{ outpoint: { transactionId: "d".repeat(64), index: 0 }, amountSompi: "10000" }],
+          outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: amount }]
+        };
+        const hash = calculateContentHash(payload);
+        const artId = `plan-${hash.slice(0, 16)}`;
+        const file = path.join(artifactsDir, `${artId}.json`);
+        fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+        return { artId, file, payload };
+      };
+      var writePlan = writePlan2;
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      switch (subCase) {
+        case 1: {
+          const { file } = writePlan2(`plan-fsync-${ctx.caseSeed}`, "1000");
+          const written = fs.readFileSync(file, "utf-8");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          if (artifacts.length === 0) {
+            throw new TortureInvariantError(
+              "Fsync delay caused artifact to not be indexed",
+              "FSYNC_DELAY_INDEX_LOSS",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 2: {
+          const { file } = writePlan2(`plan-readonly-${ctx.caseSeed}`, "2000");
+          try {
+            fs.chmodSync(file, 292);
+            await backend.sync({ strict: true, cwd: sandboxDir });
+            const artifacts = await backend.findArtifacts();
+            if (artifacts.length === 0) {
+              throw new TortureInvariantError(
+                "Read-only artifact file was skipped during sync",
+                "READONLY_FILE_SKIPPED",
+                "critical"
+              );
+            }
+          } finally {
+            try {
+              fs.chmodSync(file, 438);
+            } catch {
+            }
+          }
+          break;
+        }
+        case 3: {
+          const { file } = writePlan2(`plan-inode-old-${ctx.caseSeed}`, "3000");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          fs.unlinkSync(file);
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          const { file: fileNew } = writePlan2(`plan-inode-new-${ctx.caseSeed}`, "99000");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          const foundNew = artifacts.find((a) => a.payload.amountSompi === "99000");
+          if (!foundNew) {
+            throw new TortureInvariantError(
+              "Inode/mtime replacement was not detected during sync",
+              "INODE_REPLACEMENT_LOST",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 4: {
+          try {
+            fs.chmodSync(artifactsDir, 365);
+            let writeSucceeded = false;
+            try {
+              writePlan2(`plan-permission-denied-${ctx.caseSeed}`, "4000");
+              writeSucceeded = true;
+            } catch (e) {
+            }
+            await backend.sync({ strict: false, cwd: sandboxDir });
+          } finally {
+            try {
+              fs.chmodSync(artifactsDir, 511);
+            } catch {
+            }
+          }
+          break;
+        }
+      }
+      store.disconnect();
+      return {
+        flow: `Docker mount simulation subcase ${subCase}`,
+        mutation: `Mount synchronization scenario ${subCase}`,
+        expectedInvariant: "containerized_mounts_preserve_semantic_equivalence"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "ci-environment-hell",
+  expectedInvariant: "ci_environment_variation_preserves_runtime_truth",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 4);
+    try {
+      let writePlan2 = function(id, amount) {
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // hardkas-determinism-allow: mock timestamp
+          planId: id,
+          from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+          to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+          amountSompi: amount,
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [{ outpoint: { transactionId: "c".repeat(64), index: 0 }, amountSompi: "10000" }],
+          outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: amount }]
+        };
+        const hash = calculateContentHash(payload);
+        const artId = `plan-${hash.slice(0, 16)}`;
+        const file = path.join(artifactsDir, `${artId}.json`);
+        fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+        return { artId, file, payload };
+      };
+      var writePlan = writePlan2;
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      switch (subCase) {
+        case 1: {
+          writePlan2(`plan-ci-ro-${ctx.caseSeed}`, "1000");
+          try {
+            fs.chmodSync(artifactsDir, 365);
+            const syncResult = await backend.sync({ strict: true, cwd: sandboxDir });
+            if (!syncResult.ok) {
+              throw new TortureInvariantError(
+                "Sync failed when artifacts directory is read-only",
+                "RO_DIR_SYNC_FAILED",
+                "critical"
+              );
+            }
+          } finally {
+            try {
+              fs.chmodSync(artifactsDir, 511);
+            } catch {
+            }
+          }
+          break;
+        }
+        case 2: {
+          store.disconnect();
+          cleanupSandbox(sandboxDir);
+          fs.mkdirSync(sandboxDir, { recursive: true });
+          const newStore = new HardkasStore({ dbPath });
+          newStore.connect({ autoMigrate: true });
+          const newBackend = new SqliteQueryBackend(newStore);
+          const syncResult = await newBackend.sync({ strict: true, cwd: sandboxDir });
+          if (!syncResult.ok) {
+            throw new TortureInvariantError(
+              "Sync failed to initialize missing .hardkas folder",
+              "MISSING_HARDKAS_DIR_INIT_FAILED",
+              "critical"
+            );
+          }
+          newStore.disconnect();
+          break;
+        }
+        case 3: {
+          writePlan2(`plan-ci-rebuild-${ctx.caseSeed}`, "3000");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          store.disconnect();
+          if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+          const newStore = new HardkasStore({ dbPath });
+          newStore.connect({ autoMigrate: true });
+          const newBackend = new SqliteQueryBackend(newStore);
+          const rebuildResult = await newBackend.rebuild({ strict: true, cwd: sandboxDir });
+          if (!rebuildResult.ok) {
+            throw new TortureInvariantError(
+              "Rebuild failed after database file deletion",
+              "REBUILD_POST_DELETION_FAILED",
+              "critical"
+            );
+          }
+          const artifacts = await newBackend.findArtifacts();
+          if (artifacts.length === 0) {
+            throw new TortureInvariantError(
+              "Rebuilt store contains 0 artifacts after database file deletion",
+              "REBUILD_RECONSTRUCTION_LOST",
+              "critical"
+            );
+          }
+          newStore.disconnect();
+          break;
+        }
+        case 4: {
+          const files = fs.readdirSync(artifactsDir);
+          for (const file of files) {
+            fs.unlinkSync(path.join(artifactsDir, file));
+          }
+          const syncResult = await backend.sync({ strict: true, cwd: sandboxDir });
+          if (!syncResult.ok) {
+            throw new TortureInvariantError(
+              "Sync failed with empty artifacts folder",
+              "EMPTY_ARTIFACTS_SYNC_FAILED",
+              "critical"
+            );
+          }
+          const artifacts = await backend.findArtifacts();
+          if (artifacts.length !== 0) {
+            throw new TortureInvariantError(
+              `Expected 0 artifacts, got ${artifacts.length}`,
+              "EMPTY_ARTIFACTS_NOT_EMPTY",
+              "critical"
+            );
+          }
+          break;
+        }
+      }
+      try {
+        store.disconnect();
+      } catch {
+      }
+      return {
+        flow: `CI environment hell subcase ${subCase}`,
+        mutation: `CI environmental condition ${subCase}`,
+        expectedInvariant: "ci_environment_variation_preserves_runtime_truth"
+      };
+    } finally {
+      try {
+        fs.chmodSync(artifactsDir, 511);
+      } catch {
+      }
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+registerTortureBucket({
+  name: "network-drive-simulation",
+  expectedInvariant: "network_filesystem_latency_cannot_create_semantic_divergence",
+  async run(ctx) {
+    const { sandboxDir, hardkasDir, artifactsDir, dbPath } = createSandbox(ctx);
+    const subCase = ctx.prng.nextInt(1, 4);
+    try {
+      let writePlan2 = function(id, amount) {
+        const payload = {
+          schema: "hardkas.txPlan",
+          hardkasVersion: "0.7.0-alpha",
+          version: ARTIFACT_VERSION,
+          networkId: "simnet",
+          mode: "simulated",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          // hardkas-determinism-allow: mock timestamp
+          planId: id,
+          from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+          to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+          amountSompi: amount,
+          estimatedFeeSompi: "100",
+          estimatedMass: "10",
+          inputs: [{ outpoint: { transactionId: "n".repeat(64), index: 0 }, amountSompi: "10000" }],
+          outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: amount }]
+        };
+        const hash = calculateContentHash(payload);
+        const artId = `plan-${hash.slice(0, 16)}`;
+        const file = path.join(artifactsDir, `${artId}.json`);
+        fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: artId, contentHash: hash }, null, 2));
+        return { artId, file, payload };
+      };
+      var writePlan = writePlan2;
+      const store = new HardkasStore({ dbPath });
+      store.connect({ autoMigrate: true });
+      const backend = new SqliteQueryBackend(store);
+      switch (subCase) {
+        case 1: {
+          const { file } = writePlan2(`plan-stale-${ctx.caseSeed}`, "1000");
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          await new Promise((resolve) => setTimeout(resolve, 20));
+          const payload = {
+            schema: "hardkas.txPlan",
+            hardkasVersion: "0.7.0-alpha",
+            version: ARTIFACT_VERSION,
+            networkId: "simnet",
+            mode: "simulated",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+            // hardkas-determinism-allow: mock timestamp
+            planId: `plan-stale-${ctx.caseSeed}`,
+            from: { address: "kaspa:sim_qz0s9xrz5y5e8dq5azmpg756aeepm6fesq82ye7wv" },
+            to: { address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg" },
+            amountSompi: "99000",
+            estimatedFeeSompi: "100",
+            estimatedMass: "10",
+            inputs: [{ outpoint: { transactionId: "n".repeat(64), index: 0 }, amountSompi: "100000" }],
+            outputs: [{ address: "kaspa:sim_qq0d6h0prjm5mpdld5pncst3adu0yam6xch9fkr6eg", amountSompi: "99000" }]
+          };
+          const hash = calculateContentHash(payload);
+          fs.writeFileSync(file, JSON.stringify({ ...payload, artifactId: `plan-${hash.slice(0, 16)}`, contentHash: hash }, null, 2));
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const artifacts = await backend.findArtifacts();
+          const found = artifacts.find((a) => a.payload.amountSompi === "99000");
+          if (!found) {
+            throw new TortureInvariantError(
+              "Stale read/overwrite was not detected in second sync",
+              "STALE_READ_OVERWRITE_LOST",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 2: {
+          const plans = [];
+          for (let i = 0; i < 10; i++) {
+            const { artId } = writePlan2(`plan-ooo-${i}-${ctx.caseSeed}`, `${(i + 1) * 1e3}`);
+            plans.push(artId);
+          }
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          const artifacts1 = await backend.findArtifacts();
+          const ids1 = artifacts1.map((a) => a.artifactId).sort();
+          store.disconnect();
+          if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+          const newStore = new HardkasStore({ dbPath });
+          newStore.connect({ autoMigrate: true });
+          const newBackend = new SqliteQueryBackend(newStore);
+          await newBackend.rebuild({ strict: true, cwd: sandboxDir });
+          const artifacts2 = await newBackend.findArtifacts();
+          const ids2 = artifacts2.map((a) => a.artifactId).sort();
+          if (JSON.stringify(ids1) !== JSON.stringify(ids2)) {
+            throw new TortureInvariantError(
+              "Out-of-order writes caused database reconstruction divergence",
+              "OOO_WRITES_DIVERGENCE",
+              "critical"
+            );
+          }
+          newStore.disconnect();
+          break;
+        }
+        case 3: {
+          const files = [];
+          for (let i = 0; i < 10; i++) {
+            const { file } = writePlan2(`plan-partial-${i}-${ctx.caseSeed}`, `${(i + 1) * 1e3}`);
+            files.push(file);
+          }
+          await backend.syncPaths(files.slice(0, 5), { strict: true, cwd: sandboxDir });
+          const artifacts1 = await backend.findArtifacts();
+          if (artifacts1.length !== 5) {
+            throw new TortureInvariantError(
+              `Expected exactly 5 artifacts after partial sync, got ${artifacts1.length}`,
+              "PARTIAL_SYNC_COUNT_MISMATCH",
+              "critical"
+            );
+          }
+          await backend.syncPaths(files.slice(5), { strict: true, cwd: sandboxDir });
+          const artifacts2 = await backend.findArtifacts();
+          if (artifacts2.length !== 10) {
+            throw new TortureInvariantError(
+              `Expected exactly 10 artifacts after full sync, got ${artifacts2.length}`,
+              "FULL_SYNC_COUNT_MISMATCH",
+              "critical"
+            );
+          }
+          break;
+        }
+        case 4: {
+          for (let i = 0; i < 5; i++) {
+            writePlan2(`plan-delayed-vis-${i}-${ctx.caseSeed}`, `${(i + 1) * 1e3}`);
+          }
+          await backend.sync({ strict: true, cwd: sandboxDir });
+          for (let i = 5; i < 10; i++) {
+            writePlan2(`plan-delayed-vis-${i}-${ctx.caseSeed}`, `${(i + 1) * 1e3}`);
+          }
+          store.disconnect();
+          if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+          const newStore = new HardkasStore({ dbPath });
+          newStore.connect({ autoMigrate: true });
+          const newBackend = new SqliteQueryBackend(newStore);
+          await newBackend.rebuild({ strict: true, cwd: sandboxDir });
+          const artifacts = await newBackend.findArtifacts();
+          if (artifacts.length !== 10) {
+            throw new TortureInvariantError(
+              `Expected 10 rebuilt artifacts, got ${artifacts.length}`,
+              "DELAYED_VISIBILITY_RECONSTRUCTION_FAILED",
+              "critical"
+            );
+          }
+          newStore.disconnect();
+          break;
+        }
+      }
+      try {
+        store.disconnect();
+      } catch {
+      }
+      return {
+        flow: `Network drive simulation subcase ${subCase}`,
+        mutation: `Latency/filesystem sync visibility subcase ${subCase}`,
+        expectedInvariant: "network_filesystem_latency_cannot_create_semantic_divergence"
+      };
+    } finally {
+      cleanupSandbox(sandboxDir);
+    }
+  }
+});
+
+// src/torture/local-buckets.ts
+import fs2 from "fs";
+import { fileURLToPath } from "url";
+import path2 from "path";
+import { execSync } from "child_process";
+registerTortureBucket({
+  name: "local-first-lifecycle",
+  profiles: ["local"],
+  expectedInvariant: "Workspace init, basic transfer, and dev doctor checks succeed without mutation side effects",
+  run: async (ctx) => {
+    const runDir = path2.join(ctx.workspaceDir, ".tmp", `local-${ctx.caseId}`);
+    fs2.rmSync(runDir, { recursive: true, force: true });
+    fs2.mkdirSync(runDir, { recursive: true });
+    const cliPath = fileURLToPath(new URL("../../cli/dist/index.js", import.meta.url));
+    fs2.writeFileSync(path2.join(runDir, "package.json"), "{}");
+    try {
+      execSync(`node "${cliPath}" dev init`, { cwd: runDir, stdio: "pipe", encoding: "utf-8" });
+    } catch (e) {
+      throw new TortureInvariantError(`hardkas dev init failed: ${e.message}
+${e.stdout}
+${e.stderr}`, "INIT_FAILED", "critical");
+    }
+    if (!fs2.existsSync(path2.join(runDir, "hardkas.config.ts"))) {
+      throw new TortureInvariantError("hardkas.config.ts was not generated", "MISSING_CONFIG", "critical");
+    }
+    const minimalConfig = `export default {
+  defaultNetwork: "simulated",
+  networks: {
+    simulated: { kind: "simulated", description: "Pure local simulation" }
+  },
+  accounts: {
+    alice: { kind: "simulated", address: "kaspa:sim_sim_alice" }
+  }
+};
+`;
+    fs2.writeFileSync(path2.join(runDir, "hardkas.config.ts"), minimalConfig);
+    const artifactsDir = path2.join(runDir, ".hardkas", "artifacts");
+    fs2.mkdirSync(artifactsDir, { recursive: true });
+    const eventsPath = path2.join(artifactsDir, "events.jsonl");
+    const mockArtifact = { schema: "hardkas.artifact.v1", type: "transfer", amount: 100, timestamp: Date.now() };
+    fs2.appendFileSync(eventsPath, JSON.stringify(mockArtifact) + "\n");
+    try {
+      const doctorOutput = execSync(`node "${cliPath}" dev doctor --json`, { cwd: runDir, stdio: "pipe", encoding: "utf-8" });
+      const doctorResult = JSON.parse(doctorOutput);
+      const workspaceCheck = doctorResult.checks?.find((c) => c.name === "Workspace Validity");
+      if (workspaceCheck?.status === "error") {
+        throw new TortureInvariantError(
+          `dev doctor: workspace invalid \u2014 ${workspaceCheck.message}`,
+          "DOCTOR_WORKSPACE_INVALID",
+          "critical"
+        );
+      }
+    } catch (e) {
+      if (e instanceof TortureInvariantError) throw e;
+      const stdout = e.stdout || "";
+      try {
+        const doctorResult = JSON.parse(stdout);
+        const workspaceCheck = doctorResult.checks?.find((c) => c.name === "Workspace Validity");
+        if (workspaceCheck?.status === "error") {
+          throw new TortureInvariantError(
+            `dev doctor: workspace invalid \u2014 ${workspaceCheck.message}`,
+            "DOCTOR_WORKSPACE_INVALID",
+            "critical"
+          );
+        }
+      } catch (parseErr) {
+        if (parseErr instanceof TortureInvariantError) throw parseErr;
+        throw new TortureInvariantError(
+          `dev doctor failed and produced unparseable output: ${e.message}`,
+          "DOCTOR_FAILED",
+          "warning"
+        );
+      }
+    }
+    fs2.rmSync(runDir, { recursive: true, force: true });
+    return {
+      flow: "local-first-lifecycle",
+      mutation: "simulated local workflows and dev doctor",
+      environmentMode: "local",
+      artifactsAfter: ["events.jsonl"]
+    };
+  }
+});
+
+// src/torture/corruption-buckets.ts
+import fs3 from "fs";
+import path3 from "path";
+import { AppendCoordinator } from "@hardkas/core";
+registerTortureBucket({
+  name: "concurrent-append-tail-repair",
+  profiles: ["corruption"],
+  expectedInvariant: "AppendCoordinator successfully truncates partial JSONL suffix while keeping large JSONL lines during concurrent append simulation",
+  run: async (ctx) => {
+    const runDir = path3.join(ctx.workspaceDir, ".tmp", `corruption-${ctx.caseId}`);
+    fs3.rmSync(runDir, { recursive: true, force: true });
+    fs3.mkdirSync(runDir, { recursive: true });
+    const eventsPath = path3.join(runDir, "events.jsonl");
+    const largePayload = { schema: "hardkas.artifact.v1", type: "large", data: "x".repeat(7e4) };
+    fs3.writeFileSync(eventsPath, JSON.stringify(largePayload) + "\n");
+    const validSize = fs3.statSync(eventsPath).size;
+    fs3.appendFileSync(eventsPath, '{"schema":"hardkas.artifact.v1","type":"corrupted","d');
+    const newArtifact = { schema: "hardkas.artifact.v1", type: "recovery-test" };
+    AppendCoordinator.appendAtomic(eventsPath, JSON.stringify(newArtifact), runDir);
+    const content = fs3.readFileSync(eventsPath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim().length > 0);
+    if (lines.length !== 2) {
+      throw new TortureInvariantError(`Expected exactly 2 lines after recovery, got ${lines.length}`, "CORRUPTION_RECOVERY_FAILED", "catastrophic");
+    }
+    try {
+      JSON.parse(lines[0]);
+      JSON.parse(lines[1]);
+    } catch (e) {
+      throw new TortureInvariantError("Recovered JSON lines are invalid", "CORRUPTION_RECOVERY_JSON_PARSE", "catastrophic");
+    }
+    if (lines[0].length < 7e4) {
+      throw new TortureInvariantError("Large JSONL line was incorrectly truncated", "LARGE_LINE_TRUNCATED", "catastrophic");
+    }
+    fs3.rmSync(runDir, { recursive: true, force: true });
+    return {
+      flow: "concurrent-append-tail-repair",
+      mutation: "massive valid line + partial tail + atomic append",
+      environmentMode: "corruption",
+      externalMutationDetected: true
+    };
+  }
+});
 export {
   AdversarialFixtures,
+  LcgPrng,
+  TortureInvariantError,
   clearMassRecords,
   createFixture,
   createTestHarness,
   disableMassTracking,
   enableMassTracking,
   generateReproducibilityReport,
+  getAllTortureBuckets,
   getMassRecords,
+  getTortureBucket,
   hardKasMatchers
 };