gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

package/src/resources/extensions/gsd/tests/path-normalization-unified.test.ts

@@ -0,0 +1,175 @@
+// GSD-2 + Unified path normalization tests: normalizeRealPath and tryRealpath parity
+
+import { describe, test, before, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  existsSync,
+  rmSync,
+  realpathSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { normalizeRealPath } from "../paths.ts";
+import { createWorkspace } from "../workspace.ts";
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+/**
+ * Detect whether the filesystem hosting `dir` is case-insensitive.
+ * Creates a file with a lowercase name, then probes it via an uppercase name.
+ */
+function isCaseInsensitiveFs(dir: string): boolean {
+  const lower = join(dir, "ci_probe_lower.txt");
+  const upper = join(dir, "CI_PROBE_LOWER.TXT");
+  try {
+    writeFileSync(lower, "probe");
+    return existsSync(upper);
+  } finally {
+    try { rmSync(lower); } catch { /* ignore */ }
+  }
+}
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-pathnorm-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+// ─── Suite 1: normalizeRealPath and tryRealpath return identical strings ──────
+
+describe("normalizeRealPath and tryRealpath produce identical results", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("normalizeRealPath on an existing directory matches realpathSync.native", () => {
+    const result = normalizeRealPath(projectDir);
+    // realpathSync.native is the canonical form — result must equal it
+    const expected = realpathSync.native(projectDir);
+    assert.equal(result, expected);
+  });
+
+  test("createWorkspace identityKey equals normalizeRealPath of projectRoot", () => {
+    const ws = createWorkspace(projectDir);
+    // identityKey is computed via tryRealpath → normalizeRealPath
+    assert.equal(ws.identityKey, normalizeRealPath(ws.projectRoot));
+  });
+
+  test("createWorkspace identityKey and normalizeRealPath agree on the same input", () => {
+    const ws = createWorkspace(projectDir);
+    const direct = normalizeRealPath(projectDir);
+    assert.equal(ws.identityKey, direct);
+  });
+});
+
+// ─── Suite 2: non-existent path fallback ─────────────────────────────────────
+
+describe("normalizeRealPath: fallback for non-existent paths", () => {
+  test("returns a resolved (absolute) path for a non-existent input", () => {
+    const ghost = join(tmpdir(), "gsd-pathnorm-ghost-does-not-exist-" + Date.now());
+    const result = normalizeRealPath(ghost);
+    // Must be a string, must be absolute, must not throw
+    assert.equal(typeof result, "string");
+    assert.ok(result.startsWith("/") || /^[A-Za-z]:/.test(result), "result must be absolute");
+  });
+
+  test("normalizeRealPath of a non-existent path is idempotent", () => {
+    const ghost = join(tmpdir(), "gsd-pathnorm-ghost2-" + Date.now());
+    const first = normalizeRealPath(ghost);
+    const second = normalizeRealPath(first);
+    assert.equal(first, second);
+  });
+});
+
+// ─── Suite 3: idempotency on existing paths ───────────────────────────────────
+
+describe("normalizeRealPath: idempotency on existing paths", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("normalizeRealPath of a normalizeRealPath result is the same", () => {
+    const once = normalizeRealPath(projectDir);
+    const twice = normalizeRealPath(once);
+    assert.equal(once, twice);
+  });
+
+  test("createWorkspace identityKey is idempotent across two calls with same path", () => {
+    const ws1 = createWorkspace(projectDir);
+    const ws2 = createWorkspace(projectDir);
+    assert.equal(ws1.identityKey, ws2.identityKey);
+  });
+});
+
+// ─── Suite 4: case-insensitive filesystem (macOS HFS+/APFS) ──────────────────
+
+describe("normalizeRealPath: case normalization on case-insensitive volumes", () => {
+  let projectDir: string;
+  let caseInsensitive: boolean;
+
+  before(() => {
+    // Detect FS case sensitivity once for the suite
+    const probe = mkdtempSync(join(tmpdir(), "gsd-ci-probe-"));
+    caseInsensitive = isCaseInsensitiveFs(probe);
+    rmSync(probe, { recursive: true, force: true });
+  });
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("upper and lower case paths resolve to the same canonical string on case-insensitive FS", (t) => {
+    if (!caseInsensitive) {
+      t.skip("case-sensitive filesystem — case-normalization check not applicable");
+      return;
+    }
+
+    const lower = projectDir.toLowerCase();
+    const upper = projectDir.toUpperCase();
+
+    const canonicalFromLower = normalizeRealPath(lower);
+    const canonicalFromUpper = normalizeRealPath(upper);
+
+    assert.equal(
+      canonicalFromLower,
+      canonicalFromUpper,
+      "both case variants must resolve to the same canonical path on case-insensitive FS",
+    );
+  });
+
+  test("createWorkspace identityKey is case-stable on case-insensitive FS", (t) => {
+    if (!caseInsensitive) {
+      t.skip("case-sensitive filesystem — case-normalization check not applicable");
+      return;
+    }
+
+    const wsLower = createWorkspace(projectDir.toLowerCase());
+    const wsUpper = createWorkspace(projectDir.toUpperCase());
+
+    assert.equal(
+      wsLower.identityKey,
+      wsUpper.identityKey,
+      "identityKey must be identical regardless of input case on case-insensitive FS",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/paths-cache.test.ts

@@ -0,0 +1,170 @@
+// GSD2 — paths cache normalization and clearPathCache() invalidation tests
+
+import { describe, test, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, renameSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { gsdRoot, clearPathCache, _clearGsdRootCache } from '../paths.ts';
+
+describe('gsdRootCache key normalization', () => {
+  let projectDir: string;
+  let fakeHome: string;
+  let savedHome: string | undefined;
+  let savedUserProfile: string | undefined;
+  let savedGsdHome: string | undefined;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-cache-norm-')));
+    mkdirSync(join(projectDir, '.gsd'), { recursive: true });
+
+    fakeHome = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-cache-home-')));
+
+    savedHome = process.env.HOME;
+    savedUserProfile = process.env.USERPROFILE;
+    savedGsdHome = process.env.GSD_HOME;
+
+    // Point HOME and GSD_HOME at an unrelated temp dir to prevent ~/.gsd interference.
+    process.env.HOME = fakeHome;
+    process.env.USERPROFILE = fakeHome;
+    process.env.GSD_HOME = join(fakeHome, '.gsd');
+
+    _clearGsdRootCache();
+  });
+
+  afterEach(() => {
+    if (savedHome === undefined) delete process.env.HOME;
+    else process.env.HOME = savedHome;
+    if (savedUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = savedUserProfile;
+    if (savedGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = savedGsdHome;
+
+    clearPathCache();
+    rmSync(projectDir, { recursive: true, force: true });
+    rmSync(fakeHome, { recursive: true, force: true });
+  });
+
+  test('gsdRoot with trailing slash returns same result as without', () => {
+    const withoutSlash = gsdRoot(projectDir);
+    _clearGsdRootCache();
+    const withSlash = gsdRoot(projectDir + '/');
+
+    assert.equal(
+      withoutSlash,
+      withSlash,
+      'gsdRoot must return the same path regardless of trailing slash',
+    );
+    assert.equal(
+      withoutSlash,
+      join(projectDir, '.gsd'),
+      'both calls should resolve to projectDir/.gsd',
+    );
+  });
+
+  test('second call with trailing slash hits cache set by first call without slash', () => {
+    // Prime the cache with the no-slash form.
+    const first = gsdRoot(projectDir);
+    // Now remove .gsd so a fresh probe would return a different path.
+    renameSync(join(projectDir, '.gsd'), join(projectDir, '.gsd-hidden'));
+    // Call with trailing slash — must hit the normalized cache entry (no re-probe).
+    const second = gsdRoot(projectDir + '/');
+    // Restore for cleanup.
+    renameSync(join(projectDir, '.gsd-hidden'), join(projectDir, '.gsd'));
+
+    assert.equal(
+      second,
+      first,
+      'trailing-slash call must return cached result from the no-slash call',
+    );
+  });
+});
+
+describe('clearPathCache() does NOT invalidate gsdRootCache (process-lifetime semantics)', () => {
+  let projectDir: string;
+  let fakeHome: string;
+  let savedHome: string | undefined;
+  let savedUserProfile: string | undefined;
+  let savedGsdHome: string | undefined;
+
+  beforeEach(() => {
+    projectDir = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-cache-clear-')));
+    mkdirSync(join(projectDir, '.gsd'), { recursive: true });
+
+    fakeHome = realpathSync(mkdtempSync(join(tmpdir(), 'gsd-cache-home2-')));
+
+    savedHome = process.env.HOME;
+    savedUserProfile = process.env.USERPROFILE;
+    savedGsdHome = process.env.GSD_HOME;
+
+    process.env.HOME = fakeHome;
+    process.env.USERPROFILE = fakeHome;
+    process.env.GSD_HOME = join(fakeHome, '.gsd');
+
+    _clearGsdRootCache();
+  });
+
+  afterEach(() => {
+    if (savedHome === undefined) delete process.env.HOME;
+    else process.env.HOME = savedHome;
+    if (savedUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = savedUserProfile;
+    if (savedGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = savedGsdHome;
+
+    _clearGsdRootCache();
+    clearPathCache();
+    rmSync(projectDir, { recursive: true, force: true });
+    rmSync(fakeHome, { recursive: true, force: true });
+  });
+
+  test('clearPathCache() does NOT evict a cached gsdRoot result', (t) => {
+    // Prime the cache.
+    const firstResult = gsdRoot(projectDir);
+    assert.equal(firstResult, join(projectDir, '.gsd'));
+
+    // Remove .gsd so a fresh probe would return a different (fallback) result.
+    renameSync(join(projectDir, '.gsd'), join(projectDir, '.gsd-hidden'));
+    t.after(() => {
+      try { renameSync(join(projectDir, '.gsd-hidden'), join(projectDir, '.gsd')); } catch { /* ignore */ }
+    });
+
+    // clearPathCache() only clears volatile dir caches — gsdRootCache is untouched.
+    clearPathCache();
+    const afterClearPath = gsdRoot(projectDir);
+    assert.equal(
+      afterClearPath,
+      firstResult,
+      'clearPathCache must NOT evict gsdRootCache — result must still be the cached value',
+    );
+  });
+
+  test('_clearGsdRootCache() DOES evict gsdRootCache, causing re-probe', (t) => {
+    // Prime the cache.
+    const firstResult = gsdRoot(projectDir);
+    assert.equal(firstResult, join(projectDir, '.gsd'));
+
+    // Remove .gsd so a fresh probe returns the creation fallback.
+    renameSync(join(projectDir, '.gsd'), join(projectDir, '.gsd-hidden'));
+    t.after(() => {
+      try { renameSync(join(projectDir, '.gsd-hidden'), join(projectDir, '.gsd')); } catch { /* ignore */ }
+    });
+
+    // _clearGsdRootCache() evicts the entry — next call re-probes.
+    _clearGsdRootCache();
+    const afterClearRoot = gsdRoot(projectDir);
+    assert.equal(
+      afterClearRoot,
+      join(projectDir, '.gsd'),
+      'after _clearGsdRootCache, gsdRoot must re-probe and return creation fallback',
+    );
+    // The two results are equal (same path) but the key point is re-probe occurred;
+    // the cached firstResult also happened to equal the fallback path.
+    // Verify: if we prime again without removing .gsd, clearing root re-probes to gsd.
+    renameSync(join(projectDir, '.gsd-hidden'), join(projectDir, '.gsd'));
+    _clearGsdRootCache();
+    const reprobe = gsdRoot(projectDir);
+    assert.equal(reprobe, join(projectDir, '.gsd'), 're-probe after restore returns .gsd');
+  });
+});

package/src/resources/extensions/gsd/tests/paused-session-via-db.test.ts

@@ -0,0 +1,119 @@
+// gsd-2 + Paused-session via runtime_kv (Phase C pt 2 — paused-session.json migration)
+//
+// runtime/paused-session.json is gone. The metadata that the old file
+// stored now lives in runtime_kv (global scope, key PAUSED_SESSION_KV_KEY).
+// readPausedSessionMetadata reads the key; the writer in pauseAuto +
+// the cleanup in stopAuto/startAuto/guided-flow all use the same key.
+//
+// These tests verify the round-trip via the storage layer directly.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  openDatabase,
+  closeDatabase,
+} from "../gsd-db.ts";
+import {
+  setRuntimeKv,
+  getRuntimeKv,
+  deleteRuntimeKv,
+} from "../db/runtime-kv.ts";
+import {
+  readPausedSessionMetadata,
+  PAUSED_SESSION_KV_KEY,
+  type PausedSessionMetadata,
+} from "../interrupted-session.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-paused-session-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  try { rmSync(base, { recursive: true, force: true }); } catch { /* noop */ }
+}
+
+test("readPausedSessionMetadata returns null when no row exists", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  assert.equal(readPausedSessionMetadata(base), null);
+});
+
+test("readPausedSessionMetadata round-trips a real PausedSessionMetadata payload", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const meta: PausedSessionMetadata = {
+    milestoneId: "M001",
+    worktreePath: "/tmp/wt",
+    originalBasePath: base,
+    stepMode: false,
+    pausedAt: new Date().toISOString(),
+    sessionFile: "/tmp/session.jsonl",
+    unitType: "plan-slice",
+    unitId: "M001/S01",
+    activeEngineId: "dev",
+    activeRunDir: null,
+    autoStartTime: Date.now(),
+    milestoneLock: null,
+  };
+  setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, meta);
+
+  const loaded = readPausedSessionMetadata(base);
+  assert.ok(loaded);
+  assert.equal(loaded!.milestoneId, "M001");
+  assert.equal(loaded!.unitType, "plan-slice");
+  assert.equal(loaded!.unitId, "M001/S01");
+  assert.equal(loaded!.sessionFile, "/tmp/session.jsonl");
+});
+
+test("readPausedSessionMetadata auto-deletes stale pseudo-milestone pause rows", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  // discuss-milestone with a non-MID-shaped unitId triggers
+  // isStalePseudoMilestonePause → returns null + deletes the row.
+  const stale: PausedSessionMetadata = {
+    milestoneId: "M001",
+    unitType: "discuss-milestone",
+    unitId: "PROJECT-thing",
+    activeEngineId: "dev",
+  };
+  setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, stale);
+
+  assert.equal(readPausedSessionMetadata(base), null);
+  assert.equal(getRuntimeKv("global", "", PAUSED_SESSION_KV_KEY), null,
+    "stale row was deleted by readPausedSessionMetadata");
+});
+
+test("deleteRuntimeKv on PAUSED_SESSION_KV_KEY removes the row idempotently", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, { milestoneId: "M001" });
+  deleteRuntimeKv("global", "", PAUSED_SESSION_KV_KEY);
+  deleteRuntimeKv("global", "", PAUSED_SESSION_KV_KEY); // idempotent — no throw
+  assert.equal(readPausedSessionMetadata(base), null);
+});
+
+test("readPausedSessionMetadata returns null when DB is unavailable", () => {
+  // No openDatabase call — DB is closed.
+  try { closeDatabase(); } catch { /* noop */ }
+  // Use a tmpdir-style base; the function should handle DB-unavailable gracefully.
+  const base = mkdtempSync(join(tmpdir(), "gsd-paused-no-db-"));
+  try {
+    assert.equal(readPausedSessionMetadata(base), null);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/pending-autostart-scope.test.ts

@@ -0,0 +1,120 @@
+// GSD-2 + Tests for MilestoneScope pinning in pendingAutoStartMap (C1 regression guard)
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  setPendingAutoStart,
+  clearPendingAutoStart,
+  _getPendingAutoStart,
+} from "../guided-flow.ts";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-pas-scope-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe("pendingAutoStart scope pinning (C1)", () => {
+  let base: string;
+
+  beforeEach(() => {
+    clearPendingAutoStart();
+    base = makeProjectDir();
+  });
+
+  afterEach(() => {
+    clearPendingAutoStart();
+    if (base) {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test("setPendingAutoStart stores a scope whose paths derive from the basePath at reservation time", () => {
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+
+    const entry = _getPendingAutoStart(base);
+    assert.ok(entry, "entry should exist");
+    assert.ok(entry.scope, "entry.scope should be set");
+    assert.equal(entry.scope.milestoneId, "M001");
+
+    const expectedContext = join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md");
+    const expectedRoadmap = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const expectedState = join(base, ".gsd", "STATE.md");
+
+    assert.equal(entry.scope.contextFile(), expectedContext);
+    assert.equal(entry.scope.roadmapFile(), expectedRoadmap);
+    assert.equal(entry.scope.stateFile(), expectedState);
+  });
+
+  test("scope paths are unaffected by process.chdir after reservation", (t) => {
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M002" });
+
+    const entry = _getPendingAutoStart(base);
+    assert.ok(entry, "entry should exist");
+
+    // Capture paths before cwd change
+    const ctxBefore = entry.scope.contextFile();
+    const roadmapBefore = entry.scope.roadmapFile();
+    const stateBefore = entry.scope.stateFile();
+
+    // Change cwd to a different directory, then check that scope is unchanged
+    const originalCwd = process.cwd();
+    const altDir = mkdtempSync(join(tmpdir(), "gsd-cwd-alt-"));
+    t.after(() => {
+      process.chdir(originalCwd);
+      rmSync(altDir, { recursive: true, force: true });
+    });
+
+    process.chdir(altDir);
+
+    assert.equal(entry.scope.contextFile(), ctxBefore, "contextFile must not change after cwd drift");
+    assert.equal(entry.scope.roadmapFile(), roadmapBefore, "roadmapFile must not change after cwd drift");
+    assert.equal(entry.scope.stateFile(), stateBefore, "stateFile must not change after cwd drift");
+  });
+
+  test("scope identityKey matches the realpath of the original basePath even with trailing slash", () => {
+    const baseWithSlash = base + "/";
+    setPendingAutoStart(base, { basePath: baseWithSlash, milestoneId: "M003" });
+
+    const entry = _getPendingAutoStart(base);
+    assert.ok(entry, "entry should exist");
+
+    const expectedIdentityKey = realpathSync(base);
+    assert.equal(
+      entry.scope.workspace.identityKey,
+      expectedIdentityKey,
+      "identityKey must match realpath of the original (non-canonical) basePath",
+    );
+  });
+
+  test("clearPendingAutoStart removes the entry", () => {
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+
+    const before = _getPendingAutoStart(base);
+    assert.ok(before, "entry should exist before clear");
+
+    clearPendingAutoStart(base);
+
+    const after = _getPendingAutoStart(base);
+    assert.equal(after, null, "entry should be null after clearPendingAutoStart(base)");
+  });
+
+  test("_getPendingAutoStart with no basePath argument returns the sole entry", () => {
+    setPendingAutoStart(base, { basePath: base, milestoneId: "M001" });
+
+    // No argument — should return the sole entry
+    const entry = _getPendingAutoStart();
+    assert.ok(entry, "sole entry should be returned when no basePath given");
+    assert.equal(entry.milestoneId, "M001");
+    assert.ok(entry.scope, "sole entry must have a scope");
+    assert.equal(entry.scope.milestoneId, "M001");
+  });
+});

package/src/resources/extensions/gsd/tests/pipeline-variant-dispatch.test.ts

@@ -11,6 +11,7 @@ import { tmpdir } from "node:os";
 
 import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
 import {
+  _getAdapter,
   openDatabase,
   closeDatabase,
   insertMilestone,
@@ -241,9 +242,66 @@ test("#4781 phase 2: validate-milestone rule writes pass-through VALIDATION for
   const { readFileSync } = await import("node:fs");
   const content = readFileSync(validationPath, "utf-8");
   assert.match(content, /verdict: pass/);
+  assert.match(content, /skip_validation: true/);
   assert.match(content, /trivial-scope pipeline variant \(#4781\)/);
 });
 
+test("#4781 phase 2: validate-milestone skip path does not persist gates without a real slice", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({
+    id: "M001",
+    title: TRIVIAL_INPUT.title,
+    status: "active",
+    depends_on: [],
+  });
+  upsertMilestonePlanning("M001", {
+    title: TRIVIAL_INPUT.title,
+    status: "active",
+    vision: TRIVIAL_INPUT.vision,
+    successCriteria: TRIVIAL_INPUT.successCriteria,
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+
+  const { writeFileSync, readFileSync } = await import("node:fs");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "",
+      "_No slices required for this trivial milestone._",
+    ].join("\n"),
+  );
+
+  const ctx = makeCtx({ base, mid: "M001", phase: "validating-milestone" });
+  const result = await findRule(VALIDATE_RULE).match(ctx);
+
+  assert.ok(result, "rule must return a result, not null");
+  assert.strictEqual(result!.action, "skip", "trivial variant must still skip without slices");
+
+  const validationPath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+  const content = readFileSync(validationPath, "utf-8");
+  assert.match(content, /skip_validation: true/);
+
+  const adapter = _getAdapter();
+  assert.ok(adapter, "test database should be open");
+  const gateCount = adapter.prepare(
+    "SELECT count(*) AS n FROM quality_gates WHERE milestone_id = 'M001'",
+  ).get() as { n: number };
+  assert.equal(gateCount.n, 0, "skip path must not persist milestone gates without a real slice id");
+});
+
 test("#4781 phase 2: validate-milestone rule dispatches normally for standard variant", async (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));