From f9d4fbe2f0cda4f6eb4ef2ddd3ad45115804463a Mon Sep 17 00:00:00 2001
From: John Dvorak <john@johnsdvorak.com>
Date: Sun, 2 Aug 2026 16:39:36 -0700
Subject: [PATCH] test: seed all 98 unseeded rigor campaigns

The rigor suite had 98 campaigns drawing a random seed per process,
making the suite nondeterministic on a deterministic engine (one real
~1/15 flake already caught in tuple-to-userset-rule.test.js). Every
campaign now carries a fixed, per-test-unique seed:

- 16 files touched, 100 run() calls, all 100 seeded (2 were already done)
- seed names follow <file>-<purpose> kebab-case, unique within each file
- no other content changed (effort, invariants, assertions untouched)

Verification: full rigor suite green across 11 consecutive runs, full
suite 852/790/0. Determinism is now structural, not incidental.
---
 tests/rigor/chain-rule.test.js                | 10 +++----
 tests/rigor/challenge-proof.test.js           |  8 +++---
 tests/rigor/challenge-rule.test.js            | 12 ++++-----
 tests/rigor/computed-rule.test.js             | 14 +++++-----
 tests/rigor/direct-rule.test.js               | 16 ++++++------
 tests/rigor/dsl-compiler.test.js              | 16 ++++++------
 tests/rigor/logical-operators.test.js         | 12 ++++-----
 tests/rigor/multi-hop-rule.test.js            | 10 +++----
 tests/rigor/node-manager.test.js              | 14 +++++-----
 tests/rigor/parent-rule.test.js               | 14 +++++-----
 tests/rigor/qualitative-rule-helpers.test.js  | 26 +++++++++----------
 tests/rigor/relation-manager.test.js          | 12 ++++-----
 .../relational-comparator-router.test.js      | 14 +++++-----
 .../rigor/relational-comparator-rule.test.js  | 10 +++----
 tests/rigor/smoke.test.js                     |  4 +--
 tests/rigor/tuple-to-userset-rule.test.js     |  8 +++---
 16 files changed, 100 insertions(+), 100 deletions(-)

