@tekyzinc/gsd-t 3.26.11 → 3.29.10

package/scripts/gsd-t-context-meter.test.js

@@ -384,3 +384,88 @@ test("12. clock injection — timestamp uses injected clock", async () => {
   const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
   assert.equal(state.timestamp, fixed.toISOString());
 });
+
+/* ── M-fix: model-aware context window (the reported regression) ───────── */
+
+test("13. Opus 4.7 @ ~36% of a 1M window stays 'normal' (regression repro)", async () => {
+  // The exact reported symptom: ~360k tokens used on an Opus 4.7 session.
+  // With the old hardcoded 200k window this computed 180% → premature
+  // headless handoff at ~64% of context REMAINING. With model-aware sizing
+  // the window is 1M, so 360k = 36% = normal, no handoff.
+  seedState(tmpRoot, { checkCount: 4 });
+
+  const out = await runMeter({
+    payload: makePayload(),
+    projectRoot: tmpRoot,
+    _loadConfig: () => makeConfig(), // config still says 200k — must be overridden
+    _parseTranscript: async () => ({ ...FAKE_PARSED, model: "claude-opus-4-7" }),
+    _estimateTokens: () => ({ inputTokens: 360000 }),
+  });
+
+  // No handoff marker — this is the whole point of the fix.
+  assert.deepEqual(out, {});
+
+  const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
+  assert.equal(state.modelWindowSize, 1_000_000, "window resolved from model, not config");
+  assert.equal(state.pct, 36, "360k / 1M = 36%");
+  assert.equal(state.threshold, "normal");
+});
+
+test("14. Opus 4.7 @ 80% of the true 1M window DOES hand off", async () => {
+  // The handoff must still fire at the real 75% threshold against the
+  // corrected window — we keep the guard, we just size it correctly.
+  seedState(tmpRoot, { checkCount: 4 });
+
+  const out = await runMeter({
+    payload: makePayload(),
+    projectRoot: tmpRoot,
+    _loadConfig: () => makeConfig(),
+    _parseTranscript: async () => ({ ...FAKE_PARSED, model: "claude-opus-4-7-20260115" }),
+    _estimateTokens: () => ({ inputTokens: 800000 }), // 80% of 1M > 75%
+  });
+
+  assert.equal(out.additionalContext, "next-spawn-headless:true");
+  const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
+  assert.equal(state.modelWindowSize, 1_000_000);
+  assert.equal(state.pct, 80);
+  assert.equal(state.threshold, "threshold");
+});
+
+test("15. no model in transcript → falls back to config window (back-compat)", async () => {
+  // Existing transcripts / stubs without a model field must behave exactly
+  // as before: config's modelWindowSize governs.
+  seedState(tmpRoot, { checkCount: 4 });
+
+  const out = await runMeter({
+    payload: makePayload(),
+    projectRoot: tmpRoot,
+    _loadConfig: () => makeConfig({ modelWindowSize: 200000 }),
+    _parseTranscript: async () => FAKE_PARSED, // no `model` key
+    _estimateTokens: () => ({ inputTokens: 160000 }), // 80% of 200k
+  });
+
+  assert.equal(out.additionalContext, "next-spawn-headless:true");
+  const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
+  assert.equal(state.modelWindowSize, 200000);
+  assert.equal(state.pct, 80);
+});
+
+test("16. Haiku session correctly sized at 200k (not over-large 1M)", async () => {
+  seedState(tmpRoot, { checkCount: 4 });
+
+  const out = await runMeter({
+    payload: makePayload(),
+    projectRoot: tmpRoot,
+    _loadConfig: () => makeConfig(),
+    _parseTranscript: async () => ({
+      ...FAKE_PARSED,
+      model: "claude-haiku-4-5-20251001",
+    }),
+    _estimateTokens: () => ({ inputTokens: 170000 }), // 85% of 200k
+  });
+
+  assert.equal(out.additionalContext, "next-spawn-headless:true");
+  const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
+  assert.equal(state.modelWindowSize, 200000);
+  assert.equal(state.pct, 85);
+});

package/scripts/gsd-t-date-guard.js

@@ -89,18 +89,25 @@ const FRESH_STAMP_PATTERNS = [
 ];
 
 // Generic ISO date — only validated when surrounded by strong "freshly stamping now"
