gsd-pi 2.7.1 → 2.8.1

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

@@ -68,6 +68,7 @@ import {
   mergeSliceToMain,
 } from "./worktree.ts";
 import { GitServiceImpl } from "./git-service.ts";
+import { getPriorSliceCompletionBlocker } from "./dispatch-guard.ts";
 import type { GitPreferences } from "./git-service.ts";
 import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import { makeUI, GLYPH, INDENT } from "../shared/ui.js";
@@ -1254,7 +1255,14 @@ async function dispatchNextUnit(
     }
   }
 
-  await emitObservabilityWarnings(ctx, unitType, unitId);
+  const priorSliceBlocker = getPriorSliceCompletionBlocker(basePath, getMainBranch(basePath), unitType, unitId);
+  if (priorSliceBlocker) {
+    await stopAuto(ctx, pi);
+    ctx.ui.notify(priorSliceBlocker, "error");
+    return;
+  }
+
+  const observabilityIssues = await collectObservabilityWarnings(ctx, unitType, unitId);
 
   // Idempotency: skip units already completed in a prior session.
   const idempotencyKey = `${unitType}/${unitId}`;
@@ -1394,6 +1402,13 @@ async function dispatchNextUnit(
     }
   }
 
+  // Inject observability repair instructions so the agent fixes gaps before
+  // proceeding with the unit (see #174).
+  const repairBlock = buildObservabilityRepairBlock(observabilityIssues);
+  if (repairBlock) {
+    finalPrompt = `${finalPrompt}${repairBlock}`;
+  }
+
   // Switch model if preferences specify one for this unit type
   // Try primary model, then fallbacks in order if setting fails
   const modelConfig = resolveModelWithFallbacksForUnit(unitType);
@@ -2357,17 +2372,17 @@ function ensurePreconditions(
 
 // ─── Diagnostics ──────────────────────────────────────────────────────────────
 
-async function emitObservabilityWarnings(
+async function collectObservabilityWarnings(
   ctx: ExtensionContext,
   unitType: string,
   unitId: string,
-): Promise<void> {
+): Promise<import("./observability-validator.ts").ValidationIssue[]> {
   const parts = unitId.split("/");
   const mid = parts[0];
   const sid = parts[1];
   const tid = parts[2];
 
-  if (!mid || !sid) return;
+  if (!mid || !sid) return [];
 
   let issues = [] as Awaited<ReturnType<typeof validatePlanBoundary>>;
 
@@ -2379,12 +2394,38 @@ async function emitObservabilityWarnings(
     issues = await validateCompleteBoundary(basePath, mid, sid);
   }
 
-  if (issues.length === 0) return;
+  if (issues.length > 0) {
+    ctx.ui.notify(
+      `Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`,
+      "warning",
+    );
+  }
+
+  return issues;
+}
 
-  ctx.ui.notify(
-    `Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`,
-    "warning",
-  );
+function buildObservabilityRepairBlock(issues: import("./observability-validator.ts").ValidationIssue[]): string {
+  if (issues.length === 0) return "";
+  const items = issues.map(issue => {
+    const fileName = issue.file.split("/").pop() || issue.file;
+    let line = `- **${fileName}**: ${issue.message}`;
+    if (issue.suggestion) line += ` → ${issue.suggestion}`;
+    return line;
+  });
+  return [
+    "",
+    "---",
+    "",
+    "## Pre-flight: Observability gaps to fix FIRST",
+    "",
+    "The following issues were detected in plan/summary files for this unit.",
+    "**Read each flagged file, apply the fix described, then proceed with the unit.**",
+    "",
+    ...items,
+    "",
+    "---",
+    "",
+  ].join("\n");
 }
 
 async function recoverTimedOutUnit(
@@ -2736,14 +2777,34 @@ export function resolveExpectedArtifactPath(unitType: string, unitId: string, ba
 }
 
 /**
- * Check whether the expected artifact for a unit exists on disk.
- * Returns true if the artifact file exists, or if the unit type has no
+ * Check whether the expected artifact(s) for a unit exist on disk.
+ * Returns true if all required artifacts exist, or if the unit type has no
  * single verifiable artifact (e.g., replan-slice).
+ *
+ * complete-slice requires both SUMMARY and UAT files — verifying only
+ * the summary allowed the unit to be marked complete when the LLM
+ * skipped writing the UAT file (see #176).
  */
 function verifyExpectedArtifact(unitType: string, unitId: string, base: string): boolean {
   const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
   if (!absPath) return true;
-  return existsSync(absPath);
+  if (!existsSync(absPath)) return false;
+
+  // complete-slice must also produce a UAT file
+  if (unitType === "complete-slice") {
+    const parts = unitId.split("/");
+    const mid = parts[0];
+    const sid = parts[1];
+    if (mid && sid) {
+      const dir = resolveSlicePath(base, mid, sid);
+      if (dir) {
+        const uatPath = join(dir, buildSliceFileName(sid, "UAT"));
+        if (!existsSync(uatPath)) return false;
+      }
+    }
+  }
+
+  return true;
 }
 
 /**
@@ -2787,7 +2848,7 @@ function diagnoseExpectedArtifact(unitType: string, unitId: string, base: string
       return `Task ${tid} marked [x] in ${relSliceFile(base, mid!, sid!, "PLAN")} + summary written`;
     }
     case "complete-slice":
-      return `Slice ${sid} marked [x] in ${relMilestoneFile(base, mid!, "ROADMAP")} + summary written`;
+      return `Slice ${sid} marked [x] in ${relMilestoneFile(base, mid!, "ROADMAP")} + summary + UAT written`;
     case "replan-slice":
       return `${relSliceFile(base, mid!, sid!, "REPLAN")} + updated ${relSliceFile(base, mid!, sid!, "PLAN")}`;
     case "reassess-roadmap":

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

@@ -0,0 +1,65 @@
+import { execSync } from "node:child_process";
+import { relMilestoneFile } from "./paths.js";
+import { parseRoadmapSlices } from "./roadmap-slices.ts";
+
+const SLICE_DISPATCH_TYPES = new Set([
+  "research-slice",
+  "plan-slice",
+  "replan-slice",
+  "execute-task",
+  "complete-slice",
+]);
+
+function readTrackedFileFromBranch(base: string, branch: string, relPath: string): string | null {
+  try {
+    return execSync(`git show ${branch}:${relPath}`, {
+      cwd: base,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function milestoneIdFromNumber(num: number): string {
+  return `M${String(num).padStart(3, "0")}`;
+}
+
+export function getPriorSliceCompletionBlocker(base: string, mainBranch: string, unitType: string, unitId: string): string | null {
+  if (!SLICE_DISPATCH_TYPES.has(unitType)) return null;
+
+  const [targetMid, targetSid] = unitId.split("/");
+  if (!targetMid || !targetSid) return null;
+
+  const targetMidNumber = Number.parseInt(targetMid.slice(1), 10);
+  if (!Number.isFinite(targetMidNumber)) return null;
+
+  for (let milestoneNumber = 1; milestoneNumber <= targetMidNumber; milestoneNumber += 1) {
+    const mid = milestoneIdFromNumber(milestoneNumber);
+    const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
+    if (!roadmapRel) continue;
+
+    const roadmapContent = readTrackedFileFromBranch(base, mainBranch, roadmapRel);
+    if (!roadmapContent) continue;
+
+    const slices = parseRoadmapSlices(roadmapContent);
+    if (mid !== targetMid) {
+      const incomplete = slices.find(slice => !slice.done);
+      if (incomplete) {
+        return `Cannot dispatch ${unitType} ${unitId}: earlier slice ${mid}/${incomplete.id} is not complete on ${mainBranch}.`;
+      }
+      continue;
+    }
+
+    const targetIndex = slices.findIndex(slice => slice.id === targetSid);
+    if (targetIndex === -1) return null;
+
+    const incomplete = slices.slice(0, targetIndex).find(slice => !slice.done);
+    if (incomplete) {
+      return `Cannot dispatch ${unitType} ${unitId}: earlier slice ${targetMid}/${incomplete.id} is not complete on ${mainBranch}.`;
+    }
+  }
+
+  return null;
+}

package/src/resources/extensions/gsd/exit-command.ts

@@ -0,0 +1,18 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+type StopAutoFn = (ctx: ExtensionCommandContext, pi: ExtensionAPI) => Promise<void>;
+
+export function registerExitCommand(
+  pi: ExtensionAPI,
+  deps: { stopAuto?: StopAutoFn } = {},
+): void {
+  pi.registerCommand("exit", {
+    description: "Exit GSD gracefully",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      // Stop auto-mode first so locks and activity state are cleaned up before shutdown.
+      const stopAuto = deps.stopAuto ?? (await import("./auto.js")).stopAuto;
+      await stopAuto(ctx, pi);
+      ctx.shutdown();
+    },
+  });
+}

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

@@ -1,14 +1,14 @@
-// GSD Extension — File Parsing and I/O
+// GSD Extension - File Parsing and I/O
 // Parsers for roadmap, plan, summary, and continue files.
 // Used by state derivation and the status widget.
-// Pure functions, zero Pi dependencies — uses only Node built-ins.
+// Pure functions, zero Pi dependencies - uses only Node built-ins.
 
 import { promises as fs, readdirSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { milestonesDir, resolveMilestoneFile, relMilestoneFile } from './paths.js';
 
 import type {
-  Roadmap, RoadmapSliceEntry, BoundaryMapEntry, RiskLevel,
+  Roadmap, BoundaryMapEntry,
   SlicePlan, TaskPlanEntry,
   Summary, SummaryFrontmatter, SummaryRequires, FileModified,
   Continue, ContinueFrontmatter, ContinueStatus,
@@ -18,6 +18,7 @@ import type {
 } from './types.ts';
 
 import { checkExistingEnvKeys } from '../get-secrets-from-user.ts';
+import { parseRoadmapSlices } from './roadmap-slices.ts';
 
 // ─── Helpers ───────────────────────────────────────────────────────────────
 
@@ -199,40 +200,8 @@ export function parseRoadmap(content: string): Roadmap {
     })();
   const successCriteria = scSection ? parseBullets(scSection) : [];
 
-  // Slices
-  const slicesSection = extractSection(content, 'Slices');
-  const slices: RoadmapSliceEntry[] = [];
-
-  if (slicesSection) {
-    const checkboxItems = slicesSection.split('\n');
-    let currentSlice: RoadmapSliceEntry | null = null;
-
-    for (const line of checkboxItems) {
-      const cbMatch = line.match(/^-\s+\[([ xX])\]\s+\*\*(\w+):\s+(.+?)\*\*\s*(.*)/);
-      if (cbMatch) {
-        if (currentSlice) slices.push(currentSlice);
-
-        const done = cbMatch[1].toLowerCase() === 'x';
-        const id = cbMatch[2];
-        const sliceTitle = cbMatch[3];
-        const rest = cbMatch[4];
-
-        const riskMatch = rest.match(/`risk:(\w+)`/);
-        const risk = (riskMatch ? riskMatch[1] : 'low') as RiskLevel;
-
-        const depsMatch = rest.match(/`depends:\[([^\]]*)\]`/);
-        const depends = depsMatch && depsMatch[1].trim()
-          ? depsMatch[1].split(',').map(s => s.trim())
-          : [];
-
-        currentSlice = { id, title: sliceTitle, risk, depends, done, demo: '' };
-      } else if (currentSlice && line.trim().startsWith('>')) {
-        const demoText = line.trim().replace(/^>\s*/, '').replace(/^After this:\s*/i, '');
-        currentSlice.demo = demoText;
-      }
-    }
-    if (currentSlice) slices.push(currentSlice);
-  }
+  // Slices  
+  const slices = parseRoadmapSlices(content);
 
   // Boundary map
   const boundaryMap: BoundaryMapEntry[] = [];
@@ -657,7 +626,7 @@ export function parseTaskPlanMustHaves(content: string): Array<{ text: string; c
         checked: cbMatch[1].toLowerCase() === 'x',
       };
     }
-    // No checkbox — treat as unchecked with full line as text
+    // No checkbox - treat as unchecked with full line as text
     return { text: line.trim(), checked: false };
   });
 }
@@ -732,7 +701,7 @@ export type UatType = 'artifact-driven' | 'live-runtime' | 'human-experience' |
 /**
  * Extract the UAT type from a UAT file's raw content.
  *
- * UAT files have no YAML frontmatter — pass raw file content directly.
+ * UAT files have no YAML frontmatter - pass raw file content directly.
  * Classification is leading-keyword-only: e.g. `mixed (artifact-driven + live-runtime)` → `'mixed'`.
  *
  * Returns `undefined` when:
@@ -811,7 +780,7 @@ export async function inlinePriorMilestoneSummary(mid: string, base: string): Pr
  * with the current environment (.env + process.env).
  *
  * Returns `null` when no manifest file exists (path resolution failure or
- * file not on disk) — callers can distinguish "no manifest" from "empty manifest".
+ * file not on disk) - callers can distinguish "no manifest" from "empty manifest".
  */
 export async function getManifestStatus(
   base: string, milestoneId: string,

package/src/resources/extensions/gsd/git-service.ts

@@ -27,6 +27,7 @@ export interface GitPreferences {
   pre_merge_check?: boolean | string;
   commit_type?: string;
   main_branch?: string;
+  merge_strategy?: "squash" | "merge";
 }
 
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
@@ -55,7 +56,7 @@ export interface PreMergeCheckResult {
  * GSD runtime paths that should be excluded from smart staging.
  * These are transient/generated artifacts that should never be committed.
  * Matches the union of SKIP_PATHS + SKIP_EXACT in worktree-manager.ts
- * and the first 6 entries in gitignore.ts BASELINE_PATTERNS.
+ * and the first 7 entries in gitignore.ts BASELINE_PATTERNS.
  */
 export const RUNTIME_EXCLUSION_PATHS: readonly string[] = [
   ".gsd/activity/",
@@ -63,6 +64,7 @@ export const RUNTIME_EXCLUSION_PATHS: readonly string[] = [
   ".gsd/worktrees/",
   ".gsd/auto.lock",
   ".gsd/metrics.json",
+  ".gsd/completed-units.json",
   ".gsd/STATE.md",
 ];
 
@@ -130,16 +132,42 @@ export class GitServiceImpl {
    */
   private smartStage(extraExclusions: readonly string[] = []): void {
     const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
-    const excludes = allExclusions.map(p => `':(exclude)${p}'`);
-    const args = ["add", "-A", "--", ".", ...excludes];
-    try {
-      this.git(args);
-    } catch {
-      console.error("GitService: smart staging failed, falling back to git add -A");
-      this.git(["add", "-A"]);
+
+    // One-time cleanup: if runtime files are already tracked in the index
+    // (from older versions where the fallback bug staged them), untrack them
+    // in a dedicated commit. This must happen as a separate commit because
+    // the git reset HEAD step below would otherwise undo the rm --cached.
+    if (!this._runtimeFilesCleanedUp) {
+      let cleaned = false;
+      for (const exclusion of RUNTIME_EXCLUSION_PATHS) {
+        const result = this.git(["rm", "--cached", "-r", "--ignore-unmatch", exclusion], { allowFailure: true });
+        if (result && result.includes("rm '")) cleaned = true;
+      }
+      if (cleaned) {
+        this.git(["commit", "-F", "-"], { input: "chore: untrack .gsd/ runtime files from git index" });
+      }
+      this._runtimeFilesCleanedUp = true;
+    }
+
+    // Stage everything, then unstage excluded paths.
+    //
+    // Previous approach used pathspec excludes (:(exclude)...) with git add -A,
+    // but that fails when .gsd/ is in .gitignore — git exits non-zero before
+    // evaluating the excludes. The catch fallback ran plain `git add -A`,
+    // staging all tracked runtime files unconditionally and defeating the
+    // exclusion list entirely.
+    //
+    // git reset HEAD silently succeeds when the path isn't staged, so no
+    // error handling is needed per-path.
+    this.git(["add", "-A"]);
+    for (const exclusion of allExclusions) {
+      this.git(["reset", "HEAD", "--", exclusion], { allowFailure: true });
     }
   }
 
+  /** Tracks whether runtime file cleanup has run this session. */
+  private _runtimeFilesCleanedUp = false;
+
   /**
    * Stage files (smart staging) and commit.
    * Returns the commit message string on success, or null if nothing to commit.
@@ -312,6 +340,12 @@ export class GitServiceImpl {
     // Exclude .gsd/ to prevent merge conflicts when both branches modify planning artifacts.
     this.autoCommit("pre-switch", current, [".gsd/"]);
 
+    // Discard uncommitted .gsd/ changes so checkout doesn't fail.
+    // These are runtime files (metrics, completed-units, STATE) that were
+    // intentionally excluded from the commit above. If they remain dirty,
+    // git checkout refuses when the target branch has different versions.
+    this.git(["checkout", "--", ".gsd/"], { allowFailure: true });
+
     this.git(["checkout", branch]);
     return created;
   }
@@ -327,6 +361,9 @@ export class GitServiceImpl {
     // Exclude .gsd/ to prevent merge conflicts when both branches modify planning artifacts.
     this.autoCommit("pre-switch", current, [".gsd/"]);
 
+    // Discard uncommitted .gsd/ changes so checkout doesn't fail.
+    this.git(["checkout", "--", ".gsd/"], { allowFailure: true });
+
     this.git(["checkout", mainBranch]);
   }
 
@@ -487,25 +524,36 @@ export class GitServiceImpl {
       commitType, milestoneId, sliceId, sliceTitle, mainBranch, branch,
     );
 
-    // Squash merge — abort cleanly on conflict so the working tree is never
-    // left in a half-merged state (see: merge-bug-fix).
+    // Pull latest main before merging to avoid conflicts from remote changes
+    this.git(["pull", "--rebase", "origin", mainBranch], { allowFailure: true });
+
+    // Merge slice branch — strategy is configurable via git.merge_strategy
+    // preference. Default: "squash" (preserves existing behavior).
+    // "merge" uses --no-ff which is more resilient to conflicts from
+    // long-lived branches or frequently-changing .gsd/* artifacts.
+    const strategy = this.prefs.merge_strategy ?? "squash";
+    const mergeArgs = strategy === "merge"
+      ? ["merge", "--no-ff", "-m", message, branch]
+      : ["merge", "--squash", branch];
+
     try {
-      this.git(["merge", "--squash", branch]);
+      this.git(mergeArgs);
     } catch (mergeError) {
-      // git merge --squash exits non-zero on conflict. The working tree now
-      // has conflict markers and a dirty index. Reset to restore a clean state.
+      // Merge exits non-zero on conflict. Reset to restore a clean state.
       this.git(["reset", "--hard", "HEAD"], { allowFailure: true });
       const msg = mergeError instanceof Error ? mergeError.message : String(mergeError);
       throw new Error(
-        `Squash-merge of "${branch}" into "${mainBranch}" failed with conflicts. ` +
+        `${strategy === "merge" ? "Merge" : "Squash-merge"} of "${branch}" into "${mainBranch}" failed with conflicts. ` +
         `Working tree has been reset to a clean state. ` +
-        `Resolve manually: git checkout ${mainBranch} && git merge --squash ${branch}\n` +
+        `Resolve manually: git checkout ${mainBranch} && git merge ${strategy === "merge" ? "--no-ff" : "--squash"} ${branch}\n` +
         `Original error: ${msg}`,
       );
     }
 
-    // Commit with rich message via stdin pipe
-    this.git(["commit", "-F", "-"], { input: message });
+    // Squash merge needs a separate commit; --no-ff merge already committed
+    if (strategy === "squash") {
+      this.git(["commit", "-F", "-"], { input: message });
+    }
 
     // Delete the merged branch
     this.git(["branch", "-D", branch]);

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

@@ -20,6 +20,7 @@ const BASELINE_PATTERNS = [
   ".gsd/worktrees/",
   ".gsd/auto.lock",
   ".gsd/metrics.json",
+  ".gsd/completed-units.json",
   ".gsd/STATE.md",
 
   // ── OS junk ──

package/src/resources/extensions/gsd/guided-flow.ts

@@ -14,15 +14,16 @@ import { deriveState } from "./state.js";
 import { startAuto } from "./auto.js";
 import { readCrashLock, clearLock, formatCrashInfo } from "./crash-recovery.js";
 import {
-  gsdRoot, milestonesDir, resolveMilestoneFile,
+  gsdRoot, milestonesDir, resolveMilestoneFile, resolveMilestonePath,
   resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile,
   relMilestoneFile, relSliceFile, relSlicePath,
 } from "./paths.js";
 import { join } from "node:path";
-import { readFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
 import { execSync, execFileSync } from "node:child_process";
 import { ensureGitignore, ensurePreferences } from "./gitignore.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { showConfirm } from "../shared/confirm-ui.js";
 
 // ─── Auto-start after discuss ─────────────────────────────────────────────────
 
@@ -35,6 +36,11 @@ let pendingAutoStart: {
   step?: boolean; // preserve step mode through discuss → auto transition
 } | null = null;
 
+/** Returns the milestoneId being discussed, or null if no discussion is active */
+export function getDiscussionMilestoneId(): string | null {
+  return pendingAutoStart?.milestoneId ?? null;
+}
+
 /** Called from agent_end to check if auto-mode should start after discuss */
 export function checkAutoStartAfterDiscuss(): boolean {
   if (!pendingAutoStart) return false;
@@ -601,6 +607,16 @@ export async function showSmartEntry(
           label: "Discuss first",
           description: "Capture decisions on gray areas before planning.",
         }] : []),
+        {
+          id: "skip_milestone",
+          label: "Skip — create new milestone",
+          description: "Leave this milestone on disk and start a fresh one.",
+        },
+        {
+          id: "discard_milestone",
+          label: "Discard this milestone",
+          description: "Delete the milestone directory and start over.",
+        },
       ];
 
       const choice = await showNextAction(ctx as any, {
@@ -619,6 +635,27 @@ export async function showSmartEntry(
         dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
           milestoneId, milestoneTitle,
         }));
+      } else if (choice === "skip_milestone") {
+        const milestoneIds = findMilestoneIds(basePath);
+        const nextId = `M${String(milestoneIds.length + 1).padStart(3, "0")}`;
+        pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
+        dispatchWorkflow(pi, buildDiscussPrompt(nextId,
+          `New milestone ${nextId}.`,
+          basePath
+        ));
+      } else if (choice === "discard_milestone") {
+        const mDir = resolveMilestonePath(basePath, milestoneId);
+        if (!mDir) return;
+        const confirmed = await showConfirm(ctx as any, {
+          title: "Discard milestone?",
+          message: `This will permanently delete ${milestoneId} and all its contents.`,
+          confirmLabel: "Discard",
+          declineLabel: "Cancel",
+        });
+        if (confirmed) {
+          rmSync(mDir, { recursive: true, force: true });
+          return showSmartEntry(ctx, pi, basePath, options);
+        }
       }
     } else {
       // Roadmap exists — either blocked or ready for auto