gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

package/src/resources/extensions/gsd/tests/milestone-transition-state-rebuild.test.ts

@@ -11,99 +11,15 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync, realpathSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
+import { AutoSession } from "../auto/session.ts";
+import { runPreDispatch } from "../auto/phases.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-// ─── Source-level checks ──────────────────────────────────────────────────────
-
-test("auto/phases.ts milestone transition block calls rebuildState", () => {
-  const phasesSrc = readFileSync(
-    join(__dirname, "..", "auto", "phases.ts"),
-    "utf-8",
-  );
-
-  // rebuildState must be called within the milestone transition block
-  assert.ok(
-    phasesSrc.includes("deps.rebuildState(s.basePath)"),
-    "auto/phases.ts should call deps.rebuildState(s.basePath) during milestone transition",
-  );
-
-  // The rebuildState call must appear AFTER the pruneQueueOrder call
-  // (i.e. after all transition cleanup is done)
-  const pruneIdx = phasesSrc.indexOf("deps.pruneQueueOrder(s.basePath, pendingIds)");
-  const rebuildIdx = phasesSrc.indexOf("deps.rebuildState(s.basePath)");
-  assert.ok(pruneIdx > 0, "pruneQueueOrder should exist in phases.ts");
-  assert.ok(rebuildIdx > 0, "rebuildState should exist in phases.ts");
-  assert.ok(
-    rebuildIdx > pruneIdx,
-    "rebuildState should be called after pruneQueueOrder in the milestone transition block",
-  );
-});
-
-test("auto/phases.ts milestone transition block resets completed-units.json", () => {
-  const phasesSrc = readFileSync(
-    join(__dirname, "..", "auto", "phases.ts"),
-    "utf-8",
-  );
-
-  // completed-units.json must be archived and cleared during milestone transition
-  const transitionStart = phasesSrc.indexOf("Milestone transition");
-  assert.ok(transitionStart > 0, "Milestone transition block should exist");
-
-  // The old file is archived before being cleared (#2313)
-  const archiveSection = phasesSrc.indexOf("completed-units-", transitionStart);
-  assert.ok(
-    archiveSection > 0,
-    "auto/phases.ts should archive completed-units.json during milestone transition",
-  );
-
-  // The disk file should be cleared to an empty array
-  assert.ok(
-    phasesSrc.includes('atomicWriteSync(completedKeysPath, JSON.stringify([], null, 2))'),
-    "auto/phases.ts should write empty array to completed-units.json during milestone transition",
-  );
-});
-
-test("auto/loop-deps.ts LoopDeps interface includes rebuildState", () => {
-  const loopDepsSrc = readFileSync(
-    join(__dirname, "..", "auto", "loop-deps.ts"),
-    "utf-8",
-  );
-
-  assert.ok(
-    loopDepsSrc.includes("rebuildState: (basePath: string) => Promise<void>"),
-    "LoopDeps interface should declare rebuildState method",
-  );
-});
-
-test("auto.ts buildLoopDeps wires rebuildState", () => {
-  const autoSrc = readFileSync(
-    join(__dirname, "..", "auto.ts"),
-    "utf-8",
-  );
-
-  // rebuildState should be in the LoopDeps object literal.
-  // Match the signature prefix so the test survives future param changes
-  // (e.g. the DECOUPLE-02 change from `()` to `(pi: ExtensionAPI)`).
-  const buildLoopDepsIdx = autoSrc.indexOf("function buildLoopDeps(");
-  assert.ok(buildLoopDepsIdx > 0, "buildLoopDeps function should exist");
-
-  const afterBuild = autoSrc.slice(buildLoopDepsIdx);
-  assert.ok(
-    afterBuild.includes("rebuildState,") || afterBuild.includes("rebuildState:"),
-    "buildLoopDeps should include rebuildState in the returned deps object",
-  );
-});
-
-// ─── Functional test: completed-units.json reset ─────────────────────────────
-
-test("completed-units.json is cleared on milestone transition (functional)", () => {
+test("milestone transition archives completed units and rebuilds state", async () => {
   const tempDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-cu-reset-")));
+  const calls: string[] = [];
   try {
-    // Create .gsd directory with a populated completed-units.json
     const gsdDir = join(tempDir, ".gsd");
     mkdirSync(gsdDir, { recursive: true });
 
@@ -116,16 +32,81 @@ test("completed-units.json is cleared on milestone transition (functional)", ()
     ];
     writeFileSync(completedKeysPath, JSON.stringify(staleEntries, null, 2));
 
-    // Verify stale entries exist
-    const before = JSON.parse(readFileSync(completedKeysPath, "utf-8"));
-    assert.equal(before.length, 4, "Should have 4 stale entries before reset");
-
-    // Simulate what phases.ts does: write empty array
-    writeFileSync(completedKeysPath, JSON.stringify([], null, 2));
-
-    // Verify reset
+    const s = new AutoSession();
+    s.basePath = tempDir;
+    s.originalBasePath = tempDir;
+    s.currentMilestoneId = "M001";
+    s.unitDispatchCount.set("old", 1);
+    s.unitRecoveryCount.set("old", 1);
+    s.unitLifetimeDispatches.set("old", 1);
+
+    const state = {
+      phase: "planning",
+      activeMilestone: { id: "M002", title: "Next" },
+      activeSlice: null,
+      activeTask: null,
+      recentDecisions: [],
+      blockers: [],
+      nextAction: "Plan M002",
+      registry: [
+        { id: "M001", title: "Done", status: "complete" },
+        { id: "M002", title: "Next", status: "active" },
+      ],
+    };
+
+    const result = await runPreDispatch({
+      ctx: { ui: { notify() {} } },
+      pi: {},
+      s,
+      prefs: undefined,
+      iteration: 1,
+      flowId: "test-flow",
+      nextSeq: () => 1,
+      deps: {
+        checkResourcesStale: () => null,
+        invalidateAllCaches: () => calls.push("invalidate"),
+        preDispatchHealthGate: async () => ({ proceed: true, fixesApplied: [] }),
+        syncProjectRootToWorktree: () => {},
+        deriveState: async () => state,
+        syncCmuxSidebar: () => {},
+        preflightCleanRoot: () => ({ ok: true, stashPushed: false }),
+        postflightPopStash: () => ({ ok: true, needsManualRecovery: false }),
+        resolver: {
+          mergeAndExit: () => calls.push("merge"),
+          enterMilestone: (mid: string) => calls.push(`enter:${mid}`),
+        },
+        sendDesktopNotification: () => {},
+        logCmuxEvent: () => {},
+        getIsolationMode: () => "none",
+        captureIntegrationBranch: () => {},
+        pruneQueueOrder: (_base: string, pending: string[]) => calls.push(`prune:${pending.join(",")}`),
+        rebuildState: async () => calls.push("rebuild"),
+        setActiveMilestoneId: (_base: string, mid: string) => calls.push(`active:${mid}`),
+        reconcileMergeState: () => "clean",
+        emitJournalEvent: () => {},
+        stopAuto: async () => {},
+        pauseAuto: async () => {},
+        closeoutUnit: async () => {},
+        buildSnapshotOpts: () => ({}),
+      },
+    } as any, {
+      recentUnits: [{ key: "stale" }],
+      stuckRecoveryAttempts: 2,
+      consecutiveFinalizeTimeouts: 0,
+    });
+
+    assert.equal(result.action, "next");
+    assert.equal(s.currentMilestoneId, "M002");
+    assert.equal(s.unitDispatchCount.size, 0);
+    assert.equal(s.unitRecoveryCount.size, 0);
+    assert.equal(s.unitLifetimeDispatches.size, 0);
+    assert.ok(existsSync(join(gsdDir, "completed-units-M001.json")));
     const after = JSON.parse(readFileSync(completedKeysPath, "utf-8"));
-    assert.deepEqual(after, [], "completed-units.json should be empty after milestone transition");
+    assert.deepEqual(after, []);
+    assert.ok(
+      calls.indexOf("prune:M002") < calls.indexOf("rebuild"),
+      `expected prune before rebuild, got ${calls.join(" > ")}`,
+    );
   } finally {
     rmSync(tempDir, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/model-unittype-mapping.test.ts

@@ -1,298 +1,90 @@
 /**
- * Model UnitType Mapping — regression tests for #2865.
+ * Model UnitType Mapping — behavior tests for #2865 / #2900 / ADR-011.
  *
- * Verifies that all auto-dispatch unitTypes have corresponding entries in:
- * - resolveModelWithFallbacksForUnit (preferences-models.ts)
- * - classifyUnitPhase (metrics.ts)
- * - LIFECYCLE_ONLY_UNITS (auto-post-unit.ts)
- * - unitVerb / unitPhaseLabel (auto-dashboard.ts)
- * - resolveExpectedArtifactPath (auto-artifact-paths.ts)
- *
- * Uses source-level checks to avoid import resolution issues in dev.
- *
- * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ * Verifies model routing, metrics/dashboard labels, and artifact resolution
+ * through exported runtime APIs instead of inspecting source text.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const gsdDir = join(__dirname, "..");
-
-function readSrc(file: string): string {
-  return readFileSync(join(gsdDir, file), "utf-8");
-}
-
-const preferencesSrc = readSrc("preferences-models.ts");
-const metricsSrc = readSrc("metrics.ts");
-const postUnitSrc = readSrc("auto-post-unit.ts");
-const dashboardSrc = readSrc("auto-dashboard.ts");
-const artifactSrc = readSrc("auto-artifact-paths.ts");
-const guidedFlowSrc = readSrc("guided-flow.ts");
-const autoDispatchSrc = readSrc("auto-dispatch.ts");
-
-// Derive unitTypes directly from auto-dispatch.ts source so the test
-// automatically tracks dispatch rule changes (Copilot review feedback).
-const AUTO_DISPATCH_UNIT_TYPES = (() => {
-  const unitTypeRegex = /unitType:\s*["']([^"']+)["']/g;
-  const unitTypes = new Set<string>();
-  let match: RegExpExecArray | null;
-  while ((match = unitTypeRegex.exec(autoDispatchSrc)) !== null) {
-    unitTypes.add(match[1]);
-  }
-  return Array.from(unitTypes);
-})();
-
-// Additionally include unitTypes used by guided-flow but not auto-dispatch
-// (e.g., discuss-slice is dispatched by guided-flow but not auto-dispatch).
-const ALL_KNOWN_UNIT_TYPES = [
-  ...new Set([...AUTO_DISPATCH_UNIT_TYPES, "discuss-slice"]),
-];
-
-// ═══════════════════════════════════════════════════════════════════════════
-// #2865: discuss dispatches must NOT alias to plan unitTypes
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("#2865: no dispatchWorkflow with gsd-discuss customType uses plan-milestone", () => {
-  // Match dispatchWorkflow calls where "gsd-discuss" appears before "plan-milestone"
-  // in the same call (the 5 args are on consecutive lines).
-  const blocks = guidedFlowSrc.split(/dispatchWorkflow\(/);
-  for (const block of blocks) {
-    const callEnd = block.indexOf(");");
-    if (callEnd === -1) continue;
-    const call = block.slice(0, callEnd);
-    if (call.includes('"gsd-discuss"') && call.includes('"plan-milestone"')) {
-      assert.fail(`Discuss dispatch should not use plan-milestone: ...dispatchWorkflow(${call.slice(0, 120).trim()}...`);
-    }
-  }
-});
-
-test("#2865: no dispatchWorkflow with gsd-discuss customType uses plan-slice", () => {
-  const blocks = guidedFlowSrc.split(/dispatchWorkflow\(/);
-  for (const block of blocks) {
-    const callEnd = block.indexOf(");");
-    if (callEnd === -1) continue;
-    const call = block.slice(0, callEnd);
-    if (call.includes('"gsd-discuss"') && call.includes('"plan-slice"')) {
-      assert.fail(`Discuss slice dispatch should not use plan-slice: ...dispatchWorkflow(${call.slice(0, 120).trim()}...`);
-    }
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolveExpectedArtifactPath } from "../auto-artifact-paths.ts";
+import { unitPhaseLabel, unitVerb } from "../auto-dashboard.ts";
+import { classifyUnitPhase } from "../metrics.ts";
+import { resolveModelWithFallbacksForUnit } from "../preferences-models.ts";
+import { KNOWN_UNIT_LABELS } from "../preferences-types.ts";
+
+function withModelPreferences<T>(fn: () => T): T {
+  const oldHome = process.env.GSD_HOME;
+  const home = mkdtempSync(join(tmpdir(), "gsd-model-map-"));
+  try {
+    process.env.GSD_HOME = home;
+    writeFileSync(join(home, "preferences.md"), [
+      "---",
+      "models:",
+      "  research: research-model",
+      "  planning: planning-model",
+      "  discuss: discuss-model",
+      "  execution: execution-model",
+      "  execution_simple: simple-model",
+      "  completion: completion-model",
+      "  validation: validation-model",
+      "  subagent: subagent-model",
+      "---",
+      "",
+    ].join("\n"));
+    return fn();
+  } finally {
+    if (oldHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = oldHome;
+    rmSync(home, { recursive: true, force: true });
   }
-});
-
-test("#2865: no buildDiscussPrompt call dispatches with plan-milestone", () => {
-  const blocks = guidedFlowSrc.split(/dispatchWorkflow\(/);
-  for (const block of blocks) {
-    const callEnd = block.indexOf(");");
-    if (callEnd === -1) continue;
-    const call = block.slice(0, callEnd);
-    if (call.includes("buildDiscussPrompt") && call.includes('"plan-milestone"')) {
-      assert.fail(`buildDiscussPrompt dispatch should not use plan-milestone`);
-    }
-  }
-});
-
-test("#2865: no buildDiscussSlicePrompt call dispatches with plan-slice", () => {
-  const blocks = guidedFlowSrc.split(/dispatchWorkflow\(/);
-  for (const block of blocks) {
-    const callEnd = block.indexOf(");");
-    if (callEnd === -1) continue;
-    const call = block.slice(0, callEnd);
-    if (call.includes("buildDiscussSlicePrompt") && call.includes('"plan-slice"')) {
-      assert.fail(`buildDiscussSlicePrompt dispatch should not use plan-slice`);
-    }
-  }
-});
-
-test("#2865: no guided-discuss-milestone loadPrompt dispatches with plan-milestone", () => {
-  const blocks = guidedFlowSrc.split(/dispatchWorkflow\(/);
-  for (const block of blocks) {
-    const callEnd = block.indexOf(");");
-    if (callEnd === -1) continue;
-    const call = block.slice(0, callEnd);
-    if (call.includes("guided-discuss-milestone") && call.includes('"plan-milestone"')) {
-      assert.fail(`guided-discuss-milestone dispatch should not use plan-milestone`);
-    }
-  }
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// preferences-models.ts: resolveModelWithFallbacksForUnit coverage
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("resolveModelWithFallbacksForUnit handles discuss-milestone", () => {
-  assert.ok(preferencesSrc.includes('"discuss-milestone"'), "missing discuss-milestone case");
-});
-
-test("resolveModelWithFallbacksForUnit handles discuss-slice", () => {
-  assert.ok(preferencesSrc.includes('"discuss-slice"'), "missing discuss-slice case");
-});
-
-test("discuss unitTypes fall back to planning when models.discuss is unset", () => {
-  assert.ok(
-    preferencesSrc.includes("m.discuss ?? m.planning"),
-    "discuss should fall back to m.planning",
-  );
-});
-
-test("validation unitTypes fall back to planning when models.validation is unset", () => {
-  assert.ok(
-    preferencesSrc.includes("m.validation ?? m.planning"),
-    "validation should fall back to m.planning",
-  );
-});
-
-test("all auto-dispatch unitTypes have preference mapping or subagent handling", () => {
-  const unmapped: string[] = [];
-  for (const ut of ALL_KNOWN_UNIT_TYPES) {
-    if (!preferencesSrc.includes(`"${ut}"`)) {
-      unmapped.push(ut);
-    }
-  }
-  assert.deepEqual(unmapped, [], `Unmapped unitTypes in preferences-models.ts: ${unmapped.join(", ")}`);
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// #2900: worktree-merge must map to completion phase
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("#2900: resolveModelWithFallbacksForUnit handles worktree-merge", () => {
-  assert.ok(preferencesSrc.includes('"worktree-merge"'), "missing worktree-merge case in switch");
-});
-
-// ═══════════════════════════════════════════════════════════════════════════
-// #2900: KNOWN_UNIT_TYPES must include all dispatched unit types
-// ═══════════════════════════════════════════════════════════════════════════
-
-const preferenceTypesSrc = readSrc("preferences-types.ts");
-
-test("#2900: KNOWN_UNIT_TYPES includes all auto-dispatch unit types", () => {
-  const missing: string[] = [];
-  for (const ut of ALL_KNOWN_UNIT_TYPES) {
-    if (!preferenceTypesSrc.includes(`"${ut}"`)) {
-      missing.push(ut);
-    }
-  }
-  assert.deepEqual(missing, [], `Missing from KNOWN_UNIT_TYPES: ${missing.join(", ")}`);
-});
+}
 
-test("#2900: KNOWN_UNIT_TYPES includes worktree-merge", () => {
-  assert.ok(preferenceTypesSrc.includes('"worktree-merge"'), "worktree-merge missing from KNOWN_UNIT_TYPES");
+test("discuss unit types route to the discuss model bucket", () => {
+  withModelPreferences(() => {
+    assert.equal(resolveModelWithFallbacksForUnit("discuss-milestone")?.primary, "discuss-model");
+    assert.equal(resolveModelWithFallbacksForUnit("discuss-slice")?.primary, "discuss-model");
+  });
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// metrics.ts: classifyUnitPhase coverage
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("classifyUnitPhase includes discussion phase", () => {
-  assert.ok(metricsSrc.includes('"discussion"'), "MetricsPhase should include discussion");
+test("validation unit types route to the validation model bucket", () => {
+  withModelPreferences(() => {
+    assert.equal(resolveModelWithFallbacksForUnit("validate-milestone")?.primary, "validation-model");
+    assert.equal(resolveModelWithFallbacksForUnit("gate-evaluate")?.primary, "validation-model");
+  });
 });
 
-test("classifyUnitPhase maps discuss-milestone and discuss-slice", () => {
-  assert.ok(metricsSrc.includes('"discuss-milestone"'), "missing discuss-milestone in metrics");
-  assert.ok(metricsSrc.includes('"discuss-slice"'), "missing discuss-slice in metrics");
+test("worktree-merge routes to completion and is recognized as a unit label", () => {
+  withModelPreferences(() => {
+    assert.ok(KNOWN_UNIT_LABELS.includes("worktree-merge"));
+    assert.equal(resolveModelWithFallbacksForUnit("worktree-merge")?.primary, "completion-model");
+  });
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// auto-post-unit.ts: LIFECYCLE_ONLY_UNITS
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("LIFECYCLE_ONLY_UNITS includes discuss-slice", () => {
-  assert.ok(postUnitSrc.includes('"discuss-slice"'), "discuss-slice should be lifecycle-only");
+test("every known unit label with a dispatch phase resolves when all model buckets are configured", () => {
+  withModelPreferences(() => {
+    const missing = KNOWN_UNIT_LABELS.filter((unitType) => !resolveModelWithFallbacksForUnit(unitType));
+    assert.deepEqual(missing, []);
+  });
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// auto-dashboard.ts: display label coverage
-// ═══════════════════════════════════════════════════════════════════════════
-
-test("unitVerb handles discuss-slice", () => {
-  assert.ok(dashboardSrc.includes('"discuss-slice"'), "missing discuss-slice in dashboard");
+test("discuss-slice has discussion metrics and dashboard labels", () => {
+  assert.equal(classifyUnitPhase("discuss-slice"), "discussion");
+  assert.equal(unitVerb("discuss-slice"), "discussing");
+  assert.equal(unitPhaseLabel("discuss-slice"), "DISCUSS");
 });
 
-// ═══════════════════════════════════════════════════════════════════════════
-// auto-artifact-paths.ts: artifact resolution
-// ═══════════════════════════════════════════════════════════════════════════
-
-// ═══════════════════════════════════════════════════════════════════════════
-// ADR-011: meta-test — every KNOWN_UNIT_TYPES entry must appear in all four
-// downstream registries so a future unit type added to KNOWN_UNIT_TYPES can't
-// silently fall through to wrong defaults in metrics/dashboard/artifacts/post-unit.
-// ═══════════════════════════════════════════════════════════════════════════
-
-// Intentional exceptions — unit types that legitimately rely on default/null
-// behavior in a specific registry. Entries captured here reflect the current
-// baseline at the time ADR-011 landed; adding to this allowlist for a NEW unit
-// type requires explicit justification in the commit.
-//
-// Test intent: catch the case where someone adds a new unit type to
-// KNOWN_UNIT_TYPES but forgets to wire it into one of the four registries.
-// The allowlist freezes the baseline so pre-existing omissions do not block
-// the test, but any brand-new addition must be either handled or justified.
-// Deep-mode project-level units (workflow-preferences, discuss-project,
-// discuss-requirements, research-decision, research-project) operate above
-// the milestone/slice/task model. They do not produce slice-shaped artifacts,
-// they do not have per-unit dashboard renderers, and they do not have
-// post-unit hooks that mirror execute/complete patterns. They legitimately
-// rely on default behavior in all four registries. Adding them to the
-// allowlist with this justification.
-const DEEP_MODE_PROJECT_UNITS = [
-  "workflow-preferences",
-  "discuss-project",
-  "discuss-requirements",
-  "research-decision",
-  "research-project",
-];
-
-const REGISTRY_EXCEPTIONS: Record<string, Set<string>> = {
-  // metrics.ts classifyUnitPhase uses default → "execution" for most unit types.
-  "metrics.ts": new Set([
-    "worktree-merge", "custom-step",
-    "rewrite-docs", "run-uat", "gate-evaluate", "replan-slice",
-    "reactive-execute", "validate-milestone", "complete-milestone",
-    ...DEEP_MODE_PROJECT_UNITS,
-  ]),
-  "auto-dashboard.ts": new Set([
-    "worktree-merge",
-    "gate-evaluate", "reactive-execute", "validate-milestone", "complete-milestone",
-    ...DEEP_MODE_PROJECT_UNITS,
-  ]),
-  "auto-artifact-paths.ts": new Set([
-    "rewrite-docs", "gate-evaluate", "reactive-execute", "discuss-slice", "worktree-merge",
-    ...DEEP_MODE_PROJECT_UNITS,
-  ]),
-  "auto-post-unit.ts": new Set([
-    "execute-task", "reactive-execute", "gate-evaluate", "worktree-merge",
-    ...DEEP_MODE_PROJECT_UNITS,
-  ]),
-};
-
-const REGISTRY_SOURCES: Array<[string, string]> = [
-  ["metrics.ts", metricsSrc],
-  ["auto-dashboard.ts", dashboardSrc],
-  ["auto-artifact-paths.ts", artifactSrc],
-  ["auto-post-unit.ts", postUnitSrc],
-];
-
-test("ADR-011 meta: every KNOWN_UNIT_TYPES entry appears in all 4 downstream registries", () => {
-  const missing: Array<{ registry: string; unitType: string }> = [];
-  for (const [registry, src] of REGISTRY_SOURCES) {
-    for (const ut of ALL_KNOWN_UNIT_TYPES) {
-      if (REGISTRY_EXCEPTIONS[registry]?.has(ut)) continue;
-      if (!src.includes(`"${ut}"`)) {
-        missing.push({ registry, unitType: ut });
-      }
-    }
+test("discuss-slice resolves to the slice context artifact path", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-discuss-artifact-"));
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+    const path = resolveExpectedArtifactPath("discuss-slice", "M001/S01", base);
+    assert.equal(path, join(realpathSync(base), ".gsd", "milestones", "M001", "slices", "S01", "S01-CONTEXT.md"));
+  } finally {
+    rmSync(base, { recursive: true, force: true });
   }
-  assert.deepEqual(
-    missing,
-    [],
-    "Each listed unit type is absent from the given registry — either add a handler or add to REGISTRY_EXCEPTIONS with justification:\n" +
-      missing.map((m) => `  ${m.registry}: "${m.unitType}"`).join("\n"),
-  );
-});
-
-test("resolveExpectedArtifactPath handles discuss-slice", () => {
-  assert.ok(artifactSrc.includes('"discuss-slice"'), "missing discuss-slice in artifact paths");
 });

package/src/resources/extensions/gsd/tests/needs-remediation-revalidation.test.ts

@@ -6,43 +6,50 @@
  * dispatch blocks completion for needs-remediation while state derives
  * completing-milestone, creating a permanent deadlock.
  *
- * This structural test verifies the verdict === 'needs-remediation' guard
- * exists at all three derivation paths in state.ts.
+ * This behavior test verifies DB-backed state derivation does not route a
+ * needs-remediation validation verdict into milestone completion.
  */
 
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const source = readFileSync(join(__dirname, '..', 'state.ts'), 'utf-8');
+import { mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from '../gsd-db.ts';
+import { deriveStateFromDb } from '../state.ts';
 
 describe('needs-remediation revalidation guard (#3670)', () => {
-  test('verdict === needs-remediation guard exists in state.ts', () => {
-    const matches = source.match(/verdict\s*===\s*['"]needs-remediation['"]/g);
-    assert.ok(matches, 'verdict === "needs-remediation" check must exist in state.ts');
-    assert.ok(matches.length >= 2,
-      `Expected at least 2 needs-remediation guards (deriveStateFromDb + _deriveStateImpl), found ${matches.length}`);
-  });
+  test('needs-remediation assessment blocks completion when every slice is done', async () => {
+    const base = mkdtempSync(join(tmpdir(), 'gsd-needs-remediation-'));
+    try {
+      openDatabase(':memory:');
+      insertMilestone({ id: 'M001', title: 'Needs remediation', status: 'active' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Done slice', status: 'complete' });
+      insertAssessment({
+        path: join(base, '.gsd', 'milestones', 'M001', 'M001-VALIDATION.md'),
+        milestoneId: 'M001',
+        status: 'needs-remediation',
+        scope: 'milestone-validation',
+        fullContent: 'Verdict: needs-remediation',
+      });
 
-  test('needsRevalidation variable is derived from verdict', () => {
-    assert.match(source, /needsRevalidation.*=.*verdict\s*===\s*['"]needs-remediation['"]/,
-      'needsRevalidation should incorporate verdict === "needs-remediation"');
-  });
-
-  test('deriveStateFromDb path uses needs-remediation guard', () => {
-    assert.match(source, /!validationTerminal\s*\|\|\s*verdict\s*===\s*['"]needs-remediation['"]/,
-      'deriveStateFromDb should check !validationTerminal || verdict === "needs-remediation"');
-  });
+      const state = await deriveStateFromDb(base);
 
-  test('extractVerdict is called on validation content', () => {
-    const extractCalls = source.match(/extractVerdict\(validationContent\)/g);
-    assert.ok(extractCalls, 'extractVerdict should be called on validation content');
-    assert.ok(extractCalls.length >= 2,
-      `Expected at least 2 extractVerdict calls, found ${extractCalls.length}`);
+      assert.equal(state.phase, 'blocked');
+      assert.match(state.nextAction, /remediation/i);
+      assert.ok(
+        state.blockers.some((blocker) => blocker.includes('needs-remediation')),
+        'blocked state explains the remediation verdict',
+      );
+    } finally {
+      closeDatabase();
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });