gsd-pi 2.35.0-dev.30eec3f → 2.35.0-dev.640d5c7

package/src/resources/extensions/gsd/health-widget.ts

@@ -9,37 +9,41 @@
  */
 
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
-import type { GSDState } from "./types.js";
 import { runProviderChecks, summariseProviderIssues } from "./doctor-providers.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { loadLedgerFromDisk, getProjectTotals } from "./metrics.js";
-import { describeNextUnit, estimateTimeRemaining, updateSliceProgressCache } from "./auto-dashboard.js";
 import { projectRoot } from "./commands.js";
-import { deriveState, invalidateStateCache } from "./state.js";
-import {
-  buildHealthLines,
-  detectHealthWidgetProjectState,
-  type HealthWidgetData,
-} from "./health-widget-core.js";
+
+// ── Types ──────────────────────────────────────────────────────────────────────
+
+interface HealthWidgetData {
+  hasProject: boolean;
+  budgetCeiling: number | undefined;
+  budgetSpent: number;
+  providerIssue: string | null;      // compact summary from summariseProviderIssues()
+  environmentErrorCount: number;
+  environmentWarningCount: number;
+  lastRefreshed: number;
+}
 
 // ── Data loader ────────────────────────────────────────────────────────────────
 
-function loadBaseHealthWidgetData(basePath: string): HealthWidgetData {
+function loadHealthWidgetData(basePath: string): HealthWidgetData {
+  let hasProject = false;
   let budgetCeiling: number | undefined;
   let budgetSpent = 0;
   let providerIssue: string | null = null;
   let environmentErrorCount = 0;
   let environmentWarningCount = 0;
 
-  const projectState = detectHealthWidgetProjectState(basePath);
-
   try {
     const prefs = loadEffectiveGSDPreferences();
     budgetCeiling = prefs?.preferences?.budget_ceiling;
 
     const ledger = loadLedgerFromDisk(basePath);
     if (ledger) {
+      hasProject = true;
       const totals = getProjectTotals(ledger.units ?? []);
       budgetSpent = totals.cost;
     }
@@ -59,7 +63,7 @@ function loadBaseHealthWidgetData(basePath: string): HealthWidgetData {
   } catch { /* non-fatal */ }
 
   return {
-    projectState,
+    hasProject,
     budgetCeiling,
     budgetSpent,
     providerIssue,
@@ -69,88 +73,54 @@ function loadBaseHealthWidgetData(basePath: string): HealthWidgetData {
   };
 }
 
-function compactText(text: string, max = 64): string {
-  const trimmed = text.replace(/\s+/g, " ").trim();
-  if (trimmed.length <= max) return trimmed;
-  return `${trimmed.slice(0, max - 1).trimEnd()}…`;
-}
+// ── Rendering ──────────────────────────────────────────────────────────────────
 
-function summarizeExecutionStatus(state: GSDState): string {
-  switch (state.phase) {
-    case "blocked": return "Blocked";
-    case "paused": return "Paused";
-    case "complete": return "Complete";
-    case "executing": return "Executing";
-    case "planning": return "Planning";
-    case "pre-planning": return "Pre-planning";
-    case "summarizing": return "Summarizing";
-    case "validating-milestone": return "Validating";
-    case "completing-milestone": return "Completing";
-    case "needs-discussion": return "Needs discussion";
-    case "replanning-slice": return "Replanning";
-    default: return "Active";
-  }
+function formatCost(n: number): string {
+  return n >= 1 ? `$${n.toFixed(2)}` : `${(n * 100).toFixed(1)}¢`;
 }
 
-function summarizeExecutionTarget(state: GSDState): string {
-  switch (state.phase) {
-    case "needs-discussion":
-      return state.activeMilestone ? `Discuss ${state.activeMilestone.id}` : "Discuss milestone draft";
-    case "pre-planning":
-      return state.activeMilestone ? `Plan ${state.activeMilestone.id}` : "Research & plan milestone";
-    case "planning":
-      return state.activeSlice ? `Plan ${state.activeSlice.id}` : "Plan next slice";
-    case "executing":
-      return state.activeTask ? `Execute ${state.activeTask.id}` : "Execute next task";
-    case "summarizing":
-      return state.activeSlice ? `Complete ${state.activeSlice.id}` : "Complete current slice";
-    case "validating-milestone":
-      return state.activeMilestone ? `Validate ${state.activeMilestone.id}` : "Validate milestone";
-    case "completing-milestone":
-      return state.activeMilestone ? `Complete ${state.activeMilestone.id}` : "Complete milestone";
-    case "replanning-slice":
-      return state.activeSlice ? `Replan ${state.activeSlice.id}` : "Replan current slice";
-    case "blocked":
-      return `waiting on ${compactText(state.blockers[0] ?? state.nextAction, 56)}`;
-    case "paused":
-      return compactText(state.nextAction || "waiting to resume", 56);
-    case "complete":
-      return "All milestones complete";
-    default:
-      return compactText(describeNextUnit(state).label, 56);
+/**
+ * Build compact health lines for the widget.
+ * Returns a string array suitable for setWidget().
+ */
+export function buildHealthLines(data: HealthWidgetData): string[] {
+  if (!data.hasProject) {
+    return ["  GSD  No project loaded — run /gsd to start"];
   }
-}
 
-async function enrichHealthWidgetData(basePath: string, baseData: HealthWidgetData): Promise<HealthWidgetData> {
-  if (baseData.projectState !== "active") return baseData;
+  const parts: string[] = [];
 
-  try {
-    invalidateStateCache();
-    const state = await deriveState(basePath);
+  // System status signal
+  const totalIssues = data.environmentErrorCount + data.environmentWarningCount + (data.providerIssue ? 1 : 0);
+  if (totalIssues === 0) {
+    parts.push("● System OK");
+  } else if (data.environmentErrorCount > 0 || data.providerIssue?.includes("✗")) {
+    parts.push(`✗ ${totalIssues} issue${totalIssues > 1 ? "s" : ""}`);
+  } else {
+    parts.push(`⚠ ${totalIssues} warning${totalIssues > 1 ? "s" : ""}`);
+  }
 
-    if (state.activeMilestone) {
-      // Warm the slice-progress cache so estimateTimeRemaining() has data
-      updateSliceProgressCache(basePath, state.activeMilestone.id, state.activeSlice?.id);
-    }
+  // Budget
+  if (data.budgetCeiling !== undefined && data.budgetCeiling > 0) {
+    const pct = Math.min(100, (data.budgetSpent / data.budgetCeiling) * 100);
+    parts.push(`Budget: ${formatCost(data.budgetSpent)}/${formatCost(data.budgetCeiling)} (${pct.toFixed(0)}%)`);
+  } else if (data.budgetSpent > 0) {
+    parts.push(`Spent: ${formatCost(data.budgetSpent)}`);
+  }
 
-    return {
-      ...baseData,
-      executionPhase: state.phase,
-      executionStatus: summarizeExecutionStatus(state),
-      executionTarget: summarizeExecutionTarget(state),
-      nextAction: state.nextAction,
-      blocker: state.blockers[0] ?? null,
-      activeMilestoneId: state.activeMilestone?.id,
-      activeSliceId: state.activeSlice?.id,
-      activeTaskId: state.activeTask?.id,
-      progress: state.progress,
-      eta: state.phase === "blocked" || state.phase === "paused" || state.phase === "complete"
-        ? null
-        : estimateTimeRemaining(),
-    };
-  } catch {
-    return baseData;
+  // Provider issue (if any)
+  if (data.providerIssue) {
+    parts.push(data.providerIssue);
   }
+
+  // Environment issues
+  if (data.environmentErrorCount > 0) {
+    parts.push(`Env: ${data.environmentErrorCount} error${data.environmentErrorCount > 1 ? "s" : ""}`);
+  } else if (data.environmentWarningCount > 0) {
+    parts.push(`Env: ${data.environmentWarningCount} warning${data.environmentWarningCount > 1 ? "s" : ""}`);
+  }
+
+  return [`  ${parts.join("  │  ")}`];
 }
 
 // ── Widget init ────────────────────────────────────────────────────────────────
@@ -167,34 +137,20 @@ export function initHealthWidget(ctx: ExtensionContext): void {
   const basePath = projectRoot();
 
   // String-array fallback — used in RPC mode (factory is a no-op there)
-  const initialData = loadBaseHealthWidgetData(basePath);
+  const initialData = loadHealthWidgetData(basePath);
   ctx.ui.setWidget("gsd-health", buildHealthLines(initialData), { placement: "belowEditor" });
 
   // Factory-based widget for TUI mode — replaces the string-array above
   ctx.ui.setWidget("gsd-health", (_tui, _theme) => {
     let data = initialData;
     let cachedLines: string[] | undefined;
-    let refreshInFlight = false;
 
-    const refresh = async () => {
-      if (refreshInFlight) return;
-      refreshInFlight = true;
+    const refreshTimer = setInterval(() => {
       try {
-        const baseData = loadBaseHealthWidgetData(basePath);
-        data = await enrichHealthWidgetData(basePath, baseData);
+        data = loadHealthWidgetData(basePath);
         cachedLines = undefined;
         _tui.requestRender();
-      } catch { /* non-fatal */ } finally {
-        refreshInFlight = false;
-      }
-    };
-
-    // Fire first enrichment immediately. requestRender() inside is a no-op
-    // if the widget has not yet rendered, so this is safe before factory return.
-    void refresh();
-
-    const refreshTimer = setInterval(() => {
-      void refresh();
+      } catch { /* non-fatal */ }
     }, REFRESH_INTERVAL_MS);
 
     return {

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

@@ -175,16 +175,7 @@ export default function (pi: ExtensionAPI) {
         // Pipe closed — nothing we can write; just exit cleanly
         process.exit(0);
       }
-      if ((err as NodeJS.ErrnoException).code === "ENOENT" &&
-          (err as any).syscall?.startsWith("spawn")) {
-        // spawn ENOENT — command not found (e.g., npx on Windows).
-        // This surfaces as an uncaught exception from child_process but
-        // is not a fatal process error. Log and continue instead of
-        // crashing auto-mode (#1384).
-        process.stderr.write(`[gsd] spawn ENOENT: ${(err as any).path ?? "unknown"} — command not found\n`);
-        return;
-      }
-      // Re-throw anything that isn't EPIPE/ENOENT so real crashes still surface
+      // Re-throw anything that isn't EPIPE so real crashes still surface
       throw err;
     };
     process.on("uncaughtException", _gsdEpipeGuard);

package/src/resources/extensions/gsd/migrate-external.ts

@@ -6,11 +6,10 @@
  * symlink replaces the original directory so all paths remain valid.
  */
 
-import { existsSync, lstatSync, mkdirSync, readdirSync, realpathSync, renameSync, cpSync, rmSync, symlinkSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, renameSync, cpSync, rmSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { externalGsdRoot } from "./repo-identity.js";
 import { getErrorMessage } from "./error-utils.js";
-import { hasGitTrackedGsdFiles } from "./gitignore.js";
 
 export interface MigrationResult {
   migrated: boolean;
@@ -52,28 +51,6 @@ export function migrateToExternalState(basePath: string): MigrationResult {
     return { migrated: false, error: `Cannot stat .gsd: ${getErrorMessage(err)}` };
   }
 
-  // Skip if .gsd/ contains git-tracked files — the project intentionally
-  // keeps .gsd/ in version control and migration would destroy that.
-  if (hasGitTrackedGsdFiles(basePath)) {
-    return { migrated: false };
-  }
-
-  // Skip if .gsd/worktrees/ has active worktree directories (#1337).
-  // On Windows, active git worktrees hold OS-level directory handles that
-  // prevent rename/delete. Attempting migration causes EBUSY and data loss.
-  const worktreesDir = join(localGsd, "worktrees");
-  if (existsSync(worktreesDir)) {
-    try {
-      const entries = readdirSync(worktreesDir, { withFileTypes: true });
-      if (entries.some(e => e.isDirectory())) {
-        return { migrated: false };
-      }
-    } catch {
-      // Can't read worktrees dir — skip migration to be safe
-      return { migrated: false };
-    }
-  }
-
   const externalPath = externalGsdRoot(basePath);
   const migratingPath = join(basePath, ".gsd.migrating");
 
@@ -122,29 +99,7 @@ export function migrateToExternalState(basePath: string): MigrationResult {
     // Create symlink .gsd -> external path
     symlinkSync(externalPath, localGsd, "junction");
 
-    // Verify the symlink resolves correctly before removing the backup (#1377).
-    // On Windows, junction creation can silently succeed but resolve to the wrong
-    // target, or the external dir may not be accessible. If verification fails,
-    // restore from the backup.
-    try {
-      const resolved = realpathSync(localGsd);
-      const resolvedExternal = realpathSync(externalPath);
-      if (resolved !== resolvedExternal) {
-        // Symlink points to wrong target — restore backup
-        try { rmSync(localGsd, { force: true }); } catch { /* may not exist */ }
-        renameSync(migratingPath, localGsd);
-        return { migrated: false, error: `Migration verification failed: symlink resolves to ${resolved}, expected ${resolvedExternal}` };
-      }
-      // Verify we can read through the symlink
-      readdirSync(localGsd);
-    } catch (verifyErr) {
-      // Symlink broken or unreadable — restore backup
-      try { rmSync(localGsd, { force: true }); } catch { /* may not exist */ }
-      try { renameSync(migratingPath, localGsd); } catch { /* best-effort restore */ }
-      return { migrated: false, error: `Migration verification failed: ${getErrorMessage(verifyErr)}` };
-    }
-
-    // Remove .gsd.migrating only after symlink is verified
+    // Remove .gsd.migrating
     rmSync(migratingPath, { recursive: true, force: true });
 
     return { migrated: true };

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

@@ -10,8 +10,7 @@
  */
 
 import { readdirSync, existsSync, realpathSync, Dirent } from "node:fs";
-import { join, dirname, normalize } from "node:path";
-import { spawnSync } from "node:child_process";
+import { join } from "node:path";
 import { nativeScanGsdTree, type GsdTreeEntry } from "./native-parser-bridge.js";
 import { DIR_CACHE_MAX } from "./constants.js";
 
@@ -278,80 +277,15 @@ const LEGACY_GSD_ROOT_FILES: Record<GSDRootFileKey, string> = {
   KNOWLEDGE: "knowledge.md",
 };
 
-// ─── GSD Root Discovery ───────────────────────────────────────────────────────
-
-const gsdRootCache = new Map<string, string>();
-
-/** Exported for tests only — do not call in production code. */
-export function _clearGsdRootCache(): void {
-  gsdRootCache.clear();
-}
-
-/**
- * Resolve the `.gsd` directory for a given project base path.
- *
- * Probe order:
- *   1. basePath/.gsd         — fast path (common case)
- *   2. git rev-parse root    — handles cwd-is-a-subdirectory
- *   3. Walk up from basePath — handles moved .gsd in an ancestor (bounded by git root)
- *   4. basePath/.gsd         — creation fallback (init scenario)
- *
- * Result is cached per basePath for the process lifetime.
- */
 export function gsdRoot(basePath: string): string {
-  const cached = gsdRootCache.get(basePath);
-  if (cached) return cached;
-
-  const result = probeGsdRoot(basePath);
-  gsdRootCache.set(basePath, result);
-  return result;
-}
-
-function probeGsdRoot(rawBasePath: string): string {
-  // 1. Fast path — check the input path directly
-  const local = join(rawBasePath, ".gsd");
-  if (existsSync(local)) return local;
-
-  // Resolve symlinks so path comparisons work correctly across platforms
-  // (e.g. macOS /var → /private/var). Use rawBasePath as fallback if not resolvable.
-  let basePath: string;
-  try { basePath = realpathSync.native(rawBasePath); } catch { basePath = rawBasePath; }
-
-  // 2. Git root anchor — used as both probe target and walk-up boundary
-  //    Only walk if we're inside a git project — prevents escaping into
-  //    unrelated filesystem territory when running outside any repo.
-  let gitRoot: string | null = null;
+  const local = join(basePath, ".gsd");
   try {
-    const out = spawnSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd: basePath,
-      encoding: "utf-8",
-    });
-    if (out.status === 0) {
-      const r = out.stdout.trim();
-      if (r) gitRoot = normalize(r);
-    }
-  } catch { /* git not available */ }
-
-  if (gitRoot) {
-    const candidate = join(gitRoot, ".gsd");
-    if (existsSync(candidate)) return candidate;
-  }
-
-  // 3. Walk up from basePath to the git root (only if we are in a subdirectory)
-  if (gitRoot && basePath !== gitRoot) {
-    let cur = dirname(basePath);
-    while (cur !== basePath) {
-      const candidate = join(cur, ".gsd");
-      if (existsSync(candidate)) return candidate;
-      if (cur === gitRoot) break;
-      basePath = cur;
-      cur = dirname(cur);
-    }
-  }
-
-  // 4. Fallback for init/creation
-  return local;
+    const resolved = realpathSync(local);
+    if (resolved !== local) return resolved; // symlink resolved
+  } catch { /* doesn't exist yet — fall through */ }
+  return local; // backwards compat: unmigrated projects
 }
+
 export function milestonesDir(basePath: string): string {
   return join(gsdRoot(basePath), "milestones");
 }

package/src/resources/extensions/gsd/post-unit-hooks.ts

@@ -149,15 +149,11 @@ function dequeueNextHook(basePath: string): HookDispatchResult | null {
 
     // Build the prompt with variable substitution
     const [mid, sid, tid] = triggerUnitId.split("/");
-    let prompt = config.prompt
+    const prompt = config.prompt
       .replace(/\{milestoneId\}/g, mid ?? "")
       .replace(/\{sliceId\}/g, sid ?? "")
       .replace(/\{taskId\}/g, tid ?? "");
 
-    // Inject browser safety instruction for hooks that may use browser tools (#1345).
-    // Vite HMR and other persistent connections prevent networkidle from resolving.
-    prompt += "\n\n**Browser tool safety:** Do NOT use `browser_wait_for` with `condition: \"network_idle\"` — it hangs indefinitely when dev servers keep persistent connections (Vite HMR, WebSocket). Use `selector_visible`, `text_visible`, or `delay` instead.";
-
     return {
       hookName: config.name,
       prompt,

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

@@ -33,24 +33,9 @@ export function validatePreferences(preferences: GSDPreferences): {
   const validated: GSDPreferences = {};
 
   // ─── Unknown Key Detection ──────────────────────────────────────────
-  // Common key migration hints for pi-level settings that don't map to GSD prefs
-  const KEY_MIGRATION_HINTS: Record<string, string> = {
-    taskIsolation: 'use "git.isolation" instead (values: worktree, branch, none)',
-    task_isolation: 'use "git.isolation" instead (values: worktree, branch, none)',
-    isolation: 'use "git.isolation" instead (values: worktree, branch, none)',
-    manage_gitignore: 'use "git.manage_gitignore" instead',
-    auto_push: 'use "git.auto_push" instead',
-    main_branch: 'use "git.main_branch" instead',
-  };
-
   for (const key of Object.keys(preferences)) {
     if (!KNOWN_PREFERENCE_KEYS.has(key)) {
-      const hint = KEY_MIGRATION_HINTS[key];
-      if (hint) {
-        warnings.push(`unknown preference key "${key}" — ${hint}`);
-      } else {
-        warnings.push(`unknown preference key "${key}" — ignored`);
-      }
+      warnings.push(`unknown preference key "${key}" — ignored`);
     }
   }
 

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

@@ -28,8 +28,6 @@ Then:
 
 **Important:** Do NOT skip the success criteria and definition of done verification (steps 3-4). The milestone summary must reflect actual verified outcomes, not assumed success. If any criterion was not met, document it clearly in the summary and do not mark the milestone as passing verification.
 
-**File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.
-
 **You MUST write `{{milestoneSummaryPath}}` AND update PROJECT.md before finishing.**
 
 When done, say: "Milestone {{milestoneId}} complete."

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

@@ -67,6 +67,4 @@ If verdict is `needs-remediation`:
 
 **You MUST write `{{validationPath}}` before finishing.**
 
-**File system safety:** When scanning milestone directories for evidence, use `ls` or `find` to list directory contents first — never pass a directory path (e.g. `tasks/`, `slices/`) directly to the `read` tool. The `read` tool only accepts file paths, not directories.
-
 When done, say: "Milestone {{milestoneId}} validation complete — verdict: <verdict>."

package/src/resources/extensions/gsd/session-lock.ts

@@ -57,19 +57,9 @@ let _lockCompromised: boolean = false;
 /** Whether we've already registered a process.on('exit') handler. */
 let _exitHandlerRegistered: boolean = false;
 
-/** Snapshotted lock file path — captured at acquireSessionLock time to avoid
- *  gsdRoot() resolving differently in worktree vs project root contexts (#1363). */
-let _snapshotLockPath: string | null = null;
-
-/** Timestamp when the session lock was acquired — used to detect false-positive
- *  onCompromised events from event loop stalls within the stale window (#1362). */
-let _lockAcquiredAt: number = 0;
-
 const LOCK_FILE = "auto.lock";
 
 function lockPath(basePath: string): string {
-  // If we have a snapshotted path from acquisition, use it for consistency
-  if (_snapshotLockPath) return _snapshotLockPath;
   return join(gsdRoot(basePath), LOCK_FILE);
 }
 
@@ -208,19 +198,8 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
       onCompromised: () => {
         // proper-lockfile detected mtime drift (system sleep, event loop stall, etc.).
         // Default handler throws inside setTimeout — an uncaught exception that crashes
-        // or corrupts process state.
-        //
-        // False-positive suppression (#1362): If we're still within the stale window
-        // (30 min since acquisition), the mtime mismatch is from an event loop stall
-        // during a long LLM call — not a real takeover. Log and continue.
-        const elapsed = Date.now() - _lockAcquiredAt;
-        if (elapsed < 1_800_000) {
-          process.stderr.write(
-            `[gsd] Lock heartbeat mismatch after ${Math.round(elapsed / 1000)}s — event loop stall, continuing.\n`,
-          );
-          return; // Suppress false positive
-        }
-        // Past the stale window — this is a real compromise
+        // or corrupts process state. Instead, set a flag so validateSessionLock() can
+        // detect the compromise gracefully on the next dispatch cycle.
         _lockCompromised = true;
         _releaseFunction = null;
       },
@@ -230,8 +209,6 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     _lockedPath = basePath;
     _lockPid = process.pid;
     _lockCompromised = false;
-    _lockAcquiredAt = Date.now();
-    _snapshotLockPath = lp; // Snapshot the resolved path for consistent access (#1363)
 
     // Safety net: clean up lock dir on process exit if _releaseFunction
     // wasn't called (e.g., normal exit after clean completion) (#1245).
@@ -268,8 +245,6 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
         _lockedPath = basePath;
         _lockPid = process.pid;
         _lockCompromised = false;
-        _lockAcquiredAt = Date.now();
-        _snapshotLockPath = lp; // Snapshot for retry path too (#1363)
 
         // Safety net — uses centralized handler to avoid double-registration
         ensureExitHandler(gsdDir);
@@ -419,8 +394,6 @@ export function releaseSessionLock(basePath: string): void {
   _lockedPath = null;
   _lockPid = 0;
   _lockCompromised = false;
-  _lockAcquiredAt = 0;
-  _snapshotLockPath = null;
 }
 
 /**

package/src/resources/extensions/gsd/templates/plan.md

@@ -113,14 +113,6 @@
   - Tasks execute sequentially in order (T01, T02, T03, ...)
   - est: is informational (e.g. 30m, 1h, 2h) and optional
 
-  Verify field rules:
-  - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
-  - For content/document tasks: verify file existence, section count, YAML validity, or word count
-    NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
-  - If no command can verify the output, write: "Manual review — file exists and is non-empty"
-  - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
-  - GOOD: `grep -c "^## " doc.md` returns >= 4 (4+ sections), `! grep -q "TBD\|TODO" doc.md`
-
   Integration closure rule:
   - At least one slice in any multi-boundary milestone should perform real composition/wiring, not just contract hardening
   - For the final assembly slice, verification must exercise the real entrypoint or runtime path

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

@@ -40,18 +40,8 @@ test("git.merge_to_main produces deprecation warning", () => {
 });
 
 
-test("getIsolationMode defaults to worktree when preferences have no isolation setting", () => {
-  // Validate the default via validatePreferences: when no isolation is set,
-  // preferences.git.isolation is undefined, and getIsolationMode returns "worktree".
-  // We test the function's logic by verifying its documented default.
-  const { preferences } = validatePreferences({});
-  assert.equal(preferences.git?.isolation, undefined, "no isolation in empty prefs");
-  // The function returns "worktree" when prefs?.git?.isolation is not "none" or "branch"
-  // This is a compile-time-verifiable truth from the function body — test it directly
-  // by constructing the same conditions getIsolationMode checks.
-  const isolation = preferences.git?.isolation;
-  const expected = isolation === "none" ? "none" : isolation === "branch" ? "branch" : "worktree";
-  assert.equal(expected, "worktree", "default isolation mode is worktree");
+test("getIsolationMode defaults to worktree when no prefs file", { skip: "requires no global ~/.gsd/preferences.md" }, () => {
+  assert.equal(getIsolationMode(), "worktree");
 });
 
 // ── Mode defaults ────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/validate-directory.test.ts

@@ -101,21 +101,6 @@ test("validateDirectory: subdirectory of home is NOT blocked", () => {
   }
 });
 
-// Regression test for #1317: GSD worktree inside $HOME must not be blocked even
-// when the resolved project root equals $HOME (e.g. home dir is a git repo).
-test("validateDirectory: GSD worktree path nested under home is NOT blocked (#1317)", () => {
-  const worktreePath = join(homedir(), ".gsd", "worktrees", "M001");
-  mkdirSync(worktreePath, { recursive: true });
-  try {
-    // The worktree CWD itself is a valid location — it must pass.
-    const result = validateDirectory(worktreePath);
-    assert.equal(result.safe, true, "GSD worktree path should be safe to run in");
-    assert.equal(result.severity, "ok");
-  } finally {
-    rmSync(join(homedir(), ".gsd", "worktrees", "M001"), { recursive: true, force: true });
-  }
-});
-
 // ─── Temp directory root ─────────────────────────────────────────────────────────
 
 test("validateDirectory: temp directory root is blocked", () => {

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

@@ -196,7 +196,6 @@ test("dispatch rule matches validating-milestone phase", async () => {
   try {
     // Set up minimal milestone structure for the prompt builder
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
-    writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone."); // Guard requires slice summaries (#1368)
 
     const ctx: DispatchContext = {
       basePath: base,
@@ -232,7 +231,6 @@ test("dispatch rule skips when skip_milestone_validation preference is set", asy
   const base = makeTmpBase();
   try {
     writeRoadmap(base, "M001", ALL_DONE_ROADMAP);
-    writeSliceSummary(base, "M001", "S01", "# S01 Summary\nDone."); // Guard requires slice summaries (#1368)
 
     const ctx: DispatchContext = {
       basePath: base,