@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -15,13 +15,16 @@ import {
   insertGateRun,
   readTransaction,
   saveGateResult,
+  upsertMilestonePlanning,
   upsertQualityGate,
 } from "../gsd-db.js";
+import { extractMilestoneSeq } from "../milestone-ids.js";
 import { GATE_REGISTRY } from "../gate-registry.js";
 import { generateRequirementsMd, saveArtifactToDb } from "../db-writer.js";
-import { clearPathCache, relSliceFile, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
+import { clearPathCache, normalizeRealPath, relMilestoneFile, relSliceFile, relSlicePath, resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { unlinkSync } from "node:fs";
+import { hostname } from "node:os";
 import { join } from "node:path";
 import type { CompleteMilestoneParams } from "./complete-milestone.js";
 import { handleCompleteMilestone } from "./complete-milestone.js";
@@ -48,13 +51,21 @@ import { logError, logWarning } from "../workflow-logger.js";
 import { invalidateStateCache } from "../state.js";
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { parseProject } from "../schemas/parsers.js";
-import { getAutoRuntimeSnapshot } from "../auto-runtime-state.js";
+import { autoSession, getAutoRuntimeSnapshot, isAutoActive } from "../auto-runtime-state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import {
   prepareUatRun,
   saveUatAttemptArtifact,
   type UatResultSaveParams,
 } from "../uat-run.js";
+import { registerAutoWorker, markWorkerStopping, getAutoWorker } from "../db/auto-workers.js";
+import {
+  claimMilestoneLease,
+  releaseMilestoneLease,
+  getMilestoneLease,
+  refreshMilestoneLease,
+  milestoneLeaseTtlSeconds,
+} from "../db/milestone-leases.js";
 export type {
   UatCheckResultInput,
   UatEvidenceRef,
@@ -105,6 +116,24 @@ function blockIfWrongAutoUnit(requiredUnitType: string, operation: string): Tool
   };
 }
 
