gsd-pi 2.56.0-dev.b753b00 → 2.57.0-dev.75d5ac5

package/src/resources/extensions/gsd/preferences-models.ts

@@ -56,16 +56,28 @@ export function resolveModelWithFallbacksForUnit(unitType: string): ResolvedMode
     case "replan-slice":
       phaseConfig = m.planning;
       break;
+    case "discuss-milestone":
+    case "discuss-slice":
+      phaseConfig = m.discuss ?? m.planning;
+      break;
     case "execute-task":
+    case "reactive-execute":
       phaseConfig = m.execution;
       break;
     case "execute-task-simple":
       phaseConfig = m.execution_simple ?? m.execution;
       break;
     case "complete-slice":
+    case "complete-milestone":
     case "run-uat":
       phaseConfig = m.completion;
       break;
+    case "reassess-roadmap":
+    case "rewrite-docs":
+    case "gate-evaluate":
+    case "validate-milestone":
+      phaseConfig = m.validation ?? m.planning;
+      break;
     default:
       // Subagent unit types (e.g., "subagent", "subagent/scout")
       if (unitType === "subagent" || unitType.startsWith("subagent/")) {

package/src/resources/extensions/gsd/preferences-types.ts

@@ -134,9 +134,11 @@ export interface GSDPhaseModelConfig {
 export interface GSDModelConfig {
   research?: string;
   planning?: string;
+  discuss?: string;
   execution?: string;
   execution_simple?: string;
   completion?: string;
+  validation?: string;
   subagent?: string;
 }
 
@@ -147,9 +149,11 @@ export interface GSDModelConfig {
 export interface GSDModelConfigV2 {
   research?: string | GSDPhaseModelConfig;
   planning?: string | GSDPhaseModelConfig;
+  discuss?: string | GSDPhaseModelConfig;
   execution?: string | GSDPhaseModelConfig;
   execution_simple?: string | GSDPhaseModelConfig;
   completion?: string | GSDPhaseModelConfig;
+  validation?: string | GSDPhaseModelConfig;
   subagent?: string | GSDPhaseModelConfig;
 }
 

package/src/resources/extensions/gsd/preferences.ts

@@ -22,6 +22,7 @@ import { normalizeStringArray } from "../shared/format-utils.js";
 import { resolveProfileDefaults as _resolveProfileDefaults } from "./preferences-models.js";
 
 import {
+  KNOWN_PREFERENCE_KEYS,
   MODE_DEFAULTS,
   type WorkflowMode,
   type GSDPreferences,
@@ -250,7 +251,7 @@ function parseFrontmatterBlock(frontmatter: string): GSDPreferences {
  *   - planner: sonnet
  */
 function parseHeadingListFormat(content: string): GSDPreferences {
-  const result: Record<string, Record<string, string>> = {};
+  const result: Record<string, string[]> = {};
   let currentSection: string | null = null;
 
   for (const rawLine of content.split('\n')) {
@@ -258,27 +259,44 @@ function parseHeadingListFormat(content: string): GSDPreferences {
     const headingMatch = line.match(/^##\s+(.+)$/);
     if (headingMatch) {
       currentSection = headingMatch[1].trim().toLowerCase().replace(/\s+/g, '_');
+      if (!result[currentSection]) result[currentSection] = [];
       continue;
     }
-    if (currentSection) {
-      const itemMatch = line.match(/^-\s+([^:]+):\s*(.*)$/);
-      if (itemMatch) {
-        if (!result[currentSection]) result[currentSection] = {};
-        const value = itemMatch[2].trim();
-        // Coerce "true"/"false" strings and numbers
-        result[currentSection][itemMatch[1].trim()] = value;
-      }
+    if (currentSection && line.trim() && !line.trimStart().startsWith('#')) {
+      result[currentSection].push(line);
     }
   }
 
-  // Convert string values to appropriate types via YAML parser for each section
   const typed: Record<string, unknown> = {};
-  for (const [section, entries] of Object.entries(result)) {
-    const yamlLines = Object.entries(entries).map(([k, v]) => `${k}: ${v}`).join('\n');
+  for (const [section, lines] of Object.entries(result)) {
+    if (lines.length === 0) continue;
+
+    const usesLegacyListItems = lines.every((line) => /^\s*-\s+[^:]+:\s*.*$/.test(line));
+    const yamlBlock = usesLegacyListItems
+      ? lines.map((line) => line.replace(/^\s*-\s+/, '')).join('\n')
+      : lines.join('\n');
+
     try {
-      typed[section] = parseYaml(yamlLines);
+      const parsed = parseYaml(yamlBlock);
+      if (typeof parsed !== 'object' || parsed === null) continue;
+
+      let targetSection = section;
+      let value: unknown = parsed;
+
+      if (!Array.isArray(parsed)) {
+        const keys = Object.keys(parsed);
+        if (keys.length === 1) {
+          const [onlyKey] = keys;
+          if (onlyKey === section || (!KNOWN_PREFERENCE_KEYS.has(section) && KNOWN_PREFERENCE_KEYS.has(onlyKey))) {
+            targetSection = onlyKey;
+            value = (parsed as Record<string, unknown>)[onlyKey];
+          }
+        }
+      }
+
+      typed[targetSection] = value;
     } catch {
-      typed[section] = entries;
+      /* malformed section — skip */
     }
   }
 

package/src/resources/extensions/gsd/prompts/validate-milestone.md

@@ -26,7 +26,7 @@ All relevant context has been preloaded below — the roadmap, all slice summari
 4. Check **requirement coverage** — are all active requirements addressed by at least one slice?
 5. If **Verification Classes** are provided in the inlined context above, check each non-empty class:
    - For each verification class (Contract, Integration, Operational, UAT), determine whether slice summaries, UAT results, or observable behavior provide evidence that this verification tier was addressed.
-   - Document the compliance status of each class in your verdict rationale.
+   - Document the compliance status of each class in a dedicated verification classes section.
    - If `Operational` verification is non-empty and no evidence of operational verification exists, flag this explicitly — it means planned operational checks (migrations, deployments, runtime verification) were not proven.
    - A milestone with unaddressed verification classes may still pass if the gaps are minor, but the gaps MUST be documented in the Deferred Work Inventory.
 6. Determine a verdict:
@@ -36,7 +36,7 @@ All relevant context has been preloaded below — the roadmap, all slice summari
 
 ## Persist Validation
 
-**Persist validation results through `gsd_validate_milestone`.** Call it with: `milestoneId`, `verdict`, `remediationRound`, `successCriteriaChecklist`, `sliceDeliveryAudit`, `crossSliceIntegration`, `requirementCoverage`, `verdictRationale`, and `remediationPlan` (if verdict is `needs-remediation`). The tool writes the validation to the DB and renders VALIDATION.md to disk.
+**Persist validation results through `gsd_validate_milestone`.** Call it with: `milestoneId`, `verdict`, `remediationRound`, `successCriteriaChecklist`, `sliceDeliveryAudit`, `crossSliceIntegration`, `requirementCoverage`, `verificationClasses` (when non-empty), `verdictRationale`, and `remediationPlan` (if verdict is `needs-remediation`). The tool writes the validation to the DB and renders VALIDATION.md to disk.
 
 If verdict is `needs-remediation`:
 - After calling `gsd_validate_milestone`, use `gsd_reassess_roadmap` to add remediation slices. Pass `milestoneId`, a synthetic `completedSliceId` (e.g. "VALIDATION"), `verdict: "roadmap-adjusted"`, `assessment` text, and `sliceChanges` with the new slices in the `added` array. The tool persists the changes to the DB and re-renders ROADMAP.md.

package/src/resources/extensions/gsd/roadmap-slices.ts

@@ -82,6 +82,7 @@ function parseTableSlices(section: string): RoadmapSliceEntry[] {
     const fullRow = line.toLowerCase();
     const done =
       /\[x\]/i.test(line) ||
+      /[✅☑✓]/.test(line) ||
       /\bdone\b/.test(fullRow) ||
       /\bcomplete(?:d)?\b/.test(fullRow);
 

package/src/resources/extensions/gsd/tests/auto-loop.test.ts

@@ -79,11 +79,17 @@ function makeMockCtx() {
  */
 function makeMockPi() {
   const calls: unknown[] = [];
+  const setModelCalls: unknown[] = [];
   return {
     sendMessage: (...args: unknown[]) => {
       calls.push(args);
     },
+    setModel: async (...args: unknown[]) => {
+      setModelCalls.push(args);
+      return true;
+    },
     calls,
+    setModelCalls,
   } as any;
 }
 
@@ -227,6 +233,38 @@ test("runUnit only arms resolve after newSession completes", async () => {
   assert.equal(pi.calls.length, 1);
 });
 
+test("runUnit re-applies the selected unit model after newSession before dispatch", async () => {
+  _resetPendingResolve();
+
+  const callOrder: string[] = [];
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  pi.setModel = async (...args: unknown[]) => {
+    callOrder.push("setModel");
+    pi.setModelCalls.push(args);
+    return true;
+  };
+  pi.sendMessage = (...args: unknown[]) => {
+    callOrder.push("sendMessage");
+    pi.calls.push(args);
+  };
+
+  const s = makeMockSession();
+  s.currentUnitModel = { provider: "anthropic", id: "claude-opus-4-6" };
+
+  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt");
+
+  await new Promise((r) => setTimeout(r, 10));
+  resolveAgentEnd(makeEvent());
+
+  const result = await resultPromise;
+  assert.equal(result.status, "completed");
+  assert.deepEqual(callOrder, ["setModel", "sendMessage"]);
+  assert.equal(pi.setModelCalls.length, 1);
+  assert.deepEqual(pi.setModelCalls[0][0], s.currentUnitModel);
+  assert.equal(pi.calls.length, 1);
+});
+
 // ─── Structural assertions ───────────────────────────────────────────────────
 
 test("auto-loop.ts exports autoLoop, runUnit, resolveAgentEnd", async () => {
@@ -372,7 +410,7 @@ function makeMockDeps(
     captureAvailableSkills: () => {},
     ensurePreconditions: () => {},
     updateSliceProgressCache: () => {},
-    selectAndApplyModel: async () => ({ routing: null }),
+    selectAndApplyModel: async () => ({ routing: null, appliedModel: null }),
     startUnitSupervision: () => {},
     getDeepDiagnostic: () => null,
     isDbAvailable: () => false,
@@ -1195,6 +1233,24 @@ test("startAuto calls selfHealRuntimeRecords before autoLoop (#1727)", { skip: "
   );
 });
 
+test("startAuto guards against concurrent invocation (#2923)", () => {
+  const src = readFileSync(
+    resolve(import.meta.dirname, "..", "auto.ts"),
+    "utf-8",
+  );
+  const fnIdx = src.indexOf("export async function startAuto");
+  assert.ok(fnIdx > -1, "startAuto must exist in auto.ts");
+  // The guard must appear before any other logic in the function body
+  const fnBody = src.slice(fnIdx, fnIdx + 500);
+  const activeGuard = fnBody.indexOf("if (s.active)");
+  assert.ok(activeGuard > -1, "startAuto must check s.active to prevent concurrent auto-loops");
+  const returnIdx = fnBody.indexOf("return;", activeGuard);
+  assert.ok(
+    returnIdx > -1 && returnIdx < activeGuard + 120,
+    "s.active guard must early-return to prevent a second concurrent loop",
+  );
+});
+
 test("agent_end handler calls resolveAgentEnd (not handleAgentEnd)", () => {
   const hooksSrc = readFileSync(
     resolve(import.meta.dirname, "..", "bootstrap", "register-hooks.ts"),

package/src/resources/extensions/gsd/tests/auto-start-cold-db-bootstrap.test.ts

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, report } = createTestContext();
+
+const srcPath = join(import.meta.dirname, "..", "auto-start.ts");
+const src = readFileSync(srcPath, "utf-8");
+
+console.log("\n=== #2841: cold DB opened before initial deriveState ===");
+
+const helperIdx = src.indexOf("async function openProjectDbIfPresent");
+assertTrue(helperIdx >= 0, "auto-start.ts defines a helper for pre-derive DB open (#2841)");
+
+const helperRegion = helperIdx >= 0 ? src.slice(helperIdx, helperIdx + 500) : "";
+assertTrue(
+  helperRegion.includes("resolveProjectRootDbPath(basePath)"),
+  "pre-derive DB helper resolves the project-root DB path (#2841)",
+);
+assertTrue(
+  helperRegion.includes("openDatabase(gsdDbPath)"),
+  "pre-derive DB helper opens the resolved DB path (#2841)",
+);
+
+const firstDeriveIdx = src.indexOf("let state = await deriveState(base);");
+assertTrue(firstDeriveIdx > 0, "auto-start.ts has the initial deriveState(base) call");
+
+const preDeriveRegion = firstDeriveIdx > 0 ? src.slice(0, firstDeriveIdx) : "";
+const preDeriveOpenIdx = preDeriveRegion.lastIndexOf("await openProjectDbIfPresent(base);");
+
+assertTrue(
+  preDeriveOpenIdx > 0,
+  "bootstrapAutoSession opens the DB before the first deriveState(base) call (#2841)",
+);
+
+report();

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -200,7 +200,7 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     captureAvailableSkills: () => {},
     ensurePreconditions: () => {},
     updateSliceProgressCache: () => {},
-    selectAndApplyModel: async () => ({ routing: null }),
+    selectAndApplyModel: async () => ({ routing: null, appliedModel: null }),
     resolveModelId: () => undefined,
     startUnitSupervision: () => {},
     getDeepDiagnostic: () => null,

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

@@ -216,3 +216,50 @@ test("dispatch guard works without git repo", (t) => {
 
   assert.equal(getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S02"), null);
 });
+
+test("dispatch guard skips cross-milestone check when GSD_MILESTONE_LOCK is set (#2797)", (t) => {
+  const repo = setupRepo();
+  t.after(() => {
+    delete process.env.GSD_MILESTONE_LOCK;
+    teardownRepo(repo);
+  });
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M010"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M011"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M012"), { recursive: true });
+
+  // M010 and M011 have incomplete slices
+  insertMilestone({ id: "M010", title: "Analytics" });
+  insertSlice({ id: "S01", milestoneId: "M010", title: "Data Quality", status: "pending", depends: [], sequence: 1 });
+
+  insertMilestone({ id: "M011", title: "Builder Onboarding" });
+  insertSlice({ id: "S01", milestoneId: "M011", title: "Schema", status: "pending", depends: [], sequence: 1 });
+
+  insertMilestone({ id: "M012", title: "Shared Components" });
+  insertSlice({ id: "S01", milestoneId: "M012", title: "Foundation", status: "pending", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M012", title: "Migrate Pages", status: "pending", depends: ["S01"], sequence: 2 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M010", "M010-ROADMAP.md"), "# M010\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M011", "M011-ROADMAP.md"), "# M011\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M012", "M012-ROADMAP.md"), "# M012\n");
+
+  // Without lock: M012 blocked by M010's incomplete S01
+  delete process.env.GSD_MILESTONE_LOCK;
+  assert.match(
+    getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M012/S01/T01") ?? "",
+    /earlier slice M010\/S01 is not complete/,
+  );
+
+  // With lock: M012 only checks its own intra-milestone deps — S01 has none, so unblocked
+  process.env.GSD_MILESTONE_LOCK = "M012";
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M012/S01/T01"),
+    null,
+  );
+
+  // With lock: M012/S02 still blocked by M012/S01 (intra-milestone dep preserved)
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M012/S02/T01"),
+    "Cannot dispatch execute-task M012/S02/T01: dependency slice M012/S01 is not complete.",
+  );
+});

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -97,7 +97,7 @@ function makeMockDeps(
     captureAvailableSkills: () => {},
     ensurePreconditions: () => {},
     updateSliceProgressCache: () => {},
-    selectAndApplyModel: async () => ({ routing: null }),
+    selectAndApplyModel: async () => ({ routing: null, appliedModel: null }),
     startUnitSupervision: () => {},
     getDeepDiagnostic: () => null,
     isDbAvailable: () => false,

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

@@ -0,0 +1,192 @@
+/**
+ * Model UnitType Mapping — regression tests for #2865.
+ *
+ * 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>
+ */
+
+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()}...`);
+    }
+  }
+});
+
+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(", ")}`);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// metrics.ts: classifyUnitPhase coverage
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("classifyUnitPhase includes discussion phase", () => {
+  assert.ok(metricsSrc.includes('"discussion"'), "MetricsPhase should include discussion");
+});
+
+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");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// 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");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// auto-dashboard.ts: display label coverage
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("unitVerb handles discuss-slice", () => {
+  assert.ok(dashboardSrc.includes('"discuss-slice"'), "missing discuss-slice in dashboard");
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// auto-artifact-paths.ts: artifact resolution
+// ═══════════════════════════════════════════════════════════════════════════
+
+test("resolveExpectedArtifactPath handles discuss-slice", () => {
+  assert.ok(artifactSrc.includes('"discuss-slice"'), "missing discuss-slice in artifact paths");
+});

package/src/resources/extensions/gsd/tests/parallel-worker-monitoring.test.ts

@@ -131,14 +131,15 @@ describe("parallel-worker-monitoring", () => {
     assert.ok(!(5.01 < ceiling), "5.01 is over ceiling");
   });
 
-  it("worker spawn args include --mode json", () => {
-    // Verify the spawn command includes JSON mode for NDJSON output.
-    // We can't easily test the actual spawn, but we verify the args pattern.
-    const expectedArgs = ["--mode", "json", "--print", "/gsd auto"];
-    assert.ok(expectedArgs.includes("--mode"), "args include --mode");
-    assert.ok(expectedArgs.includes("json"), "args include json");
-    assert.ok(expectedArgs.indexOf("--mode") < expectedArgs.indexOf("json"),
-      "--mode comes before json");
+  it("worker spawn args use headless --json auto (#2792)", () => {
+    // Verify the spawn command uses headless mode (not --print which exits
+    // before auto-mode can run). See #2792.
+    const expectedArgs = ["headless", "--json", "auto"];
+    assert.ok(expectedArgs.includes("headless"), "args include headless");
+    assert.ok(expectedArgs.includes("--json"), "args include --json");
+    assert.ok(expectedArgs.includes("auto"), "args include auto");
+    assert.ok(expectedArgs.indexOf("headless") < expectedArgs.indexOf("auto"),
+      "headless comes before auto");
   });
 
   it("refreshWorkerStatuses restores persisted workers from disk", () => {

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -352,6 +352,40 @@ test("handles empty models config", () => {
   assert.equal(prefs!.models, undefined);
 });
 
+test("parses raw YAML blocks under headings", () => {
+  const content = `## Parallel
+enabled: true
+max_workers: 3
+`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.notEqual(prefs, null);
+  assert.equal(prefs!.parallel?.enabled, true);
+  assert.equal(prefs!.parallel?.max_workers, 3);
+});
+
+test("unwraps nested top-level preference key under descriptive headings", () => {
+  const content = `## Parallel Orchestration
+parallel:
+  enabled: true
+  max_workers: 3
+`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.notEqual(prefs, null);
+  assert.equal(prefs!.parallel?.enabled, true);
+  assert.equal(prefs!.parallel?.max_workers, 3);
+});
+
+test("preserves legacy heading list format", () => {
+  const content = `## Git
+- isolation: branch
+- auto_push: true
+`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.notEqual(prefs, null);
+  assert.equal(prefs!.git?.isolation, "branch");
+  assert.equal(prefs!.git?.auto_push, true);
+});
+
 // ── Warn-once for unrecognized format (#2373) ────────────────────────────────
 
 test("unrecognized format warning is emitted at most once (#2373)", () => {

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -181,6 +181,13 @@ test("reassess-roadmap prompt references gsd_reassess_roadmap tool", () => {
   assert.match(prompt, /gsd_reassess_roadmap/);
 });
 
+test("validate-milestone prompt persists verification classes through gsd_validate_milestone", () => {
+  const prompt = readPrompt("validate-milestone");
+  assert.match(prompt, /verification classes section/i);
+  assert.match(prompt, /verificationClasses/);
+  assert.match(prompt, /gsd_validate_milestone/);
+});
+
 // ─── Prompt migration: replan-slice → gsd_replan_slice ────────────────
 
 test("replan-slice prompt names gsd_replan_slice as the tool to use", () => {

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -116,6 +116,23 @@ test("parseRoadmapSlices: table with Status Done/Complete text (#1736)", () => {
   assert.equal(slices[2]?.done, true);
 });
 
+test("parseRoadmapSlices: table with glyph completion markers (#2841)", () => {
+  const tableContent = [
+    "# M003: Glyph Status", "", "## Slices", "",
+    "| Slice | Title | Risk | Status |", "|---|---|---|---|",
+    "| S01 | First | Low | ✅ |",
+    "| S02 | Second | High | Pending |",
+    "| S03 | Third | Medium | ☑ |",
+    "| S04 | Fourth | Medium | ✓ |", "",
+  ].join("\n");
+  const slices = parseRoadmapSlices(tableContent);
+  assert.equal(slices.length, 4);
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.done, false);
+  assert.equal(slices[2]?.done, true);
+  assert.equal(slices[3]?.done, true);
+});
+
 test("parseRoadmapSlices: table with dependencies column (#1736)", () => {
   const tableContent = [
     "# M004: Deps", "", "## Slices", "",