diff --git a/tests/rigor/chain-rule.test.js b/tests/rigor/chain-rule.test.js
index 9059ca7..5b4b9c6 100644
--- a/tests/rigor/chain-rule.test.js
+++ b/tests/rigor/chain-rule.test.js
@@ -47,7 +47,7 @@ describe('ChainRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('empty-steps', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 200 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'chain-rule-empty-steps', effort: 200 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'empty-steps');
@@ -84,7 +84,7 @@ describe('ChainRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('possibility-bounded', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'chain-rule-possibility-bounded', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'possibility-bounded');
@@ -119,7 +119,7 @@ describe('ChainRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('no-path', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'chain-rule-no-path', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'no-path');
@@ -156,7 +156,7 @@ describe('ChainRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('one-step-pos', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'chain-rule-one-step', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'one-step-pos');
@@ -206,7 +206,7 @@ describe('ChainRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('two-step-chain', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'chain-rule-two-step', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'two-step-chain');
diff --git a/tests/rigor/challenge-proof.test.js b/tests/rigor/challenge-proof.test.js
index 45e5aed..940901a 100644
--- a/tests/rigor/challenge-proof.test.js
+++ b/tests/rigor/challenge-proof.test.js
@@ -111,7 +111,7 @@ describe('PartialGraphContext.getChallengeProof (rigor)', () => {
           ({ error, errorMessage }) => !error && !errorMessage
         )
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'challenge-proof-oracle', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') {
       console.log('TAP:', report.toTAP());
@@ -152,7 +152,7 @@ describe('PartialGraphContext.getChallengeProof (rigor)', () => {
       rigor.crucible([
         rigor.invariant('no-expired', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'challenge-proof-expired', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') {
       console.log('TAP:', report.toTAP());
@@ -227,7 +227,7 @@ describe('PartialGraphContext.getChallengeProof (rigor)', () => {
       rigor.crucible([
         rigor.invariant('most-recent', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'challenge-proof-most-recent', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') {
       console.log('TAP:', report.toTAP());
@@ -283,7 +283,7 @@ describe('PartialGraphContext.getChallengeProof (rigor)', () => {
       rigor.crucible([
         rigor.invariant('within-window', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'challenge-proof-within-ms', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') {
       console.log('TAP:', report.toTAP());
diff --git a/tests/rigor/challenge-rule.test.js b/tests/rigor/challenge-rule.test.js
index 4ab5698..14c13ab 100644
--- a/tests/rigor/challenge-rule.test.js
+++ b/tests/rigor/challenge-rule.test.js
@@ -69,7 +69,7 @@ describe('ChallengeRule._resolveSubjectKey (rigor)', () => {
       rigor.crucible([
         rigor.invariant('subjectKey-wins', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1000 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'challenge-rule-subject-key-wins', effort: 1000 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'subjectKey-wins');
@@ -118,7 +118,7 @@ describe('ChallengeRule._resolveSubjectKey (rigor)', () => {
       rigor.crucible([
         rigor.invariant('subject-mapping', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'challenge-rule-subject-mapping', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'subject-mapping');
@@ -199,7 +199,7 @@ describe('ChallengeRule._resolveWithinMs (rigor)', () => {
       rigor.crucible([
         rigor.invariant('within-units', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'challenge-rule-within-units', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'within-units');
@@ -262,7 +262,7 @@ describe('ChallengeRule._resolveWithinMs (rigor)', () => {
       rigor.crucible([
         rigor.invariant('within-priority', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'challenge-rule-within-priority', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'within-priority');
@@ -295,7 +295,7 @@ describe('ChallengeRule._resolveWithinMs (rigor)', () => {
       rigor.crucible([
         rigor.invariant('null-when-absent', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'challenge-rule-null-when-absent', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'null-when-absent');
@@ -335,7 +335,7 @@ describe('ChallengeRule._buildRequirement (rigor)', () => {
       rigor.crucible([
         rigor.invariant('buildRequirement', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'challenge-rule-build-requirement', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'buildRequirement');
diff --git a/tests/rigor/computed-rule.test.js b/tests/rigor/computed-rule.test.js
index f4e1cf2..e880aeb 100644
--- a/tests/rigor/computed-rule.test.js
+++ b/tests/rigor/computed-rule.test.js
@@ -72,7 +72,7 @@ describe('ComputedRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('possibility-passthrough', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'computed-rule-possibility-passthrough', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'possibility-passthrough');
@@ -108,7 +108,7 @@ describe('ComputedRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('reason-default', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'computed-rule-reason-default', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'reason-default');
@@ -145,7 +145,7 @@ describe('ComputedRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('reason-passthrough', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'computed-rule-reason-passthrough', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'reason-passthrough');
@@ -188,7 +188,7 @@ describe('ComputedRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('meta-contract', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'computed-rule-meta-contract', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'meta-contract');
@@ -237,7 +237,7 @@ describe('ComputedRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('collected-values-passthrough', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'computed-rule-collected-values', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'collected-values-passthrough');
@@ -273,7 +273,7 @@ describe('ComputedRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('possibility-fallback-zero', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'computed-rule-possibility-fallback', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'possibility-fallback-zero');
@@ -311,7 +311,7 @@ describe('ComputedRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('options-passthrough', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'computed-rule-options-passthrough', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'options-passthrough');
diff --git a/tests/rigor/direct-rule.test.js b/tests/rigor/direct-rule.test.js
index 96d58f0..3f4ece2 100644
--- a/tests/rigor/direct-rule.test.js
+++ b/tests/rigor/direct-rule.test.js
@@ -84,7 +84,7 @@ describe('DirectRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('no-relation-fallback', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'direct-rule-no-relation', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'no-relation-fallback');
@@ -138,7 +138,7 @@ describe('DirectRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('relation-strength-preserved', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'direct-rule-strength', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'relation-strength-preserved');
@@ -186,7 +186,7 @@ describe('DirectRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('reverse-routing', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'direct-rule-reverse', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'reverse-routing');
@@ -236,7 +236,7 @@ describe('DirectRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('fastPath-early-exit', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'direct-rule-fast-path', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'fastPath-early-exit');
@@ -278,7 +278,7 @@ describe('DirectRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('collectValues-disabled', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'direct-rule-collect-off', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'collectValues-disabled');
@@ -332,7 +332,7 @@ describe('DirectRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('collectValues-default', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'direct-rule-collect-on', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'collectValues-default');
@@ -393,7 +393,7 @@ describe('DirectRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('relation-precedence', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'direct-rule-precedence', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'relation-precedence');
@@ -449,7 +449,7 @@ describe('DirectRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('result-shape-stable', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'direct-rule-shape', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'result-shape-stable');
diff --git a/tests/rigor/dsl-compiler.test.js b/tests/rigor/dsl-compiler.test.js
index 5dcbf97..7699712 100644
--- a/tests/rigor/dsl-compiler.test.js
+++ b/tests/rigor/dsl-compiler.test.js
@@ -93,7 +93,7 @@ describe('DSLCompiler → engine rule mapping (rigor)', () => {
       rigor.crucible([
         rigor.invariant('direct-emission', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'dsl-compiler-direct', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'direct-emission');
@@ -128,7 +128,7 @@ describe('DSLCompiler → engine rule mapping (rigor)', () => {
       rigor.crucible([
         rigor.invariant('tus-emission', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 200 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'dsl-compiler-tus', effort: 200 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'tus-emission');
@@ -160,7 +160,7 @@ describe('DSLCompiler → engine rule mapping (rigor)', () => {
       rigor.crucible([
         rigor.invariant('parent-emission', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 200 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'dsl-compiler-parent', effort: 200 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'parent-emission');
@@ -197,7 +197,7 @@ describe('DSLCompiler → engine rule mapping (rigor)', () => {
       rigor.crucible([
         rigor.invariant('chain-emission', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 200 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'dsl-compiler-chain', effort: 200 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'chain-emission');
@@ -246,7 +246,7 @@ describe('DSLCompiler → engine rule mapping (rigor)', () => {
       rigor.crucible([
         rigor.invariant('multi_hop-emission', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 200 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'dsl-compiler-multi-hop', effort: 200 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'multi_hop-emission');
@@ -288,7 +288,7 @@ describe('DSLCompiler → engine rule mapping (rigor)', () => {
       rigor.crucible([
         rigor.invariant('logical-emission', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'dsl-compiler-logical', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'logical-emission');
@@ -323,7 +323,7 @@ describe('DSLCompiler → engine rule mapping (rigor)', () => {
       rigor.crucible([
         rigor.invariant('relational-comparator-emission', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'dsl-compiler-relational-comparator', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'relational-comparator-emission');
@@ -371,7 +371,7 @@ describe('DSLCompiler → engine rule mapping (rigor)', () => {
       rigor.crucible([
         rigor.invariant('mapping-consistency', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'dsl-compiler-mapping-consistency', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'mapping-consistency');
diff --git a/tests/rigor/logical-operators.test.js b/tests/rigor/logical-operators.test.js
index 3ea044f..9caf84b 100644
--- a/tests/rigor/logical-operators.test.js
+++ b/tests/rigor/logical-operators.test.js
@@ -65,7 +65,7 @@ describe('LogicalOperators evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('union-max', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'logical-operators-union-max', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'union-max');
@@ -104,7 +104,7 @@ describe('LogicalOperators evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('intersection-min', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'logical-operators-intersection-min', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'intersection-min');
@@ -138,7 +138,7 @@ describe('LogicalOperators evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('union-mean', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'logical-operators-union-mean', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'union-mean');
@@ -181,7 +181,7 @@ describe('LogicalOperators evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('exclusion', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'logical-operators-exclusion', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'exclusion');
@@ -214,7 +214,7 @@ describe('LogicalOperators evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('possibility-bounded', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'logical-operators-possibility-bounded', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'possibility-bounded');
@@ -251,7 +251,7 @@ describe('LogicalOperators evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('collected-values-concat', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'logical-operators-collected-values', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'collected-values-concat');
diff --git a/tests/rigor/multi-hop-rule.test.js b/tests/rigor/multi-hop-rule.test.js
index a73e391..9c12561 100644
--- a/tests/rigor/multi-hop-rule.test.js
+++ b/tests/rigor/multi-hop-rule.test.js
@@ -51,7 +51,7 @@ describe('MultiHopRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('missing-relation', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'multi-hop-missing-relation', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'missing-relation');
@@ -88,7 +88,7 @@ describe('MultiHopRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('possibility-bounded', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'multi-hop-possibility-bounded', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'possibility-bounded');
@@ -126,7 +126,7 @@ describe('MultiHopRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('single-path-strength', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'multi-hop-single-path', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'single-path-strength');
@@ -161,7 +161,7 @@ describe('MultiHopRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('no-path', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'multi-hop-no-path', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'no-path');
@@ -208,7 +208,7 @@ describe('MultiHopRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('multi-hop-finds-path', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'multi-hop-two-hop', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'multi-hop-finds-path');
diff --git a/tests/rigor/node-manager.test.js b/tests/rigor/node-manager.test.js
index db37882..f703800 100644
--- a/tests/rigor/node-manager.test.js
+++ b/tests/rigor/node-manager.test.js
@@ -93,7 +93,7 @@ describe('NodeManager index invariants (rigor)', () => {
       rigor.crucible([
         rigor.invariant('inverse-maps', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'node-manager-inverse-maps', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'inverse-maps');
@@ -133,7 +133,7 @@ describe('NodeManager index invariants (rigor)', () => {
       rigor.crucible([
         rigor.invariant('addNode-idempotent', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'node-manager-add-idempotent', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'addNode-idempotent');
@@ -186,7 +186,7 @@ describe('NodeManager index invariants (rigor)', () => {
       rigor.crucible([
         rigor.invariant('size-invariant', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'node-manager-size-invariant', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'size-invariant');
@@ -249,7 +249,7 @@ describe('NodeManager index invariants (rigor)', () => {
       rigor.crucible([
         rigor.invariant('monotonic-ids', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'node-manager-monotonic-ids', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'monotonic-ids');
@@ -295,7 +295,7 @@ describe('NodeManager index invariants (rigor)', () => {
       rigor.crucible([
         rigor.invariant('removeNode-cleanup', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'node-manager-remove-cleanup', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'removeNode-cleanup');
@@ -335,7 +335,7 @@ describe('NodeManager index invariants (rigor)', () => {
       rigor.crucible([
         rigor.invariant('clearNodes-resets', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'node-manager-clear-resets', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'clearNodes-resets');
@@ -388,7 +388,7 @@ describe('NodeManager index invariants (rigor)', () => {
       rigor.crucible([
         rigor.invariant('updateNodeData-merges', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'node-manager-update-merge', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'updateNodeData-merges');
diff --git a/tests/rigor/parent-rule.test.js b/tests/rigor/parent-rule.test.js
index 2ec8477..e2f6258 100644
--- a/tests/rigor/parent-rule.test.js
+++ b/tests/rigor/parent-rule.test.js
@@ -87,7 +87,7 @@ describe('ParentRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('no-parents', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'parent-rule-no-parents', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'no-parents');
@@ -131,7 +131,7 @@ describe('ParentRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('one-parent-strength', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'parent-rule-one-parent', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'one-parent-strength');
@@ -175,7 +175,7 @@ describe('ParentRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('threshold-cutoff', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'parent-rule-threshold', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'threshold-cutoff');
@@ -212,7 +212,7 @@ describe('ParentRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('cycle-detection', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 200 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'parent-rule-cycle', effort: 200 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'cycle-detection');
@@ -258,7 +258,7 @@ describe('ParentRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('multi-parent-max', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'parent-rule-multi-parent', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'multi-parent-max');
@@ -297,7 +297,7 @@ describe('ParentRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('parent-relation-default', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 200 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'parent-rule-default-relation', effort: 200 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'parent-relation-default');
@@ -341,7 +341,7 @@ describe('ParentRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('possibility-bounded', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'parent-rule-possibility-bounded', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'possibility-bounded');
diff --git a/tests/rigor/qualitative-rule-helpers.test.js b/tests/rigor/qualitative-rule-helpers.test.js
index d42e3ec..68c6c50 100644
--- a/tests/rigor/qualitative-rule-helpers.test.js
+++ b/tests/rigor/qualitative-rule-helpers.test.js
@@ -94,7 +94,7 @@ describe('QualitativeRelationalComparatorRule._getQualitativeScale (rigor)', ()
       rigor.crucible([
         rigor.invariant('known-scales', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-known-scales', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'known-scales');
@@ -125,7 +125,7 @@ describe('QualitativeRelationalComparatorRule._getQualitativeScale (rigor)', ()
       rigor.crucible([
         rigor.invariant('fallback', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-fallback', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'fallback');
@@ -162,7 +162,7 @@ describe('QualitativeRelationalComparatorRule._calculateDecayedPossibility (rigo
       rigor.crucible([
         rigor.invariant('stable-identity', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-stable-identity', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'stable-identity');
@@ -197,7 +197,7 @@ describe('QualitativeRelationalComparatorRule._calculateDecayedPossibility (rigo
       rigor.crucible([
         rigor.invariant('zero-periods', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-zero-periods', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'zero-periods');
@@ -238,7 +238,7 @@ describe('QualitativeRelationalComparatorRule._calculateDecayedPossibility (rigo
       rigor.crucible([
         rigor.invariant('down-monotone', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-down-monotone', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'down-monotone');
@@ -278,7 +278,7 @@ describe('QualitativeRelationalComparatorRule._calculateDecayedPossibility (rigo
       rigor.crucible([
         rigor.invariant('up-monotone', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-up-monotone', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'up-monotone');
@@ -314,7 +314,7 @@ describe('QualitativeRelationalComparatorRule._calculateDecayedPossibility (rigo
       rigor.crucible([
         rigor.invariant('result-in-scale', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-result-in-scale', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'result-in-scale');
@@ -351,7 +351,7 @@ describe('QualitativeRelationalComparatorRule._createQualitativeInterval (rigor)
       rigor.crucible([
         rigor.invariant('lower-le-upper', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-lower-le-upper', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'lower-le-upper');
@@ -389,7 +389,7 @@ describe('QualitativeRelationalComparatorRule._createQualitativeInterval (rigor)
       rigor.crucible([
         rigor.invariant('point-contained', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-point-contained', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'point-contained');
@@ -425,7 +425,7 @@ describe('QualitativeRelationalComparatorRule._createQualitativeInterval (rigor)
       rigor.crucible([
         rigor.invariant('bounds-in-scale', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-bounds-in-scale', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'bounds-in-scale');
@@ -459,7 +459,7 @@ describe('QualitativeRelationalComparatorRule._createQualitativeInterval (rigor)
       rigor.crucible([
         rigor.invariant('zero-blur', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-zero-blur', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'zero-blur');
@@ -490,7 +490,7 @@ describe('QualitativeRelationalComparatorRule._calculatePossibilityLossSteps (ri
       rigor.crucible([
         rigor.invariant('loss-is-zero', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-loss-is-zero', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'loss-is-zero');
@@ -529,7 +529,7 @@ describe('QualitativeRelationalComparatorRule._calculatePossibilityLossSteps (ri
       rigor.crucible([
         rigor.invariant('loss-symmetric', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'qualitative-loss-symmetric', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'loss-symmetric');
diff --git a/tests/rigor/relation-manager.test.js b/tests/rigor/relation-manager.test.js
index 6e1b916..2dd8aa9 100644
--- a/tests/rigor/relation-manager.test.js
+++ b/tests/rigor/relation-manager.test.js
@@ -74,7 +74,7 @@ describe('RelationManager.addRelation/removeRelation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('add-and-get', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'relation-manager-add-get', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'add-and-get');
@@ -127,7 +127,7 @@ describe('RelationManager.addRelation/removeRelation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('addRelation-idempotent', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'relation-manager-add-idempotent', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'addRelation-idempotent');
@@ -195,7 +195,7 @@ describe('RelationManager.addRelation/removeRelation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('remove-clears-indexes', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'relation-manager-remove-cleanup', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'remove-clears-indexes');
@@ -284,7 +284,7 @@ describe('RelationManager.addRelation/removeRelation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('index-coherence', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'relation-manager-index-coherence', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'index-coherence');
@@ -364,7 +364,7 @@ describe('RelationManager.addRelation/removeRelation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('add-remove-roundtrip', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'relation-manager-add-remove-roundtrip', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'add-remove-roundtrip');
@@ -396,7 +396,7 @@ describe('RelationManager.addRelation/removeRelation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('getDirectRelation-unknown', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'relation-manager-unknown-tuple', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'getDirectRelation-unknown');
diff --git a/tests/rigor/relational-comparator-router.test.js b/tests/rigor/relational-comparator-router.test.js
index 76a5878..6c7b1f3 100644
--- a/tests/rigor/relational-comparator-router.test.js
+++ b/tests/rigor/relational-comparator-router.test.js
@@ -76,7 +76,7 @@ describe('RelationalComparatorRouter._isQualitativeRule (rigor)', () => {
       rigor.crucible([
         rigor.invariant('qualitative-wins', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-router-qualitative-wins', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'qualitative-wins');
@@ -116,7 +116,7 @@ describe('RelationalComparatorRouter._isQualitativeRule (rigor)', () => {
       rigor.crucible([
         rigor.invariant('scaleName-triggers', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-router-scale-name', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'scaleName-triggers');
@@ -156,7 +156,7 @@ describe('RelationalComparatorRouter._isQualitativeRule (rigor)', () => {
       rigor.crucible([
         rigor.invariant('decay-blur-triggers', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-router-decay-blur', effort: 500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'decay-blur-triggers');
@@ -190,7 +190,7 @@ describe('RelationalComparatorRouter._isQualitativeRule (rigor)', () => {
       rigor.crucible([
         rigor.invariant('marginSteps-correct', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-router-margin-steps', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'marginSteps-correct');
@@ -231,7 +231,7 @@ describe('RelationalComparatorRouter._isQualitativeRule (rigor)', () => {
       rigor.crucible([
         rigor.invariant('plain-numeric', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-router-plain-numeric', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'plain-numeric');
@@ -276,7 +276,7 @@ describe('RelationalComparatorRouter._isQualitativeRule (rigor)', () => {
       rigor.crucible([
         rigor.invariant('getImplType-consistent', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-router-get-impl-type', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'getImplType-consistent');
@@ -322,7 +322,7 @@ describe('RelationalComparatorRouter._isQualitativeRule (rigor)', () => {
       rigor.crucible([
         rigor.invariant('hasValidProperty', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1000 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-router-has-valid-property', effort: 1000 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'hasValidProperty');
diff --git a/tests/rigor/relational-comparator-rule.test.js b/tests/rigor/relational-comparator-rule.test.js
index 5ab0c9c..7c8ae14 100644
--- a/tests/rigor/relational-comparator-rule.test.js
+++ b/tests/rigor/relational-comparator-rule.test.js
@@ -72,7 +72,7 @@ describe('RelationalComparatorRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('left-gt-right', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-rule-left-gt-right', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'left-gt-right');
@@ -111,7 +111,7 @@ describe('RelationalComparatorRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('left-lt-right', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-rule-left-lt-right', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'left-lt-right');
@@ -146,7 +146,7 @@ describe('RelationalComparatorRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('possibility-bounded', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-rule-possibility-bounded', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'possibility-bounded');
@@ -181,7 +181,7 @@ describe('RelationalComparatorRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('result-shape-stable', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-rule-shape-stable', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'result-shape-stable');
@@ -220,7 +220,7 @@ describe('RelationalComparatorRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('determinism', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'rc-rule-determinism', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'determinism');
diff --git a/tests/rigor/smoke.test.js b/tests/rigor/smoke.test.js
index c7a9127..af06bff 100644
--- a/tests/rigor/smoke.test.js
+++ b/tests/rigor/smoke.test.js
@@ -28,7 +28,7 @@ describe('js-rigor smoke', () => {
         rigor.invariant('non-negative', ({ actual }) => actual >= 0),
         rigor.invariant('idempotent', ({ actual, fn }) => fn(actual) === actual)
       ])
-    ).run({ effort: 200 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'smoke-minimal-campaign', effort: 200 , artifacts: { dir: '', persist: 'never' }});
 
     assert.ok(report, 'campaign returns a report');
     assert.equal(typeof report.toTAP, 'function', 'report has toTAP()');
@@ -46,7 +46,7 @@ describe('js-rigor smoke', () => {
       rigor.crucible([
         rigor.invariant('equals-one', ({ actual }) => actual === 1)
       ])
-    ).run({ effort: 50 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'smoke-violated-invariant', effort: 50 , artifacts: { dir: '', persist: 'never' }});
 
     // Report shape varies — log it for debugging.
     if (process.env.TEST_DEBUG === '1') {
diff --git a/tests/rigor/tuple-to-userset-rule.test.js b/tests/rigor/tuple-to-userset-rule.test.js
index 5c4f716..4ed9216 100644
--- a/tests/rigor/tuple-to-userset-rule.test.js
+++ b/tests/rigor/tuple-to-userset-rule.test.js
@@ -194,7 +194,7 @@ describe('TupleToUsersetRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('multi-tuple-max', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 1500 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'ttu-multi-tuple-max', effort: 1500 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'multi-tuple-max');
@@ -232,7 +232,7 @@ describe('TupleToUsersetRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('possibility-bounded', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 800 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'ttu-possibility-bounded', effort: 800 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'possibility-bounded');
@@ -292,7 +292,7 @@ describe('TupleToUsersetRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('early-exit', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 200 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'ttu-early-exit', effort: 200 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'early-exit');
@@ -342,7 +342,7 @@ describe('TupleToUsersetRule evaluation (rigor)', () => {
       rigor.crucible([
         rigor.invariant('cycle-detection', ({ error, errorMessage }) => !error && !errorMessage)
       ])
-    ).run({ effort: 200 , artifacts: { dir: '', persist: 'never' }});
+    ).run({ seed: 'ttu-cycle-detection', effort: 200 , artifacts: { dir: '', persist: 'never' }});
 
     if (process.env.TEST_DEBUG === '1') console.log(report.toTAP());
     const inv = report.crucibleVerdict?.invariants?.find(i => i.name === 'cycle-detection');