+function milestoneLeaseConflictResult(
+  milestoneId: string,
+  byWorker: string,
+  expiresAt: string,
+): ToolExecutionResult {
+  return {
+    content: [{ type: "text", text: `Milestone ${milestoneId} is currently leased by ${byWorker}. Retry after ${expiresAt}.` }],
+    details: {
+      operation: "plan_milestone",
+      error: "milestone_lease_conflict",
+      milestoneId,
+      byWorker,
+      expiresAt,
+    },
+    isError: true,
+  };
+}
+
 export interface SummarySaveParams {
   milestone_id?: string;
   slice_id?: string;
@@ -116,7 +145,34 @@ export interface SummarySaveParams {
 function registerProjectMilestoneSequence(content: string): string[] {
   const parsed = parseProject(content);
   const registered: string[] = [];
+  // Reconcile parsed IDs against existing DB milestones before inserting (#807).
+  // Under unique_milestone_ids the planner mints suffixed IDs (e.g. "M001-b1nole"),
+  // while PROJECT.md's template uses bare sequence IDs (e.g. "M001"). Inserting the
+  // bare ID verbatim mints a phantom milestone row that collides with the planner's
+  // canonical one: the bare row gets its own git worktree, and at dispatch time the
+  // worktree/session scope ("M001") disagrees with ctx.mid ("M001-b1nole"), pausing
+  // auto-mode with "Dispatch milestone mismatch". A project DB holds at most one
+  // milestone per sequence number, so map each parsed line onto the existing row
+  // that shares its sequence number instead of minting a duplicate bare-ID row.
+  const existingBySeq = new Map<number, string>();
+  for (const existing of getAllMilestones()) {
+    const seq = extractMilestoneSeq(existing.id);
+    if (seq > 0 && !existingBySeq.has(seq)) existingBySeq.set(seq, existing.id);
+  }
   for (const milestone of parsed.milestones) {
+    const canonicalId = existingBySeq.get(extractMilestoneSeq(milestone.id));
+    if (canonicalId && canonicalId !== milestone.id) {
+      // An existing milestone already owns this sequence number. Treat the markdown
+      // line as referring to it: refresh the human title, and promote to complete
+      // when the line is checked — but never demote an in-flight milestone back to
+      // "queued" (the planner's row stays the single source of truth).
+      upsertMilestonePlanning(canonicalId, {
+        title: milestone.title,
+        ...(milestone.done ? { status: "complete" } : {}),
+      });
+      registered.push(canonicalId);
+      continue;
+    }
     insertMilestone({
       id: milestone.id,
       title: milestone.title,
@@ -326,11 +382,21 @@ export async function executeSummarySave(
     } else if (params.artifact_type === "REQUIREMENTS-DRAFT") {
       relativePath = "REQUIREMENTS-DRAFT.md";
     } else if (params.task_id && params.slice_id) {
-      relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/tasks/${params.task_id}-${params.artifact_type}.md`;
+      // Layout-aware path for task-scoped artifacts.
+      // Flat-phase: <phaseDir>/TID-TYPE.md  Legacy: milestones/MID/slices/SID/tasks/TID-TYPE.md
+      // relSlicePath returns ".gsd/phases/NN-slug" (flat) or ".gsd/milestones/MID/slices/SID" (legacy).
+      const sRel = relSlicePath(basePath, params.milestone_id!, params.slice_id).replace(/^\.gsd\//, "");
+      relativePath = sRel.startsWith("milestones/")
+        ? `${sRel}/tasks/${params.task_id}-${params.artifact_type}.md`
+        : `${sRel}/${params.task_id}-${params.artifact_type}.md`;
     } else if (params.slice_id) {
-      relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/${params.slice_id}-${params.artifact_type}.md`;
+      // Layout-aware path for slice-scoped artifacts.
+      // relSliceFile returns ".gsd/..." prefix — strip it to get the DB-relative path.
+      relativePath = relSliceFile(basePath, params.milestone_id!, params.slice_id, params.artifact_type).replace(/^\.gsd\//, "");
     } else {
-      relativePath = `milestones/${params.milestone_id}/${params.milestone_id}-${params.artifact_type}.md`;
+      // Layout-aware path for milestone-scoped artifacts.
+      // relMilestoneFile returns ".gsd/..." prefix — strip it to get the DB-relative path.
+      relativePath = relMilestoneFile(basePath, params.milestone_id!, params.artifact_type).replace(/^\.gsd\//, "");
     }
 
     const activeRequirements = params.artifact_type === "REQUIREMENTS"
@@ -1244,7 +1310,48 @@ export async function executePlanMilestone(
     isError: true,
       };
   }
+  let workerId: string | null = null;
+  let acquiredToken: number | null = null;
+  let leaseRefreshTimer: ReturnType<typeof setInterval> | undefined;
   try {
+    // Re-read at the gate so a peer-created milestone is not treated as fresh.
+    const milestoneExists = getMilestone(params.milestoneId) !== null;
+    if (milestoneExists) {
+      const heldLease = getMilestoneLease(params.milestoneId);
+      if (heldLease?.status === "held" && Date.parse(heldLease.expires_at) > Date.now()) {
+        const holder = getAutoWorker(heldLease.worker_id);
+        // Let the one-shot claim path recover stale same-process worker rows.
+        const projectRoot = normalizeRealPath(basePath);
+        const isOurAutoLease = isAutoActive() && heldLease.worker_id === autoSession.workerId;
+        const holderIsOneShotReentrantPeer = !isAutoActive()
+          && !!holder
+          && holder.host === hostname()
+          && holder.pid === process.pid
+          && holder.project_root_realpath === projectRoot;
+        if (holder?.status === "active" && !isOurAutoLease && !holderIsOneShotReentrantPeer) {
+          return milestoneLeaseConflictResult(params.milestoneId, heldLease.worker_id, heldLease.expires_at);
+        }
+      }
+    }
+
+    // Fresh creation cannot claim a lease because the FK row does not exist.
+    // In-process auto already owns its lease; re-claiming would bump its token.
+    if (!isAutoActive() && milestoneExists) {
+      workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(basePath) });
+      const lease = claimMilestoneLease(workerId, params.milestoneId);
+      if (!lease.ok) {
+        return milestoneLeaseConflictResult(params.milestoneId, lease.byWorker, lease.expiresAt);
+      }
+      acquiredToken = lease.token;
+
+      const leaseRefreshMs = (milestoneLeaseTtlSeconds() / 2) * 1000;
+      leaseRefreshTimer = setInterval(() => {
+        if (acquiredToken !== null && workerId !== null) {
+          refreshMilestoneLease(workerId, params.milestoneId, acquiredToken);
+        }
+      }, leaseRefreshMs);
+    }
+
     const result = await handlePlanMilestone(params, basePath);
     if ("error" in result) {
       return {
@@ -1270,6 +1377,17 @@ export async function executePlanMilestone(
     isError: true,
       };
   }
+  finally {
+    if (leaseRefreshTimer !== undefined) {
+      clearInterval(leaseRefreshTimer);
+    }
+    if (workerId !== null && acquiredToken !== null) {
+      releaseMilestoneLease(workerId, params.milestoneId, acquiredToken);
+    }
+    if (workerId !== null) {
+      markWorkerStopping(workerId);
+    }
+  }
 }
 
 export async function executePlanSlice(

package/src/resources/extensions/gsd/triage-resolution.ts

@@ -14,7 +14,7 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { createRequire } from "node:module";
-import { gsdRoot, milestonesDir } from "./paths.js";
+import { gsdRoot, milestonesDir, legacyMilestonesDir, resolveMilestonePath } from "./paths.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import type { Classification, CaptureEntry } from "./captures.js";
 import {
@@ -185,8 +185,9 @@ export function executeBacktrack(
     // so deriveState() will re-enter it as the active milestone.
     if (targetMilestoneId) {
       try {
-        const targetDir = join(milestonesDir(basePath), targetMilestoneId);
-        if (existsSync(targetDir)) {
+        // Use resolveMilestonePath to locate the dir in either legacy or flat-phase layout.
+        const targetDir = resolveMilestonePath(basePath, targetMilestoneId);
+        if (targetDir && existsSync(targetDir)) {
           // Write a regression marker so the state machine knows this milestone
           // needs re-discussion, not just re-execution
           const regressionPath = join(targetDir, `${targetMilestoneId}-REGRESSION.md`);
@@ -334,8 +335,13 @@ export function ensureDeferMilestoneDir(
 ): boolean {
   if (!MILESTONE_ID_RE.test(targetMilestone)) return false;
 
-  const msDir = join(milestonesDir(basePath), targetMilestone);
-  if (existsSync(msDir)) return true;
+  // Check if the milestone dir already exists in either layout.
+  const existingDir = resolveMilestonePath(basePath, targetMilestone);
+  if (existingDir && existsSync(existingDir)) return true;
+  // Create new dir in the layout-appropriate location.
+  const legacyBase = legacyMilestonesDir(basePath);
+  const msBase = existsSync(legacyBase) ? legacyBase : milestonesDir(basePath);
+  const msDir = join(msBase, targetMilestone);
 
   try {
     mkdirSync(msDir, { recursive: true });
@@ -495,8 +501,9 @@ export function executeTriageResolutions(
       }
     }
     for (const [milestoneId, captures] of byMilestone) {
-      const msDir = join(milestonesDir(basePath), milestoneId);
-      if (!existsSync(msDir)) {
+      // Use resolveMilestonePath to check existence in either layout.
+      const existingMs = resolveMilestonePath(basePath, milestoneId);
+      if (!existingMs || !existsSync(existingMs)) {
         const created = ensureDeferMilestoneDir(basePath, milestoneId, captures);
         if (created) {
           result.deferredMilestones++;

package/src/resources/extensions/gsd/tui/render-kit.ts

@@ -1,7 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Shared terminal rendering helpers for GSD extension TUI surfaces.
 
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+import { style, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
 
 export interface ThemeLike {
   fg(color: string, text: string): string;
@@ -107,21 +107,64 @@ export function renderPanel(
   }
 
   const ruleColor = options.ruleColor ?? "borderAccent";
-  const indent = Math.max(0, options.indent ?? 2);
-  const rule = (text: string) => theme.fg(ruleColor, text);
+  const paddingX = Math.max(0, options.indent ?? 0);
+  const surface = style()
+    .border("open")
+    .title(title, (text) => theme.fg(ruleColor, text))
+    .borderColor((text) => theme.fg(ruleColor, text))
+    .paddingX(paddingX)
+    .bottomRule(true);
 
-  // Header rule: "── <title> ───────"
-  const lead = "── ";
-  const headerUsed = visibleWidth(lead) + visibleWidth(title) + 1;
-  const headerFill = Math.max(0, width - headerUsed);
-  const header = safeLine(rule(lead) + title + " " + rule("─".repeat(headerFill)), width, "");
+  const body = inner.length > 0 ? inner : [""];
+  return surface.render(body, width);
+}
+
+export interface PlainOutcomeLayoutOptions {
+  /** Right side of the header row (e.g. elapsed time). */
+  headerRight?: string;
+  /** Full-width body rows with an optional right column. */
+  splitRows?: Array<{ left: string; right?: string }>;
+  /** Footer hints pinned to the bottom-right (e.g. slash commands). */
+  footerRight?: string;
+}
+
+/**
+ * Plain transcript outcome — matches the GSD chat/tool speaker line (no rule box).
+ * Header: `GSD · <status>` with optional right meta; body copy-clean; optional footer right.
+ */
+export function renderPlainOutcome(
+  theme: ThemeLike,
+  width: number,
+  statusLine: string,
+  bodyLines: string[],
+  options?: PlainOutcomeLayoutOptions,
+): string[] {
+  const headerLeft =
+    theme.fg("accent", theme.bold("GSD")) + theme.fg("dim", " · ") + statusLine;
+  const header = options?.headerRight
+    ? rightAlign(headerLeft, options.headerRight, width)
+    : safeLine(headerLeft, width);
+
+  const out: string[] = [header];
+
+  if (options?.splitRows && options.splitRows.length > 0) {
+    for (const row of options.splitRows) {
+      out.push(row.right ? rightAlign(row.left, row.right, width) : safeLine(row.left, width));
+    }
+  } else {
+    for (const line of bodyLines.filter(Boolean)) {
+      out.push(safeLine(line, width));
+    }
+  }
 
-  // Body lines, indented so no chrome sits on copyable text.
-  const pad = " ".repeat(indent);
-  const contentWidth = Math.max(0, width - indent);
-  const body = inner.map((line) => safeLine(pad + safeLine(line, contentWidth), width, ""));
+  if (options?.footerRight) {
+    out.push(rightAlign("", options.footerRight, width));
+  }
 
-  return [header, "", ...body, rule("─".repeat(width))];
+  if (out.length === 1 && !options?.footerRight) {
+    return [header, ""];
+  }
+  return [...out, ""];
 }
 
 export function renderFrame(

package/src/resources/extensions/gsd/uat-policy.ts

@@ -1,9 +1,11 @@
 // Project/App: gsd-pi
 // File Purpose: Central UAT mode policy for dispatch, tool presentation, and result validation.
 
-import { extractUatType } from "./files.js";
+import { hasBrowserContractPrefix } from "../shared/browser-contract.js";
+import { extractUatType, UAT_TYPE_KEYWORDS } from "./files.js";
 import type { UatType } from "./files.js";
 import { hasBrowserRequiredText } from "./browser-evidence.js";
+import { parseMcpToolName } from "./mcp-tool-name.js";
 
 export type { UatType } from "./files.js";
 
@@ -26,19 +28,14 @@ export interface UatModePolicy {
 
 export interface UatContentPolicy {
   declaredType: UatType;
+  /** False when no parseable `UAT mode:` declaration exists and declaredType defaulted to artifact-driven. */
+  modeDeclared: boolean;
   effectiveType: UatType;
   browserRequired: boolean;
   shouldDispatchByDefault: boolean;
 }
 
-export const UAT_TYPES: readonly UatType[] = [
-  "artifact-driven",
-  "browser-executable",
-  "runtime-executable",
-  "live-runtime",
-  "mixed",
-  "human-experience",
-] as const;
+export const UAT_TYPES: readonly UatType[] = UAT_TYPE_KEYWORDS;
 
 export const UAT_MODE_POLICIES: Readonly<Record<UatType, UatModePolicy>> = {
   "artifact-driven": {
@@ -87,26 +84,76 @@ export function getDeclaredUatType(content: string): UatType {
   return extractUatType(content) ?? "artifact-driven";
 }
 
-export function classifyUatContent(content: string): UatContentPolicy {
-  const declaredType = getDeclaredUatType(content);
-  const browserRequired = hasBrowserRequiredText(content);
-  const effectiveType = declaredType === "artifact-driven" && browserRequired
+/** Self-contained browser UAT harnesses that manage server lifecycle internally. */
+const SELF_CONTAINED_RUNTIME_UAT_COMMAND_RE =
+  /\b(?:npm run test:uat|node\s+(?:--check\s+\S+\s+&&\s+)*tests\/browser\/search-uat\.mjs|npx playwright test(?:\s+\S+)?)\b/i;
+
+export function hasSelfContainedRuntimeUatCommand(content: string): boolean {
+  return SELF_CONTAINED_RUNTIME_UAT_COMMAND_RE.test(content);
+}
+
+function resolveEffectiveUatTypeFromPolicy(
+  declaredType: UatType,
+  browserRequired: boolean,
+  content: string,
+): UatType {
+  let effectiveType = declaredType === "artifact-driven" && browserRequired
     ? "browser-executable"
     : declaredType;
 
+  // M006/S01 regression: specs often declare browser-executable with localhost
+  // preconditions while the Evidence section names a runtime harness such as
+  // `npm run test:uat`. Interactive browser_* checks then race a fixed port
+  // against the script's own ephemeral server — run the harness instead.
+  if (
+    effectiveType === "browser-executable" &&
+    hasSelfContainedRuntimeUatCommand(content)
+  ) {
+    effectiveType = "runtime-executable";
+  }
+
+  return effectiveType;
+}
+
+export function classifyUatContent(content: string): UatContentPolicy {
+  return classifyUatContentForRun(content);
+}
+
+/**
+ * Classify UAT mode for run-uat dispatch. Supplemental context (slice summary,
+ * verification excerpts) can name a self-contained harness even when the UAT
+ * file only documents a separate server command such as `npm run test:server`.
+ */
+export function classifyUatContentForRun(content: string, supplementalContext = ""): UatContentPolicy {
+  const parsedType = extractUatType(content);
+  const declaredType = parsedType ?? "artifact-driven";
+  const browserRequired = hasBrowserRequiredText(content);
+  const combinedForHarness = supplementalContext.trim()
+    ? `${content}\n\n${supplementalContext}`
+    : content;
+  const effectiveType = resolveEffectiveUatTypeFromPolicy(
+    declaredType,
+    browserRequired,
+    combinedForHarness,
+  );
+
   return {
     declaredType,
+    modeDeclared: parsedType !== undefined,
     effectiveType,
     browserRequired,
     shouldDispatchByDefault: effectiveType !== "artifact-driven" || browserRequired,
   };
 }
 
-export function shouldEscalateArtifactUatToBrowser(content: string): boolean {
-  const policy = classifyUatContent(content);
+export function escalatesArtifactUatToBrowser(policy: UatContentPolicy): boolean {
   return policy.declaredType === "artifact-driven" && policy.browserRequired;
 }
 
+export function shouldEscalateArtifactUatToBrowser(content: string): boolean {
+  return escalatesArtifactUatToBrowser(classifyUatContent(content));
+}
+
 export function resolveEffectiveUatType(content: string): UatType {
   return classifyUatContent(content).effectiveType;
 }
@@ -122,31 +169,39 @@ export function uatTypeIncludesBrowser(uatType: string | undefined): boolean {
   return isUatType(uatType) && UAT_MODE_POLICIES[uatType].browserTools;
 }
 
-function canonicalPresentedToolName(toolName: string): string {
-  if (!toolName.startsWith("mcp__")) return toolName;
-  const toolSeparator = toolName.indexOf("__", "mcp__".length);
-  return toolSeparator >= 0 ? toolName.slice(toolSeparator + 2) : toolName;
-}
-
 export function isUatBrowserToolName(toolName: string): boolean {
-  return canonicalPresentedToolName(toolName).startsWith("browser_");
+  const parsed = parseMcpToolName(toolName);
+  const canonicalName = parsed?.toolName ?? toolName;
+  if (hasBrowserContractPrefix(canonicalName)) return true;
+  return parsed?.toolName === "*" && parsed.serverName.toLowerCase().includes("browser");
 }
 
 export function hasUatBrowserToolSurface(activeTools: readonly string[] | undefined): boolean {
   return Array.isArray(activeTools) && activeTools.some(isUatBrowserToolName);
 }
 
+export function resolveUatBrowserToolSurface(options: {
+  activeTools: readonly string[] | undefined;
+  registeredTools?: readonly string[] | undefined;
+}): readonly string[] | undefined {
+  const surfaces = [options.activeTools, options.registeredTools].filter(Array.isArray);
+  if (surfaces.length === 0) return undefined;
+  return [...new Set(surfaces.flat())];
+}
+
 export function getUatBrowserToolSupportError(options: {
   uatType: UatType;
   activeTools: readonly string[] | undefined;
+  registeredTools?: readonly string[] | undefined;
   milestoneId: string;
   sliceId: string;
 }): string | null {
   if (!uatTypeIncludesBrowser(options.uatType)) return null;
-  if (!Array.isArray(options.activeTools)) return null;
-  if (hasUatBrowserToolSurface(options.activeTools)) return null;
+  const toolSurface = resolveUatBrowserToolSurface(options);
+  if (!toolSurface) return null;
+  if (hasUatBrowserToolSurface(toolSurface)) return null;
 
-  return `Cannot dispatch browser-backed run-uat for ${options.milestoneId}/${options.sliceId}: UAT mode "${options.uatType}" requires browser tools, but the active tool surface has none. Enable browser tools or change the UAT to a runtime-executable Playwright command, then rerun /gsd auto.`;
+  return `Cannot dispatch browser-backed run-uat for ${options.milestoneId}/${options.sliceId}: UAT mode "${options.uatType}" requires browser tools, but the run-uat tool surface has none. Enable browser tools or change the UAT to a runtime-executable Playwright command, then rerun /gsd auto.`;
 }
 
 export function isPartialEligibleUatType(uatType: UatType | undefined): boolean {

package/src/resources/extensions/gsd/uat-run.ts

@@ -103,7 +103,7 @@ function mergeBlockedTools(
 ): UatPresentationInput["blockedTools"] {
   const merged = new Map<string, { name: string; reason: string }>();
   for (const entry of [...(current ?? []), ...canonical]) {
-    merged.set(canonicalWorkflowToolName(parseMcpToolName(entry.name)?.tool ?? entry.name), entry);
+    merged.set(canonicalWorkflowToolName(parseMcpToolName(entry.name)?.toolName ?? entry.name), entry);
   }
   return [...merged.values()];
 }
@@ -299,22 +299,18 @@ function quoteToolNames(toolNames: readonly string[]): string {
 }
 
 function validateCanonicalPresentation(params: UatResultSaveParams): string | null {
-  const aliasHints: Record<string, string> = {
-    gsd_save_summary: "gsd_summary_save",
-    gsd_complete_task: "gsd_task_complete",
-    gsd_complete_slice: "gsd_slice_complete",
-    gsd_milestone_complete: "gsd_complete_milestone",
-  };
   const errors: string[] = [];
   for (const toolName of params.presentation.presentedTools) {
-    const baseName = parseMcpToolName(toolName)?.tool ?? toolName;
-    const canonical = aliasHints[baseName];
-    if (canonical) errors.push(`presentation tool "${toolName}" uses an alias; use canonical "${canonical}"`);
+    const baseName = parseMcpToolName(toolName)?.toolName ?? toolName;
+    const canonical = canonicalWorkflowToolName(baseName);
+    if (canonical !== baseName) {
+      errors.push(`presentation tool "${toolName}" uses an alias; use canonical "${canonical}"`);
+    }
   }
 
   const presentedCanonical = new Set(
     params.presentation.presentedTools.map((toolName) =>
-      canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName)
+      canonicalWorkflowToolName(parseMcpToolName(toolName)?.toolName ?? toolName)
     ),
   );
   const missingRequiredTools = RUN_UAT_WORKFLOW_TOOL_NAMES.filter(
@@ -329,11 +325,11 @@ function validateCanonicalPresentation(params: UatResultSaveParams): string | nu
   const forbiddenCanonical = new Set(
     RUN_UAT_FORBIDDEN_TOOL_NAMES
       .filter((toolName) => !toolName.includes("*"))
-      .map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName)),
+      .map((toolName) => canonicalWorkflowToolName(parseMcpToolName(toolName)?.toolName ?? toolName)),
   );
   const forbiddenPresentedTools: string[] = [];
   for (const toolName of params.presentation.presentedTools) {
-    const canonical = canonicalWorkflowToolName(parseMcpToolName(toolName)?.tool ?? toolName);
+    const canonical = canonicalWorkflowToolName(parseMcpToolName(toolName)?.toolName ?? toolName);
     if (toolName === "mcp__gsd-workflow__*" || forbiddenCanonical.has(canonical)) {
       forbiddenPresentedTools.push(toolName);
     }
@@ -346,7 +342,7 @@ function validateCanonicalPresentation(params: UatResultSaveParams): string | nu
 
   const blockedCanonical = new Set(
     params.presentation.blockedTools.map((entry) =>
-      canonicalWorkflowToolName(parseMcpToolName(entry.name)?.tool ?? entry.name)
+      canonicalWorkflowToolName(parseMcpToolName(entry.name)?.toolName ?? entry.name)
     ),
   );
   const missingBlockedTools = ["gsd_exec", "gsd_summary_save", "gsd_save_gate_result"].filter(

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

@@ -11,9 +11,9 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { parseUnitId } from "./unit-id.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
-import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
+import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveSliceFile, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
 import { sendDesktopNotification } from "./notifications.js";
-import { getTask, getSlice, getSliceTasks, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
+import { getTask, getSlice, getSliceTasks, updateTaskStatus, resetSliceCascade } from "./gsd-db.js";
 import { renderPlanCheckboxes, renderRoadmapCheckboxes } from "./markdown-renderer.js";
 
 /**
@@ -330,12 +330,16 @@ export async function handleResetSlice(
     return;
   }
 
-  // Reset all tasks
-  let tasksReset = 0;
+  // Reset all task statuses to "pending" and the slice to "active" in one
+  // atomic commit (DB is source of truth). Previously a per-task updateTaskStatus
+  // loop + a separate updateSliceStatus, which could leave a partial reset if
+  // interrupted mid-loop.
+  resetSliceCascade(mid, sid);
+
+  // Delete task summary files — projection cleanup, separate from the DB reset.
+  const tasksReset = tasks.length;
   let summariesDeleted = 0;
   for (const t of tasks) {
-    updateTaskStatus(mid, sid, t.id, "pending");
-    tasksReset++;
     const summaryPath = resolveTaskFile(basePath, mid, sid, t.id, "SUMMARY");
     if (summaryPath && existsSync(summaryPath)) {
       unlinkSync(summaryPath);
@@ -343,19 +347,15 @@ export async function handleResetSlice(
     }
   }
 
-  // Reset slice status
-  updateSliceStatus(mid, sid, "active");
-
   // Delete slice summary and UAT files
+  // Use resolveSliceFile so the legacy S01-SUMMARY.md filename is found even
+  // when buildSliceFileName now returns the flat-phase 01-SUMMARY.md format.
   let sliceFilesDeleted = 0;
-  const slicePath = resolveSlicePath(basePath, mid, sid);
-  if (slicePath) {
-    for (const suffix of ["SUMMARY", "UAT"]) {
-      const filePath = join(slicePath, buildSliceFileName(sid, suffix));
-      if (existsSync(filePath)) {
-        unlinkSync(filePath);
-        sliceFilesDeleted++;
-      }
+  for (const suffix of ["SUMMARY", "UAT"] as const) {
+    const filePath = resolveSliceFile(basePath, mid, sid, suffix);
+    if (filePath && existsSync(filePath)) {
+      unlinkSync(filePath);
+      sliceFilesDeleted++;
     }
   }