lsd-pi 1.0.0 → 1.1.0

package/src/resources/extensions/gsd/tests/vacuous-truth-slices.test.ts

@@ -1,115 +0,0 @@
-/**
- * Regression test for #2667: deriveStateFromDb must NOT treat an empty
- * slice array as "all slices done" due to JavaScript's vacuous-truth
- * behavior of Array.prototype.every on an empty array.
- *
- * [].every(predicate) === true in JavaScript. Without a length > 0 guard,
- * this causes a premature phase transition to validating-milestone when
- * the DB returns 0 slices (e.g. after a worktree DB wipe).
- */
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { deriveStateFromDb, invalidateStateCache } from "../state.ts";
-import {
-  openDatabase,
-  closeDatabase,
-  insertMilestone,
-  insertSlice,
-} from "../gsd-db.ts";
-
-test("deriveStateFromDb does NOT skip to validating when slice array is empty (#2667)", async () => {
-  const base = mkdtempSync(join(tmpdir(), "gsd-vacuous-truth-"));
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-
-  try {
-    // Set up a milestone with a roadmap that references slices,
-    // but the DB has NO slice rows (simulating a worktree DB wipe)
-    writeFileSync(
-      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      [
-        "# M001: Test Milestone",
-        "",
-        "## Slices",
-        "",
-        "### S01 — First Slice",
-        "Do something.",
-        "",
-        "### S02 — Second Slice",
-        "Do another thing.",
-      ].join("\n"),
-    );
-
-    openDatabase(":memory:");
-    // Milestone exists but NO slices inserted — simulates DB wipe
-    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
-
-    invalidateStateCache();
-    const state = await deriveStateFromDb(base);
-
-    // The phase must NOT be "validating-milestone" or "completing-milestone"
-    // because no slices have been executed — the empty array should not
-    // trigger the "all slices done" code path.
-    assert.notEqual(
-      state.phase,
-      "validating-milestone",
-      "empty slice array must not trigger validating-milestone (vacuous truth)",
-    );
-    assert.notEqual(
-      state.phase,
-      "completing-milestone",
-      "empty slice array must not trigger completing-milestone (vacuous truth)",
-    );
-
-    closeDatabase();
-  } finally {
-    closeDatabase();
-    rmSync(base, { recursive: true, force: true });
-  }
-});
-
-test("deriveStateFromDb correctly reaches validating when all slices are done (#2667 guard)", async () => {
-  const base = mkdtempSync(join(tmpdir(), "gsd-vacuous-truth-"));
-  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
-
-  try {
-    writeFileSync(
-      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      [
-        "# M001: Test Milestone",
-        "",
-        "## Slices",
-        "",
-        "### S01 — First Slice",
-        "Do something.",
-      ].join("\n"),
-    );
-
-    // Write a slice summary so the filesystem recognizes it as complete
-    writeFileSync(
-      join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"),
-      "# S01 Summary\n\nDone.",
-    );
-
-    openDatabase(":memory:");
-    insertMilestone({ id: "M001", title: "Test Milestone", status: "active" });
-    insertSlice({ id: "S01", milestoneId: "M001", title: "First Slice", status: "complete", risk: "low", depends: [] });
-
-    invalidateStateCache();
-    const state = await deriveStateFromDb(base);
-
-    // With one slice that IS complete, phase should advance
-    assert.ok(
-      state.phase === "validating-milestone" || state.phase === "completing-milestone",
-      `expected validating or completing phase, got "${state.phase}"`,
-    );
-
-    closeDatabase();
-  } finally {
-    closeDatabase();
-    rmSync(base, { recursive: true, force: true });
-  }
-});

package/src/resources/extensions/gsd/tests/vacuum-recovery.test.ts

