gsd-pi 2.82.0-dev.3709f22a5 → 2.82.0-dev.4285182e8

package/src/resources/extensions/gsd/tests/merge-db-cycle.test.ts

@@ -0,0 +1,179 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.js";
+import { _clearGsdRootCache } from "../paths.ts";
+import { _resetServiceCache } from "../worktree.ts";
+import { worktreePath } from "../worktree-manager.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function withPlatform<T>(platform: NodeJS.Platform, fn: () => T): T {
+  const descriptor = Object.getOwnPropertyDescriptor(process, "platform");
+  Object.defineProperty(process, "platform", { value: platform });
+  try {
+    return fn();
+  } finally {
+    if (descriptor) {
+      Object.defineProperty(process, "platform", descriptor);
+    }
+  }
+}
+
+function realGitPath(): string {
+  const gitExecPath = execFileSync("git", ["--exec-path"], {
+    encoding: "utf-8",
+  }).trim();
+  return join(gitExecPath, process.platform === "win32" ? "git.exe" : "git");
+}
+
+function installGitShim(bin: string, probePath: string): void {
+  const shim = join(bin, "git-proxy.cjs");
+  writeFileSync(
+    shim,
+    `
+const { appendFileSync, existsSync } = require("node:fs");
+const { join } = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const realGit = ${JSON.stringify(realGitPath())};
+const probePath = ${JSON.stringify(probePath)};
+const args = process.argv.slice(2);
+
+if (args[0] === "merge" && args[1] === "--squash") {
+  const sidecars = [
+    join(process.cwd(), ".gsd", "gsd.db-wal"),
+    join(process.cwd(), ".gsd", "gsd.db-shm"),
+  ];
+  const locked = sidecars.find((path) => existsSync(path));
+  if (locked) {
+    appendFileSync(probePath, "blocked:" + locked + "\\n");
+    console.error("error: local changes would be overwritten by merge");
+    console.error("\\t" + locked);
+    process.exit(1);
+  }
+  appendFileSync(probePath, "clean\\n");
+}
+
+const result = spawnSync(realGit, args, { stdio: "inherit", env: process.env });
+process.exit(result.status ?? 1);
+`,
+    "utf-8",
+  );
+
+  if (process.platform === "win32") {
+    writeFileSync(join(bin, "git.cmd"), `@echo off\r\nnode "%~dp0git-proxy.cjs" %*\r\n`, "utf-8");
+  } else {
+    const executable = join(bin, "git");
+    writeFileSync(executable, `#!/bin/sh\nexec node "${shim}" "$@"\n`, "utf-8");
+    chmodSync(executable, 0o755);
+  }
+}
+
+function createRepo(root: string): { repo: string; worktree: string } {
+  const repo = join(root, "repo");
+  mkdirSync(repo, { recursive: true });
+  git(["init"], repo);
+  git(["config", "user.email", "test@test.com"], repo);
+  git(["config", "user.name", "Test"], repo);
+  writeFileSync(join(repo, ".gitignore"), ".gsd/\n", "utf-8");
+  writeFileSync(join(repo, "README.md"), "# test\n", "utf-8");
+  git(["add", "."], repo);
+  git(["commit", "-m", "init"], repo);
+  git(["branch", "-M", "main"], repo);
+
+  git(["checkout", "-b", "milestone/M001"], repo);
+  writeFileSync(join(repo, "feature.txt"), "milestone change\n", "utf-8");
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(join(repo, ".gsd", "gsd.db-shm"), "milestone placeholder\n", "utf-8");
+  git(["add", "feature.txt"], repo);
+  git(["add", "-f", ".gsd/gsd.db-shm"], repo);
+  git(["commit", "-m", "feat: milestone change"], repo);
+  git(["checkout", "main"], repo);
+
+  const wt = worktreePath(repo, "M001");
+  mkdirSync(join(repo, ".gsd", "worktrees"), { recursive: true });
+  git(["worktree", "add", wt, "milestone/M001"], repo);
+  return { repo, worktree: wt };
+}
+
+test("mergeMilestoneToMain keeps the Windows DB cycle closed through squash merge", () => {
+  const savedCwd = process.cwd();
+  const originalPath = process.env.PATH ?? "";
+  const gitEnv = GIT_NO_PROMPT_ENV as NodeJS.ProcessEnv;
+  const originalGitEnvPath = gitEnv.PATH;
+  const originalHome = process.env.HOME;
+  const originalGsdHome = process.env.GSD_HOME;
+
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-db-cycle-")));
+  const fakeHome = join(root, "home");
+  const bin = join(root, "bin");
+  const probePath = join(root, "merge-probe.txt");
+  mkdirSync(fakeHome, { recursive: true });
+  mkdirSync(bin, { recursive: true });
+  installGitShim(bin, probePath);
+
+  try {
+    process.env.HOME = fakeHome;
+    process.env.GSD_HOME = join(fakeHome, ".gsd");
+    _clearGsdRootCache();
+    _resetServiceCache();
+
+    const { repo, worktree } = createRepo(root);
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+
+    withPlatform("win32", () => {
+      assert.equal(openDatabase(join(repo, ".gsd", "gsd.db")), true);
+      assert.equal(existsSync(join(repo, ".gsd", "gsd.db-shm")), true);
+
+      process.env.PATH = `${bin}${delimiter}${originalPath}`;
+      gitEnv.PATH = process.env.PATH;
+      process.chdir(worktree);
+
+      const result = mergeMilestoneToMain(repo, "M001", "# M001: Windows DB cycle\n");
+      assert.equal(result.codeFilesChanged, true);
+    });
+
+    assert.equal(git(["show", "HEAD:feature.txt"], repo), "milestone change");
+    assert.equal(readFileSync(probePath, "utf-8"), "clean\n");
+  } finally {
+    closeDatabase();
+    process.chdir(savedCwd);
+    process.env.PATH = originalPath;
+    gitEnv.PATH = originalGitEnvPath;
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    if (originalGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = originalGsdHome;
+    }
+    _clearGsdRootCache();
+    _resetServiceCache();
+    if (existsSync(root)) rmSync(root, { recursive: true, force: true });
+  }
+});

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

