gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/rogue-file-detection.test.ts

@@ -0,0 +1,296 @@
+/**
+ * Rogue file detection tests — verifies that detectRogueFileWrites()
+ * correctly identifies summary files written directly to disk without
+ * a corresponding DB completion record.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { detectRogueFileWrites } from "../auto-post-unit.ts";
+import { openDatabase, closeDatabase, isDbAvailable, insertMilestone, insertSlice, insertTask, updateSliceStatus, upsertMilestonePlanning } from "../gsd-db.ts";
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function createTmpBase(): string {
+  return realpathSync(mkdtempSync(join(tmpdir(), "gsd-rogue-test-")));
+}
+
+/**
+ * Create a minimal .gsd/ directory structure with a task summary file.
+ */
+function createTaskSummaryOnDisk(basePath: string, mid: string, sid: string, tid: string): string {
+  const tasksDir = join(basePath, ".gsd", "milestones", mid, "slices", sid, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  const summaryFile = join(tasksDir, `${tid}-SUMMARY.md`);
+  writeFileSync(summaryFile, `---\nid: ${tid}\nparent: ${sid}\nmilestone: ${mid}\n---\n# ${tid}: Test\n`, "utf-8");
+  return summaryFile;
+}
+
+/**
+ * Create a minimal .gsd/ directory structure with a slice summary file.
+ */
+function createSliceSummaryOnDisk(basePath: string, mid: string, sid: string): string {
+  const sliceDir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(sliceDir, { recursive: true });
+  const summaryFile = join(sliceDir, `${sid}-SUMMARY.md`);
+  writeFileSync(summaryFile, `---\nid: ${sid}\nmilestone: ${mid}\n---\n# ${sid}: Test Slice\n`, "utf-8");
+  return summaryFile;
+}
+
+function createRoadmapOnDisk(basePath: string, mid: string): string {
+  const milestoneDir = join(basePath, ".gsd", "milestones", mid);
+  mkdirSync(milestoneDir, { recursive: true });
+  const roadmapFile = join(milestoneDir, `${mid}-ROADMAP.md`);
+  writeFileSync(roadmapFile, `# ${mid}: Test Roadmap\n`, "utf-8");
+  return roadmapFile;
+}
+
+function createSlicePlanOnDisk(basePath: string, mid: string, sid: string): string {
+  const sliceDir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(sliceDir, { recursive: true });
+  const planFile = join(sliceDir, `${sid}-PLAN.md`);
+  writeFileSync(planFile, `# ${sid}: Test Plan\n`, "utf-8");
+  return planFile;
+}
+
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+test("rogue detection: task summary on disk, no DB row → detected as rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+    assert.ok(isDbAvailable(), "DB should be available");
+
+    const summaryPath = createTaskSummaryOnDisk(basePath, "M001", "S01", "T01");
+    assert.ok(existsSync(summaryPath), "Summary file should exist on disk");
+
+    const rogues = detectRogueFileWrites("execute-task", "M001/S01/T01", basePath);
+    assert.equal(rogues.length, 1, "Should detect one rogue file");
+    assert.equal(rogues[0].path, summaryPath);
+    assert.equal(rogues[0].unitType, "execute-task");
+    assert.equal(rogues[0].unitId, "M001/S01/T01");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: task summary on disk, DB row with status 'complete' → NOT rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    createTaskSummaryOnDisk(basePath, "M001", "S01", "T01");
+
+    // Insert parent milestone and slice first (foreign key constraints)
+    insertMilestone({ id: "M001" });
+    insertSlice({ milestoneId: "M001", id: "S01" });
+
+    // Insert a completed task row into the DB (INSERT OR REPLACE)
+    insertTask({
+      milestoneId: "M001",
+      sliceId: "S01",
+      id: "T01",
+      title: "Test Task",
+      status: "complete",
+      oneLiner: "Test",
+    });
+
+    const rogues = detectRogueFileWrites("execute-task", "M001/S01/T01", basePath);
+    assert.equal(rogues.length, 0, "Should NOT detect rogue when DB row is complete");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: no summary file on disk → NOT rogue regardless of DB state", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    // Don't create any summary file on disk
+    const rogues = detectRogueFileWrites("execute-task", "M001/S01/T01", basePath);
+    assert.equal(rogues.length, 0, "Should NOT detect rogue when no file on disk");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: DB not available → returns empty array (graceful degradation)", () => {
+  const basePath = createTmpBase();
+
+  try {
+    closeDatabase();
+    assert.ok(!isDbAvailable(), "DB should not be available");
+
+    // Create a file on disk even though DB is closed
+    createTaskSummaryOnDisk(basePath, "M001", "S01", "T01");
+
+    const rogues = detectRogueFileWrites("execute-task", "M001/S01/T01", basePath);
+    assert.equal(rogues.length, 0, "Should return empty array when DB unavailable");
+  } finally {
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: slice summary on disk, no DB row → detected as rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    const summaryPath = createSliceSummaryOnDisk(basePath, "M001", "S01");
+    assert.ok(existsSync(summaryPath), "Slice summary file should exist on disk");
+
+    const rogues = detectRogueFileWrites("complete-slice", "M001/S01", basePath);
+    assert.equal(rogues.length, 1, "Should detect one rogue slice file");
+    assert.equal(rogues[0].path, summaryPath);
+    assert.equal(rogues[0].unitType, "complete-slice");
+    assert.equal(rogues[0].unitId, "M001/S01");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: slice summary on disk, DB row with status 'complete' → NOT rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    createSliceSummaryOnDisk(basePath, "M001", "S01");
+
+    // Insert parent milestone first (foreign key constraint)
+    insertMilestone({ id: "M001" });
+
+    // Insert a slice row, then update to complete
+    insertSlice({
+      milestoneId: "M001",
+      id: "S01",
+      title: "Test Slice",
+      status: "complete",
+    });
+    updateSliceStatus("M001", "S01", "complete", new Date().toISOString());
+
+    const rogues = detectRogueFileWrites("complete-slice", "M001/S01", basePath);
+    assert.equal(rogues.length, 0, "Should NOT detect rogue when slice DB row is complete");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: plan milestone roadmap on disk, no milestone planning row → detected as rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    const roadmapPath = createRoadmapOnDisk(basePath, "M001");
+    assert.ok(existsSync(roadmapPath), "Roadmap file should exist on disk");
+
+    const rogues = detectRogueFileWrites("plan-milestone", "M001", basePath);
+    assert.equal(rogues.length, 1, "Should detect one rogue roadmap file");
+    assert.equal(rogues[0].path, roadmapPath);
+    assert.equal(rogues[0].unitType, "plan-milestone");
+    assert.equal(rogues[0].unitId, "M001");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: plan milestone roadmap on disk, DB milestone planning row exists → NOT rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    createRoadmapOnDisk(basePath, "M001");
+    insertMilestone({ id: "M001", title: "Planned Milestone" });
+    upsertMilestonePlanning("M001", {
+      vision: "Real planning state",
+      requirementCoverage: "R001 → S01",
+      boundaryMapMarkdown: "- planner → db",
+    });
+
+    const rogues = detectRogueFileWrites("plan-milestone", "M001", basePath);
+    assert.equal(rogues.length, 0, "Should NOT detect rogue when milestone planning state exists");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: slice plan on disk, no slice planning row → detected as rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    const planPath = createSlicePlanOnDisk(basePath, "M001", "S01");
+    assert.ok(existsSync(planPath), "Slice plan file should exist on disk");
+
+    const rogues = detectRogueFileWrites("plan-slice", "M001/S01", basePath);
+    assert.equal(rogues.length, 1, "Should detect one rogue slice plan file");
+    assert.equal(rogues[0].path, planPath);
+    assert.equal(rogues[0].unitType, "plan-slice");
+    assert.equal(rogues[0].unitId, "M001/S01");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("rogue detection: slice plan on disk, DB slice planning row exists → NOT rogue", () => {
+  const basePath = createTmpBase();
+  const dbPath = join(basePath, ".gsd", "gsd.db");
+  mkdirSync(join(basePath, ".gsd"), { recursive: true });
+
+  try {
+    openDatabase(dbPath);
+
+    createSlicePlanOnDisk(basePath, "M001", "S01");
+    insertMilestone({ id: "M001" });
+    insertSlice({
+      milestoneId: "M001",
+      id: "S01",
+      title: "Planned Slice",
+      status: "pending",
+      demo: "Observable plan",
+    });
+
+    const rogues = detectRogueFileWrites("plan-slice", "M001/S01", basePath);
+    assert.equal(rogues.length, 0, "Should NOT detect rogue when slice planning state exists");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/rule-registry.test.ts

@@ -3,8 +3,8 @@
 // Tests the RuleRegistry class, UnifiedRule types, singleton accessors,
 // and evaluation methods using mock rules.
 
+import assert from 'node:assert/strict';
 import { test, describe, beforeEach } from "node:test";
-import { createTestContext } from "./test-helpers.ts";
 import {
   RuleRegistry,
   getRegistry,
@@ -64,9 +64,7 @@ function makeContext(phase: string): DispatchContext {
 // ─── Tests ────────────────────────────────────────────────────────────────
 
 describe("RuleRegistry", () => {
-  const { assertEq, assertTrue } = createTestContext();
-
-  beforeEach(() => {
+    beforeEach(() => {
     resetRegistry();
   });
 
@@ -81,10 +79,10 @@ describe("RuleRegistry", () => {
 
     // At minimum, dispatch rules are returned (hook rules depend on prefs)
     const dispatchRules = listed.filter(r => r.when === "dispatch");
-    assertEq(dispatchRules.length, 3, "listRules returns 3 dispatch rules");
-    assertEq(dispatchRules[0].name, "rule-a", "first rule name is rule-a");
-    assertEq(dispatchRules[1].name, "rule-b", "second rule name is rule-b");
-    assertEq(dispatchRules[2].name, "rule-c", "third rule name is rule-c");
+    assert.deepStrictEqual(dispatchRules.length, 3, "listRules returns 3 dispatch rules");
+    assert.deepStrictEqual(dispatchRules[0].name, "rule-a", "first rule name is rule-a");
+    assert.deepStrictEqual(dispatchRules[1].name, "rule-b", "second rule name is rule-b");
+    assert.deepStrictEqual(dispatchRules[2].name, "rule-c", "third rule name is rule-c");
   });
 
   test("listRules returns correct fields on each rule", () => {
@@ -95,12 +93,12 @@ describe("RuleRegistry", () => {
     const listed = registry.listRules();
     const rule = listed.find(r => r.name === "check-fields")!;
 
-    assertTrue(rule !== undefined, "rule found by name");
-    assertEq(rule.when, "dispatch", "when field is dispatch");
-    assertEq(rule.evaluation, "first-match", "evaluation is first-match");
-    assertTrue(typeof rule.where === "function", "where is a function");
-    assertTrue(typeof rule.then === "function", "then is a function");
-    assertEq(rule.description, "Mock rule for planning", "description is set");
+    assert.ok(rule !== undefined, "rule found by name");
+    assert.deepStrictEqual(rule.when, "dispatch", "when field is dispatch");
+    assert.deepStrictEqual(rule.evaluation, "first-match", "evaluation is first-match");
+    assert.ok(typeof rule.where === "function", "where is a function");
+    assert.ok(typeof rule.then === "function", "then is a function");
+    assert.deepStrictEqual(rule.description, "Mock rule for planning", "description is set");
   });
 
   test("evaluateDispatch returns first matching rule", async () => {
@@ -113,10 +111,10 @@ describe("RuleRegistry", () => {
     const ctx = makeContext("executing");
     const result = await registry.evaluateDispatch(ctx);
 
-    assertEq(result.action, "dispatch", "result is a dispatch action");
+    assert.deepStrictEqual(result.action, "dispatch", "result is a dispatch action");
     if (result.action === "dispatch") {
-      assertEq(result.unitType, "test-executing", "matched the executing rule");
-      assertEq(result.prompt, "Prompt for executing", "prompt from matched rule");
+      assert.deepStrictEqual(result.unitType, "test-executing", "matched the executing rule");
+      assert.deepStrictEqual(result.prompt, "Prompt for executing", "prompt from matched rule");
     }
   });
 
@@ -128,9 +126,9 @@ describe("RuleRegistry", () => {
     const ctx = makeContext("blocked");
     const result = await registry.evaluateDispatch(ctx);
 
-    assertEq(result.action, "stop", "result is a stop action");
+    assert.deepStrictEqual(result.action, "stop", "result is a stop action");
     if (result.action === "stop") {
-      assertTrue(result.reason.includes("blocked"), "stop reason mentions phase");
+      assert.ok(result.reason.includes("blocked"), "stop reason mentions phase");
     }
   });
 
@@ -159,9 +157,9 @@ describe("RuleRegistry", () => {
     const ctx = makeContext("planning");
     const result = await registry.evaluateDispatch(ctx);
 
-    assertEq(result.action, "dispatch", "async dispatch resolved");
+    assert.deepStrictEqual(result.action, "dispatch", "async dispatch resolved");
     if (result.action === "dispatch") {
-      assertEq(result.unitType, "async-test", "async rule matched");
+      assert.deepStrictEqual(result.unitType, "async-test", "async rule matched");
     }
   });
 
@@ -188,11 +186,11 @@ describe("RuleRegistry", () => {
     // Reset
     registry.resetState();
 
-    assertEq(registry.getActiveHook(), null, "activeHook cleared");
-    assertEq(registry.hookQueue.length, 0, "hookQueue cleared");
-    assertEq(registry.cycleCounts.size, 0, "cycleCounts cleared");
-    assertEq(registry.isRetryPending(), false, "retryPending cleared");
-    assertEq(registry.consumeRetryTrigger(), null, "retryTrigger cleared");
+    assert.deepStrictEqual(registry.getActiveHook(), null, "activeHook cleared");
+    assert.deepStrictEqual(registry.hookQueue.length, 0, "hookQueue cleared");
+    assert.deepStrictEqual(registry.cycleCounts.size, 0, "cycleCounts cleared");
+    assert.deepStrictEqual(registry.isRetryPending(), false, "retryPending cleared");
+    assert.deepStrictEqual(registry.consumeRetryTrigger(), null, "retryTrigger cleared");
   });
 
   test("singleton getRegistry throws when not initialized", () => {
@@ -201,9 +199,9 @@ describe("RuleRegistry", () => {
       getRegistry();
     } catch (e: any) {
       threw = true;
-      assertTrue(e.message.includes("not initialized"), "error mentions not initialized");
+      assert.ok(e.message.includes("not initialized"), "error mentions not initialized");
     }
-    assertTrue(threw, "getRegistry threw");
+    assert.ok(threw, "getRegistry threw");
   });
 
   test("setRegistry / getRegistry round-trips", () => {
@@ -211,20 +209,20 @@ describe("RuleRegistry", () => {
     setRegistry(registry);
 
     const retrieved = getRegistry();
-    assertEq(retrieved, registry, "getRegistry returns the same instance");
+    assert.deepStrictEqual(retrieved, registry, "getRegistry returns the same instance");
 
     const listed = retrieved.listRules().filter(r => r.when === "dispatch");
-    assertEq(listed.length, 1, "singleton has 1 dispatch rule");
-    assertEq(listed[0].name, "singleton-test", "rule name matches");
+    assert.deepStrictEqual(listed.length, 1, "singleton has 1 dispatch rule");
+    assert.deepStrictEqual(listed[0].name, "singleton-test", "rule name matches");
   });
 
   test("initRegistry creates and sets singleton", () => {
     const rules = [mockDispatchRule("init-test", "executing")];
     const registry = initRegistry(rules);
 
-    assertEq(getRegistry(), registry, "initRegistry sets the singleton");
+    assert.deepStrictEqual(getRegistry(), registry, "initRegistry sets the singleton");
     const listed = getRegistry().listRules().filter(r => r.when === "dispatch");
-    assertEq(listed.length, 1, "singleton has the rule");
+    assert.deepStrictEqual(listed.length, 1, "singleton has the rule");
   });
 
   test("evaluateDispatch respects rule order (first match wins)", async () => {
@@ -258,9 +256,9 @@ describe("RuleRegistry", () => {
     const ctx = makeContext("planning");
     const result = await registry.evaluateDispatch(ctx);
 
-    assertEq(result.action, "dispatch", "dispatch action returned");
+    assert.deepStrictEqual(result.action, "dispatch", "dispatch action returned");
     if (result.action === "dispatch") {
-      assertEq(result.unitType, "first-wins", "first rule won over second");
+      assert.deepStrictEqual(result.unitType, "first-wins", "first rule won over second");
     }
   });
 
@@ -268,18 +266,18 @@ describe("RuleRegistry", () => {
 
   test("convertDispatchRules produces correct count of UnifiedRule objects", () => {
     const converted = convertDispatchRules(DISPATCH_RULES);
-    assertEq(converted.length, DISPATCH_RULES.length, `convertDispatchRules produces ${DISPATCH_RULES.length} rules`);
+    assert.deepStrictEqual(converted.length, DISPATCH_RULES.length, `convertDispatchRules produces ${DISPATCH_RULES.length} rules`);
   });
 
   test("each converted rule has correct when, evaluation, and original name", () => {
     const converted = convertDispatchRules(DISPATCH_RULES);
     for (let i = 0; i < converted.length; i++) {
       const rule = converted[i];
-      assertEq(rule.when, "dispatch", `rule ${i} has when:"dispatch"`);
-      assertEq(rule.evaluation, "first-match", `rule ${i} has evaluation:"first-match"`);
-      assertEq(rule.name, DISPATCH_RULES[i].name, `rule ${i} preserves name "${DISPATCH_RULES[i].name}"`);
-      assertTrue(typeof rule.where === "function", `rule ${i} has a where function`);
-      assertTrue(typeof rule.then === "function", `rule ${i} has a then function`);
+      assert.deepStrictEqual(rule.when, "dispatch", `rule ${i} has when:"dispatch"`);
+      assert.deepStrictEqual(rule.evaluation, "first-match", `rule ${i} has evaluation:"first-match"`);
+      assert.deepStrictEqual(rule.name, DISPATCH_RULES[i].name, `rule ${i} preserves name "${DISPATCH_RULES[i].name}"`);
+      assert.ok(typeof rule.where === "function", `rule ${i} has a where function`);
+      assert.ok(typeof rule.then === "function", `rule ${i} has a then function`);
     }
   });
 
@@ -287,7 +285,7 @@ describe("RuleRegistry", () => {
     const converted = convertDispatchRules(DISPATCH_RULES);
     const registry = new RuleRegistry(converted);
     const listed = registry.listRules().filter(r => r.when === "dispatch");
-    assertEq(listed.length, DISPATCH_RULES.length, `listRules returns ${DISPATCH_RULES.length} dispatch rules`);
+    assert.deepStrictEqual(listed.length, DISPATCH_RULES.length, `listRules returns ${DISPATCH_RULES.length} dispatch rules`);
   });
 
   test("rule names from listRules match getDispatchRuleNames in exact order", () => {
@@ -298,9 +296,9 @@ describe("RuleRegistry", () => {
       .map(r => r.name);
     const originalNames = getDispatchRuleNames();
 
-    assertEq(listedNames.length, originalNames.length, "same number of names");
+    assert.deepStrictEqual(listedNames.length, originalNames.length, "same number of names");
     for (let i = 0; i < originalNames.length; i++) {
-      assertEq(listedNames[i], originalNames[i], `name at index ${i} matches: "${originalNames[i]}"`);
+      assert.deepStrictEqual(listedNames[i], originalNames[i], `name at index ${i} matches: "${originalNames[i]}"`);
     }
   });
 
@@ -309,18 +307,18 @@ describe("RuleRegistry", () => {
   test("getOrCreateRegistry lazily creates a registry with empty dispatch rules", () => {
     // After resetRegistry(), getRegistry() would throw. getOrCreateRegistry() should not.
     const registry = getOrCreateRegistry();
-    assertTrue(registry instanceof RuleRegistry, "returns a RuleRegistry instance");
+    assert.ok(registry instanceof RuleRegistry, "returns a RuleRegistry instance");
     const dispatchRules = registry.listRules().filter(r => r.when === "dispatch");
-    assertEq(dispatchRules.length, 0, "lazily-created registry has 0 dispatch rules");
+    assert.deepStrictEqual(dispatchRules.length, 0, "lazily-created registry has 0 dispatch rules");
   });
 
   test("getOrCreateRegistry returns existing registry when initialized", () => {
     const rules = [mockDispatchRule("explicit-init", "planning")];
     const explicit = initRegistry(rules);
     const lazy = getOrCreateRegistry();
-    assertEq(lazy, explicit, "getOrCreateRegistry returns the same singleton as initRegistry");
+    assert.deepStrictEqual(lazy, explicit, "getOrCreateRegistry returns the same singleton as initRegistry");
     const dispatchRules = lazy.listRules().filter(r => r.when === "dispatch");
-    assertEq(dispatchRules.length, 1, "singleton has the explicitly initialized dispatch rule");
+    assert.deepStrictEqual(dispatchRules.length, 1, "singleton has the explicitly initialized dispatch rule");
   });
 
   // ── Hook-derived rules in listRules ────────────────────────────────
@@ -333,9 +331,9 @@ describe("RuleRegistry", () => {
     const preDispatchRules = allRules.filter(r => r.when === "pre-dispatch");
 
     // No preferences file = no hooks
-    assertEq(postUnitRules.length, 0, "no post-unit rules when no hooks configured");
-    assertEq(preDispatchRules.length, 0, "no pre-dispatch rules when no hooks configured");
-    assertEq(allRules.length, DISPATCH_RULES.length, "total rules equals dispatch rules only");
+    assert.deepStrictEqual(postUnitRules.length, 0, "no post-unit rules when no hooks configured");
+    assert.deepStrictEqual(preDispatchRules.length, 0, "no pre-dispatch rules when no hooks configured");
+    assert.deepStrictEqual(allRules.length, DISPATCH_RULES.length, "total rules equals dispatch rules only");
   });
 
   test("listRules dispatch rules appear first, hooks after", () => {
@@ -345,8 +343,8 @@ describe("RuleRegistry", () => {
 
     // Verify dispatch rules come first (indices 0..N-1)
     for (let i = 0; i < converted.length; i++) {
-      assertEq(allRules[i].when, "dispatch", `rule at index ${i} is a dispatch rule`);
-      assertEq(allRules[i].name, converted[i].name, `dispatch rule at index ${i} has correct name`);
+      assert.deepStrictEqual(allRules[i].when, "dispatch", `rule at index ${i} is a dispatch rule`);
+      assert.deepStrictEqual(allRules[i].name, converted[i].name, `dispatch rule at index ${i} has correct name`);
     }
   });
 
@@ -355,34 +353,34 @@ describe("RuleRegistry", () => {
   test("evaluatePostUnit returns null for hook-on-hook prevention", () => {
     const registry = new RuleRegistry([]);
     const result = registry.evaluatePostUnit("hook/code-review", "M001/S01/T01", "/tmp/test");
-    assertEq(result, null, "hook units don't trigger other hooks");
+    assert.deepStrictEqual(result, null, "hook units don't trigger other hooks");
   });
 
   test("evaluatePostUnit returns null for triage-captures", () => {
     const registry = new RuleRegistry([]);
     const result = registry.evaluatePostUnit("triage-captures", "M001/S01/T01", "/tmp/test");
-    assertEq(result, null, "triage-captures skipped");
+    assert.deepStrictEqual(result, null, "triage-captures skipped");
   });
 
   test("evaluatePostUnit returns null for quick-task", () => {
     const registry = new RuleRegistry([]);
     const result = registry.evaluatePostUnit("quick-task", "M001/S01/T01", "/tmp/test");
-    assertEq(result, null, "quick-task skipped");
+    assert.deepStrictEqual(result, null, "quick-task skipped");
   });
 
   test("evaluatePreDispatch bypasses hook units", () => {
     const registry = new RuleRegistry([]);
     const result = registry.evaluatePreDispatch("hook/review", "M001/S01/T01", "prompt", "/tmp/test");
-    assertEq(result.action, "proceed", "hook units always proceed");
-    assertEq(result.prompt, "prompt", "prompt unchanged");
-    assertEq(result.firedHooks.length, 0, "no hooks fired");
+    assert.deepStrictEqual(result.action, "proceed", "hook units always proceed");
+    assert.deepStrictEqual(result.prompt, "prompt", "prompt unchanged");
+    assert.deepStrictEqual(result.firedHooks.length, 0, "no hooks fired");
   });
 
   test("evaluatePreDispatch proceeds with empty hooks", () => {
     const registry = new RuleRegistry([]);
     const result = registry.evaluatePreDispatch("execute-task", "M001/S01/T01", "original prompt", "/tmp/test");
-    assertEq(result.action, "proceed", "proceeds when no hooks");
-    assertEq(result.prompt, "original prompt", "prompt unchanged");
+    assert.deepStrictEqual(result.action, "proceed", "proceeds when no hooks");
+    assert.deepStrictEqual(result.prompt, "original prompt", "prompt unchanged");
   });
 
   // ── matchedRule provenance (S02 journal support) ───────────────────
@@ -395,8 +393,8 @@ describe("RuleRegistry", () => {
     const ctx = makeContext("planning");
     const result = await registry.evaluateDispatch(ctx);
 
-    assertEq(result.action, "dispatch", "result is a dispatch action");
-    assertEq(result.matchedRule, "my-planning-rule", "matchedRule is the rule name");
+    assert.deepStrictEqual(result.action, "dispatch", "result is a dispatch action");
+    assert.deepStrictEqual(result.matchedRule, "my-planning-rule", "matchedRule is the rule name");
   });
 
   test("evaluateDispatch result includes matchedRule '<no-match>' on fallback stop", async () => {
@@ -407,7 +405,7 @@ describe("RuleRegistry", () => {
     const ctx = makeContext("some-unknown-phase");
     const result = await registry.evaluateDispatch(ctx);
 
-    assertEq(result.action, "stop", "result is a stop action");
-    assertEq(result.matchedRule, "<no-match>", "matchedRule is '<no-match>' on fallback");
+    assert.deepStrictEqual(result.action, "stop", "result is a stop action");
+    assert.deepStrictEqual(result.matchedRule, "<no-match>", "matchedRule is '<no-match>' on fallback");
   });
 });