@@ -1,154 +0,0 @@
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import { createRequire } from 'node:module';
-import {
-  openDatabase,
-  closeDatabase,
-  isDbAvailable,
-  _getAdapter,
-} from '../gsd-db.ts';
-
-const _require = createRequire(import.meta.url);
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Helpers
-// ═══════════════════════════════════════════════════════════════════════════
-
-function tempDbPath(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-vacuum-test-'));
-  return path.join(dir, 'test.db');
-}
-
-function cleanup(dbPath: string): void {
-  closeDatabase();
-  try {
-    const dir = path.dirname(dbPath);
-    for (const f of fs.readdirSync(dir)) {
-      fs.unlinkSync(path.join(dir, f));
-    }
-    fs.rmdirSync(dir);
-  } catch { /* best effort */ }
-}
-
-/**
- * Create a SQLite DB with a corrupt freelist that causes DDL to fail
- * with "database disk image is malformed" but is recoverable via VACUUM.
- *
- * Strategy:
- * 1. Create a DB with schema_version at v0 (so initSchema needs to run DDL)
- * 2. Add padding rows to create many pages, then delete + drop to free them
- * 3. Corrupt the freelist trunk pointer to point at a B-tree page
- *
- * This simulates the real-world scenario described in #2519: an interrupted
- * WAL checkpoint leaves the freelist in an inconsistent state.
- */
-function createCorruptFreelistDb(dbPath: string): void {
-  // Use node:sqlite directly to build the minimal corrupt DB
-  const sqlite = _require('node:sqlite');
-  const db = new sqlite.DatabaseSync(dbPath);
-  db.exec('PRAGMA journal_mode=WAL');
-  db.exec('CREATE TABLE schema_version (version INTEGER NOT NULL, applied_at TEXT NOT NULL)');
-  db.exec("INSERT INTO schema_version VALUES (0, '2024-01-01')");
-  // Pad with data to create many pages, then free them
-  db.exec('CREATE TABLE _padding (id INTEGER PRIMARY KEY, data TEXT)');
-  for (let i = 0; i < 30; i++) {
-    db.exec(`INSERT INTO _padding (data) VALUES ('${'x'.repeat(4000)}')`);
-  }
-  db.exec('DELETE FROM _padding');
-  db.exec('DROP TABLE _padding');
-  db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-  db.close();
-
-  // Remove WAL/SHM files to ensure clean file-only state
-  try { fs.unlinkSync(dbPath + '-wal'); } catch { /* may not exist */ }
-  try { fs.unlinkSync(dbPath + '-shm'); } catch { /* may not exist */ }
-
-  // Corrupt: point freelist trunk (offset 32-35) to page 2 (a B-tree page),
-  // and claim 10 free pages (offset 36-39)
-  const fd = fs.openSync(dbPath, 'r+');
-  try {
-    const buf = Buffer.alloc(8);
-    buf.writeUInt32BE(2, 0);   // trunk page = page 2 (actually a B-tree page)
-    buf.writeUInt32BE(10, 4);  // freelist count = 10
-    fs.writeSync(fd, buf, 0, 8, 32);
-  } finally {
-    fs.closeSync(fd);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe('openDatabase VACUUM recovery on corrupt freelist', () => {
-
-  test('recovers a file-backed DB with corrupt freelist via VACUUM', () => {
-    const dbPath = tempDbPath();
-
-    // Create a DB with corrupt freelist (schema at v0 so initSchema runs DDL)
-    createCorruptFreelistDb(dbPath);
-
-    // Without the fix, this throws "database disk image is malformed".
-    // With the fix, openDatabase detects "malformed", runs VACUUM, retries.
-    const ok = openDatabase(dbPath);
-    assert.ok(ok, 'openDatabase should succeed after VACUUM recovery');
-    assert.ok(isDbAvailable(), 'DB should be available after recovery');
-
-    // Verify full schema was applied
-    const adapter = _getAdapter()!;
-    const row = adapter.prepare(
-      'SELECT MAX(version) as version FROM schema_version',
-    ).get();
-    assert.ok(
-      typeof row?.['version'] === 'number' && (row['version'] as number) > 0,
-      'schema_version should have a positive version after recovery',
-    );
-
-    cleanup(dbPath);
-  });
-
-  test('does not attempt VACUUM for non-malformed errors', () => {
-    // openDatabase with :memory: never hits the fileBacked VACUUM path,
-    // so non-malformed errors propagate directly. We verify by checking
-    // that a non-file error from an in-memory DB propagates unchanged.
-    // (In-memory DBs always succeed for initSchema, so this is a design
-    // check — the VACUUM path is only for fileBacked = true.)
-    const ok = openDatabase(':memory:');
-    assert.ok(ok, 'in-memory DB should open fine');
-    closeDatabase();
-  });
-
-  test('throws if VACUUM itself fails on unrecoverable corruption', () => {
-    const dbPath = tempDbPath();
-
-    // Create a file with valid SQLite header but thoroughly corrupt content
-    const page = Buffer.alloc(4096);
-    // SQLite magic: "SQLite format 3\0"
-    page.write('SQLite format 3\0', 0, 'utf8');
-    // Page size: 4096 (big-endian at offset 16)
-    page.writeUInt16BE(4096, 16);
-    page[18] = 1;  // write version
-    page[19] = 1;  // read version
-    page[20] = 0;  // reserved space
-    page[21] = 64; // max embedded payload fraction
-    page[22] = 32; // min embedded payload fraction
-    page[23] = 32; // leaf payload fraction
-    page.writeUInt32BE(1, 28);   // page_count = 1
-    page.writeUInt32BE(999, 32); // corrupt freelist trunk
-    page.writeUInt32BE(5, 36);   // freelist count = 5
-
-    fs.writeFileSync(dbPath, page);
-
-    // Should throw — VACUUM cannot save a thoroughly corrupt file
-    assert.throws(
-      () => openDatabase(dbPath),
-      /./,
-      'should throw for unrecoverable corruption',
-    );
-
-    cleanup(dbPath);
-  });
-});

package/src/resources/extensions/gsd/tests/validate-directory.test.ts

@@ -1,237 +0,0 @@
-/**
- * Unit tests for GSD Directory Validation — safeguards against dangerous directories.
- *
- * Exercises validateDirectory() and assertSafeDirectory() with:
- * - Blocked system paths (/, /usr, /etc, $HOME, C:\Windows)
- * - Temp directory root
- * - Normal project directories (should pass)
- * - Directories with many entries (warning heuristic)
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir, homedir, platform } from "node:os";
-import { validateDirectory, assertSafeDirectory } from "../validate-directory.ts";
-
-const isWindows = platform() === "win32";
-
-function makeTempDir(prefix: string): string {
-  const dir = join(
-    tmpdir(),
-    `gsd-validate-test-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-  );
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-// ─── Blocked system paths (Unix) ─────────────────────────────────────────────────
-
-test("validateDirectory: root filesystem is blocked", { skip: isWindows ? "Unix-only test" : undefined }, () => {
-  const result = validateDirectory("/");
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-  assert.ok(result.reason?.includes("system directory"));
-});
-
-test("validateDirectory: /usr is blocked", { skip: isWindows ? "Unix-only test" : undefined }, () => {
-  const result = validateDirectory("/usr");
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-});
-
-test("validateDirectory: /etc is blocked", { skip: isWindows ? "Unix-only test" : undefined }, () => {
-  const result = validateDirectory("/etc");
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-});
-
-test("validateDirectory: /var is blocked", { skip: isWindows ? "Unix-only test" : undefined }, () => {
-  const result = validateDirectory("/var");
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-});
-
-test("validateDirectory: /usr/local/bin is blocked", { skip: isWindows ? "Unix-only test" : undefined }, () => {
-  const result = validateDirectory("/usr/local/bin");
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-});
-
-// ─── Blocked system paths (Windows) ──────────────────────────────────────────────
-
-test("validateDirectory: C:\\ is blocked", { skip: !isWindows ? "Windows-only test" : undefined }, () => {
-  const result = validateDirectory("C:\\");
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-  assert.ok(result.reason?.includes("system directory"));
-});
-
-test("validateDirectory: C:\\Windows is blocked", { skip: !isWindows ? "Windows-only test" : undefined }, () => {
-  const result = validateDirectory("C:\\Windows");
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-});
-
-// ─── Home directory (cross-platform) ─────────────────────────────────────────────
-
-test("validateDirectory: home directory itself is blocked", () => {
-  const result = validateDirectory(homedir());
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-  assert.ok(result.reason?.includes("home directory"));
-});
-
-test("validateDirectory: home directory with trailing slash is blocked", () => {
-  const sep = isWindows ? "\\" : "/";
-  const result = validateDirectory(homedir() + sep);
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-});
-
-test("validateDirectory: subdirectory of home is NOT blocked", () => {
-  const dir = makeTempDir("home-subdir");
-  try {
-    const result = validateDirectory(dir);
-    assert.equal(result.severity, "ok");
-    assert.equal(result.safe, true);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// Regression test for #1317: GSD worktree inside $HOME must not be blocked even
-// when the resolved project root equals $HOME (e.g. home dir is a git repo).
-test("validateDirectory: GSD worktree path nested under home is NOT blocked (#1317)", () => {
-  const worktreePath = join(homedir(), ".gsd", "worktrees", "M001");
-  mkdirSync(worktreePath, { recursive: true });
-  try {
-    // The worktree CWD itself is a valid location — it must pass.
-    const result = validateDirectory(worktreePath);
-    assert.equal(result.safe, true, "GSD worktree path should be safe to run in");
-    assert.equal(result.severity, "ok");
-  } finally {
-    rmSync(join(homedir(), ".gsd", "worktrees", "M001"), { recursive: true, force: true });
-  }
-});
-
-// ─── Temp directory root ─────────────────────────────────────────────────────────
-
-test("validateDirectory: temp directory root is blocked", () => {
-  const result = validateDirectory(tmpdir());
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-  assert.ok(result.reason?.includes("temp directory"));
-});
-
-// ─── Normal project directories ──────────────────────────────────────────────────
-
-test("validateDirectory: normal project directory is safe", () => {
-  const dir = makeTempDir("normal-project");
-  try {
-    writeFileSync(join(dir, "package.json"), "{}");
-    mkdirSync(join(dir, "src"));
-    const result = validateDirectory(dir);
-    assert.equal(result.safe, true);
-    assert.equal(result.severity, "ok");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("validateDirectory: empty directory is safe", () => {
-  const dir = makeTempDir("empty");
-  try {
-    const result = validateDirectory(dir);
-    assert.equal(result.safe, true);
-    assert.equal(result.severity, "ok");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// ─── High entry count heuristic ──────────────────────────────────────────────────
-
-test("validateDirectory: directory with >200 entries triggers warning", () => {
-  const dir = makeTempDir("many-entries");
-  try {
-    for (let i = 0; i < 210; i++) {
-      writeFileSync(join(dir, `file-${i.toString().padStart(4, "0")}.txt`), "");
-    }
-    const result = validateDirectory(dir);
-    assert.equal(result.safe, false);
-    assert.equal(result.severity, "warning");
-    assert.ok(result.reason?.includes("210 entries"));
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("validateDirectory: directory with exactly 200 entries is safe", () => {
-  const dir = makeTempDir("boundary-entries");
-  try {
-    for (let i = 0; i < 200; i++) {
-      writeFileSync(join(dir, `file-${i.toString().padStart(4, "0")}.txt`), "");
-    }
-    const result = validateDirectory(dir);
-    assert.equal(result.safe, true);
-    assert.equal(result.severity, "ok");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// ─── assertSafeDirectory ─────────────────────────────────────────────────────────
-
-test("assertSafeDirectory: throws for blocked directories", { skip: isWindows ? "Unix-only test" : undefined }, () => {
-  assert.throws(
-    () => assertSafeDirectory("/"),
-    (err: Error) => err.message.includes("system directory"),
-  );
-});
-
-test("assertSafeDirectory: throws for home directory", () => {
-  assert.throws(
-    () => assertSafeDirectory(homedir()),
-    (err: Error) => err.message.includes("home directory"),
-  );
-});
-
-test("assertSafeDirectory: returns result for warnings (does not throw)", () => {
-  const dir = makeTempDir("assert-warning");
-  try {
-    for (let i = 0; i < 210; i++) {
-      writeFileSync(join(dir, `file-${i.toString().padStart(4, "0")}.txt`), "");
-    }
-    const result = assertSafeDirectory(dir);
-    assert.equal(result.severity, "warning");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("assertSafeDirectory: returns ok for safe directories", () => {
-  const dir = makeTempDir("assert-safe");
-  try {
-    const result = assertSafeDirectory(dir);
-    assert.equal(result.severity, "ok");
-    assert.equal(result.safe, true);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// ─── Trailing slash normalization ────────────────────────────────────────────────
-
-test("validateDirectory: handles paths with trailing slashes", { skip: isWindows ? "Unix-only test" : undefined }, () => {
-  const result = validateDirectory("/usr/");
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-});
-
-test("validateDirectory: handles paths with multiple trailing slashes", { skip: isWindows ? "Unix-only test" : undefined }, () => {
-  const result = validateDirectory("/etc///");
-  assert.equal(result.safe, false);
-  assert.equal(result.severity, "blocked");
-});

package/src/resources/extensions/gsd/tests/validate-milestone-write-order.test.ts

@@ -1,115 +0,0 @@
-import { describe, it, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { randomUUID } from "node:crypto";
-
-import { handleValidateMilestone } from "../tools/validate-milestone.js";
-import { openDatabase, closeDatabase, _getAdapter, insertMilestone, insertSlice } from "../gsd-db.js";
-import { clearPathCache } from "../paths.js";
-import { clearParseCache } from "../files.js";
-
-function makeTmpBase(): string {
-  const base = join(tmpdir(), `gsd-val-handler-${randomUUID()}`);
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-  return base;
-}
-
-const VALID_PARAMS = {
-  milestoneId: "M001",
-  verdict: "pass" as const,
-  remediationRound: 0,
-  successCriteriaChecklist: "- [x] All pass",
-  sliceDeliveryAudit: "| S01 | delivered |",
-  crossSliceIntegration: "No issues",
-  requirementCoverage: "All covered",
-  verificationClasses: "- Contract: covered\n- Integration: covered\n- Operational: gap noted",
-  verdictRationale: "Everything checks out",
-};
-
-describe("handleValidateMilestone write ordering (#2725)", () => {
-  let base: string;
-
-  afterEach(() => {
-    clearPathCache();
-    clearParseCache();
-    try { closeDatabase(); } catch { /* */ }
-    if (base) {
-      try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
-    }
-  });
-
-  it("writes DB row and disk file on success", async () => {
-    base = makeTmpBase();
-    const dbPath = join(base, ".gsd", "gsd.db");
-    openDatabase(dbPath);
-    insertMilestone({ id: "M001" });
-    insertSlice({ id: "S01", milestoneId: "M001" });
-
-    const result = await handleValidateMilestone(VALID_PARAMS, base);
-    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
-
-    // DB row exists
-    const adapter = _getAdapter()!;
-    const row = adapter.prepare(
-      `SELECT status, scope FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
-    ).get() as { status: string; scope: string } | undefined;
-    assert.ok(row, "assessment row should exist in DB");
-    assert.equal(row!.status, "pass");
-
-    // Disk file exists
-    const filePath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
-    assert.ok(existsSync(filePath), "VALIDATION.md should exist on disk");
-    const validationMd = readFileSync(filePath, "utf-8");
-    assert.match(validationMd, /## Verification Class Compliance/);
-    assert.match(validationMd, /- Contract: covered/);
-    assert.match(validationMd, /## Verdict Rationale/);
-  });
-
-  it("omits verification class section when no verification classes are supplied", async () => {
-    base = makeTmpBase();
-    const dbPath = join(base, ".gsd", "gsd.db");
-    openDatabase(dbPath);
-    insertMilestone({ id: "M001" });
-    insertSlice({ id: "S01", milestoneId: "M001" });
-
-    const result = await handleValidateMilestone(
-      { ...VALID_PARAMS, verificationClasses: undefined },
-      base,
-    );
-    assert.ok(!("error" in result), `unexpected error: ${"error" in result ? result.error : ""}`);
-
-    const filePath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
-    const validationMd = readFileSync(filePath, "utf-8");
-    assert.doesNotMatch(validationMd, /## Verification Class Compliance/);
-  });
-
-  it("rolls back DB row when disk write fails", async () => {
-    base = makeTmpBase();
-    const dbPath = join(base, ".gsd", "gsd.db");
-    openDatabase(dbPath);
-    insertMilestone({ id: "M001" });
-    insertSlice({ id: "S01", milestoneId: "M001" });
-
-    // Force disk write failure by replacing the milestone directory with a
-    // regular file. saveFile() will fail because it cannot write inside a
-    // non-directory. This works cross-platform (chmod is ignored on Windows).
-    const milestoneDir = join(base, ".gsd", "milestones", "M001");
-    rmSync(milestoneDir, { recursive: true, force: true });
-    writeFileSync(milestoneDir, "not-a-directory");
-
-    const result = await handleValidateMilestone(VALID_PARAMS, base);
-
-    // Should return error
-    assert.ok("error" in result, "should return error when disk write fails");
-    assert.ok(result.error.includes("disk render failed"));
-
-    // DB row should have been rolled back (deleted)
-    const adapter = _getAdapter()!;
-    const row = adapter.prepare(
-      `SELECT * FROM assessments WHERE milestone_id = 'M001' AND scope = 'milestone-validation'`,
-    ).get();
-    assert.equal(row, undefined, "assessment row should be deleted after disk-write rollback");
-  });
-});