@@ -243,7 +243,8 @@ test("#4781 phase 2: validate-milestone rule writes pass-through VALIDATION for
   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\)/);
+  assert.match(content, /trivial-scope pipeline variant/);
+  assert.doesNotMatch(content, /#[0-9]{3,}/, "validation output must not include tracker-style refs");
 });
 
 test("#4781 phase 2: validate-milestone skip path does not persist gates without a real slice", async (t) => {

package/src/resources/extensions/gsd/tests/plan-slice.test.ts

@@ -2,7 +2,7 @@
 
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
@@ -105,6 +105,31 @@ test('handlePlanSlice writes slice/task planning state and renders plan artifact
   }
 });
 
+test('handlePlanSlice renders plan artifacts under worktree-local .gsd while using project DB', async () => {
+  const base = makeTmpBase();
+  const worktree = join(base, '.gsd', 'worktrees', 'M001');
+  mkdirSync(join(worktree, '.gsd'), { recursive: true });
+  mkdirSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools'), { recursive: true });
+  writeFileSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-milestone.ts'), '// fixture\n', 'utf-8');
+  writeFileSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-task.ts'), '// fixture\n', 'utf-8');
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParentSlice();
+
+    const result = await handlePlanSlice(validParams(), worktree);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const worktreePlan = join(worktree, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    const projectPlan = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    assert.ok(existsSync(worktreePlan), 'slice plan should be rendered to worktree-local .gsd');
+    assert.ok(!existsSync(projectPlan), 'slice plan should not be rendered to project .gsd');
+    assert.equal(result.planPath, realpathSync(worktreePlan));
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice advances DB-derived state out of planning immediately', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/post-unit-state-rebuild.test.ts

@@ -8,8 +8,32 @@ import assert from "node:assert/strict";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { createRequire } from "node:module";
 import { AutoSession } from "../auto/session.ts";
 import { postUnitPreVerification } from "../auto-post-unit.ts";
+import {
+  _getAdapter,
+  closeDatabase,
+  getTask,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
+
+const _require = createRequire(import.meta.url);
+
+function openRawSqliteForTest(dbPath: string): { exec(sql: string): void; close(): void } {
+  try {
+    const mod = _require("node:sqlite") as { DatabaseSync: new (path: string) => { exec(sql: string): void; close(): void } };
+    return new mod.DatabaseSync(dbPath);
+  } catch {
+    type SqliteCtor = new (path: string) => { exec(sql: string): void; close(): void };
+    const mod = _require("better-sqlite3") as SqliteCtor | { default: SqliteCtor };
+    const DatabaseCtor: SqliteCtor = typeof mod === "function" ? mod : mod.default;
+    return new DatabaseCtor(dbPath);
+  }
+}
 
 test("postUnitPreVerification rebuilds STATE.md after a completed unit", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-state-"));
@@ -47,3 +71,63 @@ test("postUnitPreVerification rebuilds STATE.md after a completed unit", async (
     rmSync(base, { recursive: true, force: true });
   }
 });
+
+test("postUnitPreVerification refreshes DB before checking execute-task completion", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-post-unit-db-refresh-"));
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "# Roadmap\n\n## Slices\n\n- [ ] **S01: Slice** `risk:low` `depends:[]`\n",
+    );
+    writeFileSync(
+      join(sliceDir, "S01-PLAN.md"),
+      "# S01: Slice\n\n## Tasks\n\n- [ ] **T01: Do work** `est:30m`\n",
+    );
+    writeFileSync(
+      join(tasksDir, "T01-SUMMARY.md"),
+      "---\nid: T01\nparent: S01\nmilestone: M001\n---\n# T01\nDone.\n",
+    );
+
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Do work", status: "pending" });
+    const adapterBefore = _getAdapter();
+
+    const externalDb = openRawSqliteForTest(dbPath);
+    try {
+      externalDb.exec("UPDATE tasks SET status = 'complete', completed_at = '2026-05-14T00:00:00.000Z' WHERE milestone_id = 'M001' AND slice_id = 'S01' AND id = 'T01'");
+    } finally {
+      externalDb.close();
+    }
+
+    const s = new AutoSession();
+    s.basePath = base;
+    s.originalBasePath = base;
+    s.currentMilestoneId = "M001";
+    s.currentUnit = { type: "execute-task", id: "M001/S01/T01", startedAt: Date.now() };
+
+    const result = await postUnitPreVerification({
+      s,
+      ctx: { ui: { notify() {} } } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}),
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => {},
+      updateProgressWidget: () => {},
+    }, { skipSettleDelay: true, skipWorktreeSync: true });
+
+    assert.equal(result, "continue");
+    assert.notEqual(_getAdapter(), adapterBefore, "post-unit flow must reopen the DB before deriving state");
+    assert.equal(getTask("M001", "S01", "T01")?.status, "complete");
+    assert.equal(s.pendingVerificationRetry, null);
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -141,3 +141,62 @@ test("category summaries expose the wizard menu surface for configured prefs", (
   assert.match(summaries.integrations, /remote: C123/);
   assert.match(summaries.verification, /1 cmd/);
 });
+
+test("models wizard offers discovered models for enabled providers", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-prefs-wizard-"));
+  const prefsPath = join(dir, "PREFERENCES.md");
+  const choices = [
+    "Models",
+    "local (2 models)",
+    "discovered-model",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+    "(keep current)",
+  ];
+  const ctx = {
+    modelRegistry: {
+      getAvailable: () => [{ provider: "local", id: "baseline-model" }],
+      getAllWithDiscovered: () => [
+        { provider: "local", id: "baseline-model" },
+        { provider: "local", id: "discovered-model" },
+        { provider: "disabled", id: "hidden-model" },
+      ],
+    },
+    ui: {
+      notify() {},
+      select: async (label: string, options: string[]) => {
+        const choice = choices.shift();
+        if (!choice && label === "GSD Preferences") return "── Save & Exit ──";
+        if (!choice && options.includes("(keep current)")) return "(keep current)";
+        if (!choice && options.includes("Done")) return "Done";
+        assert.ok(choice, `Unexpected prompt: ${label}`);
+        if (choice === "Models") {
+          const modelsOption = options.find((option) => option.startsWith("Models"));
+          assert.ok(modelsOption, "Expected Models category option");
+          return modelsOption;
+        }
+        assert.ok(options.includes(choice), `"${choice}" must be offered by "${label}"`);
+        assert.ok(!options.includes("hidden-model"), "models from disabled providers must not be offered");
+        return choice;
+      },
+      input: async () => null,
+    },
+    waitForIdle: async () => {},
+    reload: async () => {},
+  } as any;
+
+  try {
+    await handlePrefsWizard(ctx, "project", {}, { pathOverride: prefsPath });
+
+    assert.equal(choices.length, 0, "Expected all queued wizard choices to be consumed");
+    const saved = readFileSync(prefsPath, "utf-8");
+    assert.match(saved, /research:\s+local\/discovered-model/);
+    assert.doesNotMatch(saved, /hidden-model/);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -10,7 +10,12 @@ import assert from "node:assert/strict";
 import { classifyError, isTransient, isTransientNetworkError } from "../error-classifier.ts";
 import { pauseAutoForProviderError } from "../provider-error-pause.ts";
 import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.ts";
-import { MAX_TRANSIENT_AUTO_RESUMES, isTerminalDeletedWorktreeProviderError, resetTransientRetryState } from "../bootstrap/agent-end-recovery.ts";
+import {
+  MAX_TRANSIENT_AUTO_RESUMES,
+  isTerminalDeletedWorktreeProviderError,
+  resetTransientRetryState,
+  shouldDeferTransientErrorToCoreRetry,
+} from "../bootstrap/agent-end-recovery.ts";
 import { _buildCancelledUnitStopReason } from "../auto/phases.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
@@ -678,3 +683,15 @@ test("agent-session retryable error regex matches server_error (underscore)", ()
   // "temporarily backed off" must NOT be matched (intentional exclusion #3429)
   assert.ok(!RETRYABLE_ERROR_RE.test("temporarily backed off"));
 });
+
+test("exhausted retry errors are not deferred back to core retry handling", () => {
+  const cls = classifyError("Retry failed after 3 attempts: 500 empty_stream: upstream stream closed before first payload");
+  assert.equal(cls.kind, "server");
+  assert.equal(
+    shouldDeferTransientErrorToCoreRetry(
+      cls,
+      "Retry failed after 3 attempts: 500 empty_stream: upstream stream closed before first payload",
+    ),
+    false,
+  );
+});

package/src/resources/extensions/gsd/tests/quality-gates.test.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Validates planning and task template quality-gate content.
+
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -27,11 +30,14 @@ console.log("\n=== Level 1: Templates contain quality gate headings ===");
   const plan = loadTemplate("plan");
   assertTrue(plan.includes("## Threat Surface"), "plan.md contains ## Threat Surface");
   assertTrue(plan.includes("## Requirement Impact"), "plan.md contains ## Requirement Impact");
+  assertTrue(plan.includes("node --test"), "plan.md instructs using node --test for verification");
 
   const taskPlan = loadTemplate("task-plan");
   assertTrue(taskPlan.includes("## Failure Modes"), "task-plan.md contains ## Failure Modes");
   assertTrue(taskPlan.includes("## Load Profile"), "task-plan.md contains ## Load Profile");
   assertTrue(taskPlan.includes("## Negative Tests"), "task-plan.md contains ## Negative Tests");
+  assertTrue(taskPlan.includes("node --test"), "task-plan.md instructs using node --test for verification");
+  assertTrue(taskPlan.includes("node -e"), "task-plan.md mentions inline node -e as disallowed guidance");
 
   const sliceSummary = loadTemplate("slice-summary");
   assertTrue(sliceSummary.includes("## Operational Readiness"), "slice-summary.md contains ## Operational Readiness");

package/src/resources/extensions/gsd/tests/queue-reorder-ui.test.ts

@@ -0,0 +1,54 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { showQueueReorder } from "../queue-reorder-ui.ts";
+
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+describe("queue-reorder-ui", () => {
+  test("keeps cursor visible while scrolling long queue with arrow keys (#4656)", async () => {
+    const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+    Object.defineProperty(process.stdout, "rows", { value: 20, configurable: true });
+
+    try {
+      const pending = Array.from({ length: 20 }, (_, idx) => ({
+        id: `M${String(idx + 1).padStart(3, "0")}`,
+        title: `Milestone ${idx + 1}`,
+      }));
+
+      let resolved: { order: string[]; depsToRemove: Array<{ milestone: string; dep: string }> } | null = null;
+      let lastRender: string[] = [];
+
+      const ctx = {
+        hasUI: true,
+        ui: {
+          custom: async (factory: any) => {
+            const component = factory({ requestRender() {} }, fakeTheme, null, (value: any) => {
+              resolved = value;
+            });
+
+            for (let i = 0; i < 15; i++) component.handleInput("\u001b[B");
+            lastRender = component.render(100);
+            component.handleInput("\r");
+            return resolved;
+          },
+        },
+      } as any;
+
+      await showQueueReorder(ctx, [], pending);
+
+      const joined = lastRender.join("\n");
+      assert.ok(joined.includes("M016"), "selected item should stay visible after scrolling");
+      assert.ok(lastRender.length <= 16, `overlay should fit terminal max-height, got ${lastRender.length}`);
+    } finally {
+      if (originalRowsDescriptor) {
+        Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+      } else {
+        delete (process.stdout as { rows?: number }).rows;
+      }
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/remediation-completion-guard.test.ts

@@ -110,6 +110,49 @@ test("completing-milestone blocks when VALIDATION verdict is needs-attention (#5
   }
 });
 
+test("completing-milestone blocks when VALIDATION verdict is fail (#5920)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-fail-verdict-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      [
+        "---",
+        "verdict: fail",
+        "---",
+        "",
+        "# Validation Report",
+        "",
+        "Blocking failures remain unresolved.",
+      ].join("\n"),
+    );
+
+    const ctx = {
+      mid: "M001",
+      midTitle: "Test Milestone",
+      basePath: base,
+      state: { phase: "completing-milestone" } as any,
+      prefs: {} as any,
+      session: undefined,
+    };
+
+    const result = await completingRule!.match(ctx);
+
+    assert.ok(result !== null, "rule should match");
+    assert.equal(result!.action, "stop", "should return stop action");
+    if (result!.action === "stop") {
+      assert.equal(result!.level, "warning", "should be warning level (pausable)");
+      assert.ok(
+        result!.reason.includes('verdict is "fail"'),
+        "reason should mention fail verdict",
+      );
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("completing-milestone proceeds normally when VALIDATION verdict is pass (#2675 guard)", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-remediation-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });

package/src/resources/extensions/gsd/tests/run-uat-replay-cap.test.ts

@@ -36,7 +36,7 @@ function makeUatProject(): string {
   return base;
 }
 
-test("run-uat dispatch stops after three attempts without a verdict", async () => {
+test("run-uat dispatch skips after three attempts without a verdict", async () => {
   const basePath = makeUatProject();
   const rule = DISPATCH_RULES.find((r) => r.name === "run-uat (post-completion)");
   assert.ok(rule, "run-uat dispatch rule is registered");
@@ -58,8 +58,7 @@ test("run-uat dispatch stops after three attempts without a verdict", async () =
     }
 
     const capped = await rule.match(ctx as any);
-    assert.equal(capped?.action, "stop");
-    assert.match(capped?.reason ?? "", /dispatched 3 times/);
+    assert.equal(capped?.action, "skip");
     assert.equal(getUatCount(basePath, "M001", "S01"), 4);
   } finally {
     rmSync(basePath, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/status-guards.test.ts

@@ -3,7 +3,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 
-import { isClosedStatus } from '../status-guards.ts';
+import { isClosedStatus, isFutureMilestoneStatus } from '../status-guards.ts';
 
 test('isClosedStatus: "complete" returns true', () => {
   assert.equal(isClosedStatus('complete'), true);
@@ -32,3 +32,15 @@ test('isClosedStatus: "active" returns false', () => {
 test('isClosedStatus: "" (empty string) returns false', () => {
   assert.equal(isClosedStatus(''), false);
 });
+
+test('isFutureMilestoneStatus includes future milestone aliases', () => {
+  assert.equal(isFutureMilestoneStatus('pending'), true);
+  assert.equal(isFutureMilestoneStatus('queued'), true);
+  assert.equal(isFutureMilestoneStatus('planned'), true);
+});
+
+test('isFutureMilestoneStatus excludes active and closed milestones', () => {
+  assert.equal(isFutureMilestoneStatus('active'), false);
+  assert.equal(isFutureMilestoneStatus('complete'), false);
+  assert.equal(isFutureMilestoneStatus('parked'), false);
+});

package/src/resources/extensions/gsd/tests/unit-context-manifest.test.ts

@@ -301,6 +301,23 @@ test("#5843: run-uat uses verification tools policy so build/test commands can r
   assert.match(sourceWriteResult.reason!, /tools-policy "verification"/);
 });
 
+test("planning-dispatch hard block message omits internal tracker references", () => {
+  const manifest = UNIT_MANIFESTS["validate-milestone"];
+  assert.strictEqual(manifest.tools.mode, "planning-dispatch");
+
+  const result = shouldBlockPlanningUnit(
+    "task",
+    "scout",
+    process.cwd(),
+    "validate-milestone",
+    manifest.tools,
+  );
+
+  assert.strictEqual(result.block, true);
+  assert.ok(result.reason, "blocked dispatch should include a user-facing reason");
+  assert.doesNotMatch(result.reason!, /#[0-9]{3,}/);
+});
+
 test('planning-dispatch mode is reserved for slice-level decomposition and completion units', () => {
   const allowedDispatchUnits = new Set([
     "plan-slice",

package/src/resources/extensions/gsd/tests/validate-milestone-stuck-guard.test.ts

@@ -162,7 +162,7 @@ describe("validate-milestone stuck-loop guard (#4094)", () => {
     assert.equal(pauseAutoMock.mock.callCount(), 0);
   });
 
-  test("continues when no VALIDATION file exists yet", async () => {
+  test("retries when no VALIDATION file exists yet", async () => {
     insertMilestone({ id: "M001" });
     insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
 
@@ -173,7 +173,34 @@ describe("validate-milestone stuck-loop guard (#4094)", () => {
 
     const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
 
-    assert.equal(result, "continue");
+    assert.equal(result, "retry");
+    assert.equal(pauseAutoMock.mock.callCount(), 0);
+    assert.ok(s.pendingVerificationRetry);
+    assert.equal(s.pendingVerificationRetry!.unitId, "M001");
+    assert.match(s.pendingVerificationRetry!.failureContext, /gsd_validate_milestone/);
+    assert.equal(s.pendingVerificationRetry!.attempt, 1);
+  });
+
+  test("retries when VALIDATION file exists but is empty", async () => {
+    insertMilestone({ id: "M001" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice 1", status: "complete" });
+
+    const path = join(tempDir, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+    writeFileSync(path, "", "utf-8");
+    invalidateAllCaches();
+
+    const ctx = makeMockCtx();
+    const pi = makeMockPi();
+    const pauseAutoMock = mock.fn(async () => {});
+    const s = makeMockSession(tempDir, "validate-milestone", "M001");
+
+    const result = await runPostUnitVerification({ s, ctx, pi } as VerificationContext, pauseAutoMock);
+
+    assert.equal(result, "retry");
     assert.equal(pauseAutoMock.mock.callCount(), 0);
+    assert.ok(s.pendingVerificationRetry);
+    assert.equal(s.pendingVerificationRetry!.unitId, "M001");
+    assert.match(s.pendingVerificationRetry!.failureContext, /exists but is empty/);
+    assert.equal(s.pendingVerificationRetry!.attempt, 1);
   });
 });