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

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/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));

package/src/resources/extensions/gsd/tests/preferences-worktree-sync.test.ts

@@ -12,7 +12,6 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { extractSourceRegion } from "./test-helpers.ts";
 
 test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)", () => {
   const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
@@ -41,22 +40,9 @@ test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)",
   );
 });
 
-test("copyPlanningArtifacts prefers canonical PREFERENCES.md with lowercase fallback", () => {
-  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
-  const src = readFileSync(srcPath, "utf-8");
-
-  // Find the copyPlanningArtifacts function body
-  const fnIdx = src.indexOf("function copyPlanningArtifacts");
-  assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
-
-  // Extract function body (up to the next top-level function)
-  const fnBody = extractSourceRegion(src, "function copyPlanningArtifacts");
-
-  assert.ok(
-    fnBody.includes("PROJECT_PREFERENCES_FILE") && fnBody.includes("LEGACY_PROJECT_PREFERENCES_FILE"),
-    "copyPlanningArtifacts should prefer canonical PREFERENCES.md and retain lowercase fallback via the shared constants",
-  );
-});
+// Phase C: copyPlanningArtifacts was deleted. Worktrees no longer
+// maintain a parallel .gsd/ projection; preference seeding is now
+// handled exclusively by syncGsdStateToWorktree() (covered below).
 
 test("syncGsdStateToWorktree copies canonical PREFERENCES.md", async () => {
   // Functional test: create a mock source and destination, call the sync

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -231,6 +231,116 @@ test("register-hooks returns hard blocker when depth question is cancelled", asy
     patch?.content?.[0]?.text ?? "",
     /Do not infer approval from earlier or prior messages/,
   );
+  // Regression for milestone-hang: the cancelled-gate instruction must direct
+  // the agent toward the most reliable recovery path — re-calling
+  // ask_user_questions with the same gate id. The plain-text path also clears
+  // the gate via isExplicitApprovalResponse on the next before_agent_start,
+  // but the structured re-ask is more deterministic, so the message points
+  // there and avoids the prior dead-end "ask in plain chat, then stop" wording.
+  assert.match(
+    patch?.content?.[0]?.text ?? "",
+    /Re-call ask_user_questions with the same gate question id/,
+    "must instruct the agent to re-ask via ask_user_questions",
+  );
+  assert.doesNotMatch(
+    patch?.content?.[0]?.text ?? "",
+    /confirm in plain chat, then stop/,
+    "must not direct the agent down the prior dead-end plain-chat-and-stop path",
+  );
+});
+
+test("register-hooks recovers from a cancelled depth question via re-asked ask_user_questions (milestone-hang regression)", async (t) => {
+  const dir = makeTempDir("recovery");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState(dir);
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const questionId = "depth_verification_M001_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Did I capture the project correctly?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Not quite — let me clarify" },
+      ],
+    },
+  ];
+
+  // 1. Initial ask sets the gate.
+  for (const handler of handlers.get("tool_call") ?? []) {
+    await handler({ toolName: "ask_user_questions", input: { questions } });
+  }
+  assert.equal(getPendingGate(), questionId, "initial ask must set the gate");
+
+  // 2. User cancels (simulates the trap from the screenshot: question never
+  //    answered through the structured channel). Gate must stay pending.
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: { cancelled: true, response: null },
+    });
+  }
+  assert.equal(getPendingGate(), questionId, "cancelled response must leave gate pending");
+
+  // 3. Recovery path: immediately re-call ask_user_questions with the same
+  //    gate id and identical input. This must not be blocked by the strict
+  //    duplicate-call loop guard, because the hard-block instruction above
+  //    tells the agent to do exactly this and not to interleave other tools.
+  const reaskBlocks: any[] = [];
+  for (const handler of handlers.get("tool_call") ?? []) {
+    const result = await handler({ toolName: "ask_user_questions", input: { questions } });
+    if (result?.block) reaskBlocks.push(result);
+  }
+  assert.equal(
+    reaskBlocks.length,
+    0,
+    "immediate identical re-ask must not be blocked by the tool-call loop guard",
+  );
+
+  // 4. The re-asked question receives a confirming response, which clears the
+  //    gate and unlocks the milestone context save.
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: {
+        response: {
+          answers: {
+            [questionId]: { selected: "Yes, you got it (Recommended)" },
+          },
+        },
+      },
+    });
+  }
+
+  assert.equal(getPendingGate(), null, "confirming re-ask must clear the gate");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M001").block,
+    false,
+    "context save must unlock after recovery",
+  );
 });
 
 test("register-hooks gates MCP ask_user_questions cancellation before requirement saves", async (t) => {

package/src/resources/extensions/gsd/tests/runtime-kv.test.ts

@@ -0,0 +1,120 @@
+// gsd-2 + runtime_kv non-correctness-critical key-value storage tests (Phase C)
+
+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, _getAdapter } from "../gsd-db.ts";
+import {
+  setRuntimeKv,
+  getRuntimeKv,
+  deleteRuntimeKv,
+  listRuntimeKv,
+} from "../db/runtime-kv.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-runtime-kv-"));
+  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("set + get round-trip preserves the value", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("global", "", "ui_cursor", { row: 5, col: 10 });
+  const got = getRuntimeKv<{ row: number; col: number }>("global", "", "ui_cursor");
+  assert.deepEqual(got, { row: 5, col: 10 });
+});
+
+test("get returns null for missing keys", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  assert.equal(getRuntimeKv("global", "", "missing"), null);
+});
+
+test("set on existing key updates the value (idempotent upsert)", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("worker", "w1", "counter", 1);
+  setRuntimeKv("worker", "w1", "counter", 42);
+  assert.equal(getRuntimeKv("worker", "w1", "counter"), 42);
+});
+
+test("scope partitioning: same key under different scopes is independent", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("global", "", "k", "global-value");
+  setRuntimeKv("worker", "w1", "k", "worker-value");
+  setRuntimeKv("milestone", "M001", "k", "milestone-value");
+
+  assert.equal(getRuntimeKv("global", "", "k"), "global-value");
+  assert.equal(getRuntimeKv("worker", "w1", "k"), "worker-value");
+  assert.equal(getRuntimeKv("milestone", "M001", "k"), "milestone-value");
+});
+
+test("scope_id partitioning: same scope+key under different scope_ids is independent", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("worker", "w1", "k", "v1");
+  setRuntimeKv("worker", "w2", "k", "v2");
+  assert.equal(getRuntimeKv("worker", "w1", "k"), "v1");
+  assert.equal(getRuntimeKv("worker", "w2", "k"), "v2");
+});
+
+test("delete removes the row; subsequent get returns null", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("worker", "w1", "k", "value");
+  deleteRuntimeKv("worker", "w1", "k");
+  assert.equal(getRuntimeKv("worker", "w1", "k"), null);
+});
+
+test("list returns all rows for a scope+scope_id, ordered by key", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  setRuntimeKv("milestone", "M001", "alpha", 1);
+  setRuntimeKv("milestone", "M001", "gamma", 3);
+  setRuntimeKv("milestone", "M001", "beta", 2);
+  setRuntimeKv("milestone", "M002", "ignored", "different-scope");
+
+  const rows = listRuntimeKv("milestone", "M001");
+  assert.equal(rows.length, 3);
+  assert.deepEqual(rows.map(r => r.key), ["alpha", "beta", "gamma"]);
+});
+
+test("malformed JSON in storage returns null without throwing", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  // Inject a malformed value directly (bypassing setRuntimeKv's JSON.stringify).
+  setRuntimeKv("global", "", "k", "valid");
+  // Then poison the row via raw SQL.
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE runtime_kv SET value_json = '{not json' WHERE scope = 'global' AND scope_id = '' AND key = 'k'`,
+  ).run();
+
+  assert.equal(getRuntimeKv("global", "", "k"), null);
+});

package/src/resources/extensions/gsd/tests/skipped-validation-completion.test.ts

@@ -1,39 +1,144 @@
 /**
  * Regression test for #3698 — allow milestone completion when validation
- * was skipped by preference
- *
- * When validation is skipped due to user preference (e.g. budget profile),
- * auto-dispatch should recognize the "skipped by preference" pattern and
- * allow completion instead of treating it as a missing validation.
+ * was skipped by preference.
  */
 
-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';
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import {
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+  upsertMilestonePlanning,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import type { GSDState } from "../types.ts";
 
-const autoDispatchSrc = readFileSync(
-  join(__dirname, '..', 'auto-dispatch.ts'),
-  'utf-8',
-);
+const COMPLETE_RULE = "completing-milestone → complete-milestone";
 
-describe('skipped validation completion (#3698)', () => {
-  test('skippedByPreference regex detection exists', () => {
-    assert.match(autoDispatchSrc, /skippedByPreference/,
-      'skippedByPreference variable should exist in auto-dispatch.ts');
-  });
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-skipped-validation-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(join(base, "app.js"), "export const shipped = true;\n");
+  return base;
+}
 
-  test('regex matches skip-by-preference patterns', () => {
-    assert.match(autoDispatchSrc, /skip\(\?:ped\)\?\[\\s\\-\]\+\(\?:by\|per\|due to\)/,
-      'should have regex matching "skipped by/per/due to" patterns');
-  });
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
 
-  test('skippedByPreference feeds into operational check', () => {
-    assert.match(autoDispatchSrc, /hasOperationalCheck\s*=\s*skippedByPreference/,
-      'skippedByPreference should be part of hasOperationalCheck');
+function seedMilestone(base: string): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({
+    id: "M001",
+    title: "Preference-skipped validation milestone",
+    status: "active",
+    depends_on: [],
+  });
+  upsertMilestonePlanning("M001", {
+    title: "Preference-skipped validation milestone",
+    status: "active",
+    vision: "Ship a small implementation with a documented validation skip.",
+    successCriteria: ["Completion remains unblocked when validation was intentionally skipped."],
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "Smoke-test the shipped workflow before completion.",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
   });
+  insertSlice({
+    id: "S01",
+    milestoneId: "M001",
+    title: "First",
+    status: "done",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+}
+
+function writeFixtureFiles(base: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [x] **S01: First** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+  writeFileSync(
+    join(milestoneDir, "slices", "S01", "S01-SUMMARY.md"),
+    "# S01\n\nImplemented the shipped workflow.\n",
+  );
+  writeFileSync(
+    join(milestoneDir, "M001-VALIDATION.md"),
+    [
+      "---",
+      "verdict: pass",
+      "skip_validation: true",
+      "skip_validation_reason: preference",
+      "remediation_round: 0",
+      "---",
+      "",
+      "# Milestone Validation (skipped)",
+      "",
+      "Milestone validation was skipped by preference.",
+    ].join("\n"),
+  );
+}
+
+function findRule(name: string) {
+  const rule = DISPATCH_RULES.find(candidate => candidate.name === name);
+  assert.ok(rule, `rule "${name}" must exist`);
+  return rule!;
+}
+
+function makeCtx(base: string): DispatchContext {
+  const state: GSDState = {
+    phase: "completing-milestone",
+    activeMilestone: { id: "M001", title: "Preference-skipped validation milestone" },
+    activeSlice: null,
+    activeTask: null,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [{ id: "M001", title: "Preference-skipped validation milestone", status: "active" }],
+  };
+  return {
+    basePath: base,
+    mid: "M001",
+    midTitle: "Preference-skipped validation milestone",
+    state,
+    prefs: undefined,
+  };
+}
+
+test("#3698: completing-milestone dispatch accepts skipped validation fixture", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base);
+  writeFixtureFiles(base);
+
+  const result = await findRule(COMPLETE_RULE).match(makeCtx(base));
+
+  assert.ok(result, "rule must return a result");
+  assert.strictEqual(result!.action, "dispatch", "skipped validation should still allow completion dispatch");
+  if (result!.action === "dispatch") {
+    assert.strictEqual(result.unitType, "complete-milestone");
+  }
 });

package/src/resources/extensions/gsd/tests/skipped-validation-db-atomicity.test.ts

@@ -0,0 +1,17 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+test("skipped validation DB persistence stays atomic", () => {
+  const source = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
+
+  assert.match(
+    source,
+    /if \(isDbAvailable\(\)\) \{\s+transaction\(\(\) => \{\s+insertAssessment\([\s\S]*?insertMilestoneValidationGates\(/,
+    "skipped validation DB writes must remain inside a single transaction",
+  );
+});