-// context (e.g., right after labels like "Date:", "Today:", "Stamped:", etc.).
-// Two arms: (a) date+time (validated against full ±DRIFT_MINUTES window),
+// context (e.g., right after labels like the canonical frontmatter / metadata
+// keys captured below).
+// Two arms: (a) date+time (validated against full +/-DRIFT_MINUTES window),
 //          (b) date-only (validated as same-calendar-day-as-now, time-of-day ignored).
+//
+// M59 (v3.29.10): time portion may carry an optional trailing TZ token —
+// either a short abbreviation (PDT/PST/UTC/...), a numeric offset
+// (+/-HH:MM or +/-HHMM), or Z. The TZ is matched but not used for drift
+// math — drift is computed against the local clock, which already has the
+// live offset.
 const STAMPED_ISO_PATTERN = {
   name: "stamped-iso",
-  regex: /\b(?:Date|Today|Stamped|Updated|Created|Generated|Now|Timestamp|At)\s*[:=]\s*(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2}))?/gi,
+  regex: /\b(?:Date|Today|Stamped|Updated|Created|Generated|Now|Timestamp|At)\s*[:=]\s*(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::\d{2})?(?:\s+[A-Z]{2,5}|[+\-]\d{2}:?\d{2}|Z)?)?/gi,
   extract: (m) => {
     const hasTime = m[4] !== undefined;
     return {
       stamped: new Date(
         Number(m[1]), Number(m[2]) - 1, Number(m[3]),
-        hasTime ? Number(m[4]) : 12, // Date-only → noon, neutralizes timezone-edge false positives
+        hasTime ? Number(m[4]) : 12, // Date-only -> noon, neutralizes timezone-edge false positives
         hasTime ? Number(m[5]) : 0,
         0
       ),
@@ -109,6 +116,20 @@ const STAMPED_ISO_PATTERN = {
   },
 };
 
+// M59 (v3.29.10): table cells in progress.md's "Completed Milestones" and
+// "Session Log" tables now carry `YYYY-MM-DD HH:MM TZ`. We validate them
+// against +/-DRIFT_MINUTES (treat as a fresh stamp). Date-only cells in
+// pre-3.29.10 rows remain valid and are NOT flagged - those are historical
+// (forward-only rule), so this regex requires the HH:MM portion to fire.
+const PROGRESS_TABLE_CELL_PATTERN = {
+  name: "progress-table-cell",
+  regex: /\|\s*(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2})(?:\s+[A-Z]{2,5})?\s*\|/g,
+  extract: (m) => new Date(
+    Number(m[1]), Number(m[2]) - 1, Number(m[3]),
+    Number(m[4]), Number(m[5]), 0
+  ),
+};
+
 function isAllowlisted(filePath) {
   if (!filePath) return false;
   return ALLOWLIST_PATTERNS.some((re) => re.test(filePath));
@@ -119,7 +140,7 @@ function findStaleTimestamps(content, now, oldContent) {
   const findings = [];
   const oldText = typeof oldContent === "string" ? oldContent : "";
 
-  const allPatterns = [...FRESH_STAMP_PATTERNS, STAMPED_ISO_PATTERN];
+  const allPatterns = [...FRESH_STAMP_PATTERNS, STAMPED_ISO_PATTERN, PROGRESS_TABLE_CELL_PATTERN];
 
   for (const pattern of allPatterns) {
     const regex = new RegExp(pattern.regex.source, pattern.regex.flags);

package/scripts/gsd-t-design-review-server.js

@@ -13,6 +13,7 @@ const http = require("http");
 const { spawn } = require("child_process");
 const fs = require("fs");
 const path = require("path");
+const { localIsoWithOffset } = require(path.join(__dirname, "..", "bin", "gsd-t-time-format.cjs"));
 const url = require("url");
 
 // ── CLI args ──────────────────────────────────────────────────────────
@@ -422,7 +423,8 @@ function writeFeedback(items) {
   fs.writeFileSync(
     path.join(REVIEW_DIR, "review-complete.json"),
     JSON.stringify({
-      completedAt: new Date().toISOString(),
+      // M59 (v3.29.10): local-offset ISO (`YYYY-MM-DDTHH:MM:SS±HH:MM`) rather than UTC `Z`.
+      completedAt: localIsoWithOffset(),
       phase: readStatus().phase,
       items: items.map(i => ({ id: i.id, verdict: i.verdict })),
     }, null, 2)

package/templates/CLAUDE-global.md

@@ -167,11 +167,13 @@ Whenever you write a date or timestamp to any file — decision log entries in `
 2. If absent, run `node -e "console.log(new Date().toISOString())"` via Bash before writing.
 
 **Enforcement**: a PreToolUse hook (`scripts/gsd-t-date-guard.js`) blocks Write/Edit calls whose content contains timestamps drifting more than ±5 minutes from the live system clock. The guard:
-- Validates decision-log entries (`- YYYY-MM-DD HH:MM:`), filename timestamps (`continue-here-YYYY-MM-DDTHHMMSS`), banners (`Day: Mon DD, YYYY HH:MM`), and labeled stamps (`Date:`, `Updated:`, `Created:`, etc.).
+- Validates decision-log entries (`- YYYY-MM-DD HH:MM:`), filename timestamps (`continue-here-YYYY-MM-DDTHHMMSS`), banners (`Day: Mon DD, YYYY HH:MM`), labeled stamps (`Date:`, `Updated:`, `Created:`, etc., with optional TZ abbr / numeric offset / `Z`), and **progress.md table cells carrying `YYYY-MM-DD HH:MM TZ`** (M59, v3.29.10+ — Completed Milestones + Session Log).
 - For Edit, ignores timestamps that appear in BOTH `old_string` and `new_string` (pre-existing context, not new writes).
 - Allowlists machine-written paths (`.gsd-t/events/`, `.gsd-t/transcripts/`, `.gsd-t/metrics/`, `.git/`, `node_modules/`, archives, log files).
 - Fails open on internal error — broken tool calls would be worse than drift.
 
+**Timestamp precision in progress.md (M59, v3.29.10+)**: the `## Date:` frontmatter line, the "Completed" cell of the Completed Milestones table, and the "Date" cell of the Session Log table MUST be written as `YYYY-MM-DD HH:MM TZ` (e.g. `2026-05-27 10:15 PDT`). This is **forward-only** — pre-3.29.10 rows that read date-only (`YYYY-MM-DD`) stay as-is. Readers (status, dashboard, GSD-T-Board) MUST accept both. `archive-meta.json::completedAt` is local-offset ISO (`YYYY-MM-DDTHH:MM:SS±HH:MM`) — use `localIsoWithOffset()` from `bin/gsd-t-time-format.cjs`, not `new Date().toISOString()` (which produces UTC `Z`).
+
 If the guard blocks your write, do NOT bypass it. Re-read `[GSD-T NOW]`, regenerate the timestamp, retry.
 
 ## Conversation vs. Work
@@ -260,6 +262,34 @@ Every Playwright assertion must verify one of:
 
 **If a test would pass on an empty HTML page with the correct element IDs and no JavaScript, it is not a functional test.** Rewrite it.
 
+### Test Data Cleanup (MANDATORY — M58)
+
+**Tests that insert data into a project's stores MUST register those inserts with the GSD-T test-data ledger so Verify can purge them.** Tests that leave orphaned `E2E_*` records in production data violate this rule.
+
+The supported mechanism is the `withTestData()` Playwright fixture:
+
+```ts
+import { test as base } from '@playwright/test';
+import { withTestData } from '@tekyzinc/gsd-t/templates/test-helpers/test-data-fixture';
+
+export const test = base.extend(withTestData());
+
+test('drag idea creates new column', async ({ page, testData }) => {
+  const id = testData.tag('E2E_DRAG');  // → "E2E_DRAG_{runId}_{counter}"
+  await testData.register({
+    kind: 'localStorage-key-prefix',
+    store: 'gsd-t-board:idea:',
+    id,
+    taggedPrefix: 'E2E_',
+  });
+  // … UI interactions that insert a row keyed by `${store}${id}` …
+});
+```
+
+Three built-in adapters: `localStorage-key-prefix`, `file-json-array`, `sqlite-table-where`. Extend via `registerAdapter(kind, adapter)`. Each adapter refuses to delete a record whose id does not start with the ledger row's `taggedPrefix` (defense in depth — see `.gsd-t/contracts/test-data-tagging-contract.md`).
+
+After the E2E suite, `gsd-t-verify` Step 4.5 runs `gsd-t test-data --purge --run "$GSD_T_VERIFY_RUN_ID"`. If any adapter throws or refuses, verify FAILs the gate (block-promotion semantics — equivalent to a failing CI-Parity Gate). Contract: `.gsd-t/contracts/test-data-ledger-contract.md` v1.0.0 STABLE.
+
 ## QA Agent (Mandatory)
 
 Every code-producing/validating phase MUST run QA. QA writes ZERO feature code — it generates, runs, and gap-reports tests. Failure (or any shallow E2E test) blocks phase completion.
@@ -537,6 +567,12 @@ BEFORE EVERY COMMIT:
   │     YES → Verify test names and paths are referenced in requirements
   ├── Did I change UI, routes, or user flows?
   │     YES → Update affected E2E test specs (Playwright/Cypress)
+  ├── Did I add a new top-level dir, or change build/CI config?
+  │     This is ENFORCED MECHANICALLY by `gsd-t-verify` Step 2.6
+  │     (CI-Parity Gate: `gsd-t build-coverage` + `gsd-t ci-parity`,
+  │     FAIL-blocking). You do NOT self-attest this — verify runs the
+  │     real CI build. It exists because TimeTracking v1.10.12 shipped
+  │     VERIFIED+tagged with a new dir absent from the Dockerfile COPY.
   └── Did I run the affected tests?
         YES → Verify they pass. NO → Run them now.
 ```

package/templates/progress.md

@@ -3,7 +3,7 @@
 ## Project: {Project Name}
 ## Version: 0.1.0
 ## Status: READY
-## Date: {Date}
+## Date: {YYYY-MM-DD HH:MM TZ}
 
 ## Current Milestone
 None — ready for next milestone
@@ -11,6 +11,8 @@ None — ready for next milestone
 ## Completed Milestones
 | Milestone | Version | Completed | Tag |
 |-----------|---------|-----------|-----|
+<!-- M59: "Completed" cell format is `YYYY-MM-DD HH:MM TZ` for entries written ≥ v3.29.10; older rows may be `YYYY-MM-DD`. Readers MUST accept both. -->
+
 
 ## Domains
 | Domain | Status | Tasks | Completed |
@@ -37,4 +39,6 @@ None — ready for next milestone
 ## Session Log
 | Date | Session | What was accomplished |
 |------|---------|----------------------|
-| {Date} | 1 | Project initialized |
+| {YYYY-MM-DD HH:MM TZ} | 1 | Project initialized |
+<!-- M59: "Date" cell format is `YYYY-MM-DD HH:MM TZ` for entries written ≥ v3.29.10; older rows may be `YYYY-MM-DD`. Readers MUST accept both. -->
+

package/templates/test-helpers/README.md

@@ -0,0 +1,98 @@
+# GSD-T Test Helpers
+
+Helpers that test suites can import to keep test data out of production stores.
+
+## `test-data-fixture.ts`
+
+Playwright fixture (`withTestData`) that auto-registers test inserts with the
+GSD-T test-data ledger. After Playwright finishes, the verify-final-step
+(`gsd-t-verify` Step 4.5) sweeps the ledger and purges every registered row.
+
+### Install
+
+```ts
+// playwright.config.ts (no changes — fixture is plugged in per-spec or via a base test)
+
+// test/_base.ts
+import { test as base } from '@playwright/test';
+import { withTestData } from '@tekyzinc/gsd-t/templates/test-helpers/test-data-fixture';
+
+export const test = base.extend(withTestData());
+export { expect } from '@playwright/test';
+```
+
+### Use
+
+```ts
+import { test } from './_base';
+
+test('drag idea creates new column', async ({ page, testData }) => {
+  const id = testData.tag('E2E_DRAG');
+  await testData.register({
+    kind: 'localStorage-key-prefix',
+    store: 'gsd-t-board:idea:',
+    id,
+    taggedPrefix: 'E2E_',
+  });
+
+  // ... interact with the UI; the app inserts a row keyed by `gsd-t-board:idea:${id}` ...
+});
+```
+
+### Tagging Convention
+
+All IDs that flow through `testData.register()` MUST start with a recognized
+prefix. Defaults to `E2E_`. Projects can declare additional prefixes in
+`.gsd-t/test-data-config.json`:
+
+```json
+{ "taggedPrefixes": ["E2E_", "FIXTURE_", "INTEGRATION_"] }
+```
+
+`testData.tag(prefix)` composes IDs of the form
+`{PREFIX}_{verifyRunId}_{counter}` — e.g.
+`E2E_DRAG_verify-m58-20260527T091800Z_3`.
+
+### How purge happens
+
+1. Each call to `testData.register(...)` appends a JSONL row to
+   `.gsd-t/test-data-ledger.jsonl`.
+2. After Playwright runs, `gsd-t-verify` Step 4.5 executes
+   `gsd-t test-data --purge --run "$GSD_T_VERIFY_RUN_ID"`.
+3. The ledger is read; each row is dispatched to its `kind`'s adapter; the
+   adapter removes the record from the store (or reports `absent` /
+   structured `error`).
+4. If any row produces an error, verify FAILs the Test Data Cleanup Gate
+   (block-promotion semantics — equivalent to a failing CI-Parity Gate).
+
+### Opt-in per-test purge
+
+For long suites where you want to clean up after every test, pass
+`purgePerTest: true`:
+
+```ts
+export const test = base.extend(withTestData({ purgePerTest: true }));
+```
+
+This invokes `purgeRunInserts` in the fixture's `afterEach` instead of
+deferring to the verify-final-step. Most suites should leave it off — the
+verify step is the canonical sweep and avoids per-test overhead.
+
+### Verify-run id
+
+The fixture reads `process.env.GSD_T_VERIFY_RUN_ID` and uses it as the
+ledger `runId`. `gsd-t-verify` sets this at the top of the verify run as
+`verify-${MILESTONE}-$(date -u +%Y%m%dT%H%M%SZ)`. For local development
+runs (where the env var is absent), the fixture falls back to
+`local-${randomUUID()}` so the ledger is still coherent.
+
+### What this does NOT do
+
+- It does NOT enforce that every test uses the fixture — the gate works by
+  finding orphans, not by lint. A test that bypasses the fixture and inserts
+  data the gate doesn't know about will leave that data behind.
+- It does NOT clean up data inserted before the suite started — that's a
+  pre-existing data hygiene concern.
+- It does NOT roll back database transactions. Use it for additive inserts
+  (rows, keys, files); for transactional cleanup, use your store's native
+  rollback.

package/templates/test-helpers/test-data-fixture.ts

@@ -0,0 +1,153 @@
+/**
+ * GSD-T M58 — Playwright Test Data fixture
+ *
+ * Auto-registers test data inserts with the GSD-T ledger so the Test Data
+ * Cleanup Gate (gsd-t-verify Step 4.5) can purge them after the suite.
+ *
+ * Usage:
+ *
+ *   import { test as base } from '@playwright/test';
+ *   import { withTestData } from '@tekyzinc/gsd-t/templates/test-helpers/test-data-fixture';
+ *
+ *   export const test = base.extend(withTestData());
+ *
+ *   test('drag idea creates new column', async ({ page, testData }) => {
+ *     const id = testData.tag('E2E_DRAG');
+ *     await testData.register({
+ *       kind: 'localStorage-key-prefix',
+ *       store: 'gsd-t-board:idea:',
+ *       id,
+ *       taggedPrefix: 'E2E_',
+ *     });
+ *     // ... UI interactions that insert {key: 'gsd-t-board:idea:' + id} ...
+ *   });
+ *
+ * Tagging convention: `{PREFIX}_{verifyRunId}_{counter}`.
+ *
+ * Run id comes from `process.env.GSD_T_VERIFY_RUN_ID` (set by gsd-t-verify).
+ * If absent, the fixture falls back to a per-process UUID so local runs still
+ * write a coherent ledger.
+ */
+
+import { randomUUID } from 'node:crypto';
+import * as path from 'node:path';
+
+// Resolve the ledger module path at runtime so this template file does not
+// require build-time linkage to the published package.
+function resolveLedger(): {
+  appendInsert: (row: LedgerRow) => { ok: boolean; ledgerPath: string };
+} {
+  // Caller can override via env (used by synthetic suites under test/fixtures/m58-d2/).
+  const override = process.env.GSD_T_LEDGER_MODULE_PATH;
+  const modulePath = override
+    ? path.resolve(override)
+    : require.resolve('@tekyzinc/gsd-t/bin/gsd-t-test-data-ledger.cjs');
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  return require(modulePath);
+}
+
+type AdapterKind = 'localStorage-key-prefix' | 'file-json-array' | 'sqlite-table-where' | string;
+
+interface LedgerRow {
+  projectDir: string;
+  runId: string;
+  kind: AdapterKind;
+  store: string;
+  id: string;
+  taggedPrefix?: string;
+  insertedAt?: string;
+}
+
+export interface TestDataHandle {
+  /**
+   * Compose a tagged identifier of the form `{PREFIX}_{runId}_{counter}`.
+   * Default prefix is `E2E_`.
+   */
+  tag(prefix?: string): string;
+
+  /**
+   * Record an insert in the ledger. Must be called before / immediately
+   * after the test inserts the row in its store so the verify-final-step
+   * can purge it.
+   */
+  register(opts: {
+    kind: AdapterKind;
+    store: string;
+    id: string;
+    taggedPrefix?: string;
+  }): Promise<void>;
+
+  /**
+   * The runId this fixture is writing under (read-only).
+   */
+  readonly runId: string;
+}
+
+export interface WithTestDataOptions {
+  /**
+   * Project directory (defaults to process.cwd()).
+   */
+  projectDir?: string;
+
+  /**
+   * Default tag prefix when `tag()` is called without one (defaults to `E2E_`).
+   */
+  defaultPrefix?: string;
+
+  /**
+   * Opt-in: per-test purge in `test.afterEach`. Default false — the canonical
+   * purge point is gsd-t-verify Step 4.5 (`gsd-t test-data --purge --run`).
+   */
+  purgePerTest?: boolean;
+}
+
+export function withTestData(opts: WithTestDataOptions = {}) {
+  const projectDir = opts.projectDir || process.cwd();
+  const defaultPrefix = opts.defaultPrefix || 'E2E_';
+  const runId = process.env.GSD_T_VERIFY_RUN_ID || `local-${randomUUID()}`;
+
+  // Playwright fixture factory shape: { testData: [async ({}, use) => {...}, { scope: 'test' }] }
+  return {
+    testData: [
+      async ({}, use: (handle: TestDataHandle) => Promise<void>) => {
+        let counter = 0;
+        const ledger = resolveLedger();
+        const handle: TestDataHandle = {
+          runId,
+          tag(prefix?: string) {
+            const p = prefix || defaultPrefix;
+            counter += 1;
+            // Normalise prefix to end with '_' so composed IDs match the
+            // taggedPrefix the adapter will guard against.
+            const base = p.endsWith('_') ? p : `${p}_`;
+            return `${base}${runId}_${counter}`;
+          },
+          async register({ kind, store, id, taggedPrefix }) {
+            const prefix = taggedPrefix || defaultPrefix;
+            ledger.appendInsert({
+              projectDir,
+              runId,
+              kind,
+              store,
+              id,
+              taggedPrefix: prefix,
+            });
+          },
+        };
+        await use(handle);
+        // Per-test purge is opt-in; canonical sweep is the verify-final-step.
+        if (opts.purgePerTest) {
+          // Lazy-load purgeRunInserts only when opted in.
+          // eslint-disable-next-line @typescript-eslint/no-var-requires
+          const ledgerMod = require(
+            process.env.GSD_T_LEDGER_MODULE_PATH
+              ? path.resolve(process.env.GSD_T_LEDGER_MODULE_PATH)
+              : '@tekyzinc/gsd-t/bin/gsd-t-test-data-ledger.cjs',
+          );
+          await ledgerMod.purgeRunInserts({ projectDir, runId });
+        }
+      },
+      { scope: 'test' },
+    ],
+  };
+}