gsd-pi 2.23.0 → 2.24.0

package/dist/cli.js

@@ -8,7 +8,7 @@ import { loadStoredEnvKeys } from './wizard.js';
 import { getPiDefaultModelAndProvider, migratePiCredentials } from './pi-migration.js';
 import { shouldRunOnboarding, runOnboarding } from './onboarding.js';
 import chalk from 'chalk';
-import { checkForUpdates } from './update-check.js';
+import { checkForUpdates, checkAndPromptForUpdates } from './update-check.js';
 import { printHelp, printSubcommandHelp } from './help-text.js';
 function exitIfManagedResourcesAreNewer(currentAgentDir) {
     const currentVersion = process.env.GSD_VERSION || '0.0.0';
@@ -169,9 +169,18 @@ if (!isPrintMode && shouldRunOnboarding(authStorage, settingsManager.getDefaultP
         process.stdin.setRawMode(false);
     process.stdin.pause();
 }
-// Non-blocking update check — runs at most once per 24h, fire-and-forget
+// Update check — interactive prompt when stdin is a TTY, passive banner otherwise
 if (!isPrintMode) {
-    checkForUpdates().catch(() => { });
+    if (process.stdin.isTTY) {
+        const updated = await checkAndPromptForUpdates().catch(() => false);
+        if (updated) {
+            // User chose to update — exit so they relaunch with the new version
+            process.exit(0);
+        }
+    }
+    else {
+        checkForUpdates().catch(() => { });
+    }
 }
 // Warn if terminal is too narrow for readable output
 if (!isPrintMode && process.stdout.columns && process.stdout.columns < 40) {

package/dist/headless.d.ts

@@ -16,6 +16,10 @@ export interface HeadlessOptions {
     model?: string;
     command: string;
     commandArgs: string[];
+    context?: string;
+    contextText?: string;
+    auto?: boolean;
+    verbose?: boolean;
 }
 export declare function parseHeadlessArgs(argv: string[]): HeadlessOptions;
 export declare function runHeadless(options: HeadlessOptions): Promise<void>;

package/dist/headless.js

@@ -10,8 +10,8 @@
  *   1 — error or timeout
  *   2 — blocked (command reported a blocker)
  */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
 // RpcClient is not in @gsd/pi-coding-agent's public exports — import from dist directly.
 // This relative path resolves correctly from both src/ (via tsx) and dist/ (compiled).
 import { RpcClient } from '../packages/pi-coding-agent/dist/modes/rpc/rpc-client.js';
@@ -46,6 +46,18 @@ export function parseHeadlessArgs(argv) {
                 // --model can also be passed from the main CLI; headless-specific takes precedence
                 options.model = args[++i];
             }
+            else if (arg === '--context' && i + 1 < args.length) {
+                options.context = args[++i];
+            }
+            else if (arg === '--context-text' && i + 1 < args.length) {
+                options.contextText = args[++i];
+            }
+            else if (arg === '--auto') {
+                options.auto = true;
+            }
+            else if (arg === '--verbose') {
+                options.verbose = true;
+            }
         }
         else if (!positionalStarted) {
             positionalStarted = true;
@@ -99,18 +111,23 @@ function handleExtensionUIRequest(event, writeToStdin) {
 // ---------------------------------------------------------------------------
 // Progress Formatter
 // ---------------------------------------------------------------------------
-function formatProgress(event) {
+function formatProgress(event, verbose) {
     const type = String(event.type ?? '');
     switch (type) {
         case 'tool_execution_start':
-            return `[tool] ${event.toolName ?? 'unknown'}`;
+            if (verbose)
+                return `  [tool]    ${event.toolName ?? 'unknown'}`;
+            return null;
         case 'agent_start':
-            return '[agent] Session started';
+            return '[agent]   Session started';
         case 'agent_end':
-            return '[agent] Session ended';
+            return '[agent]   Session ended';
         case 'extension_ui_request':
             if (event.method === 'notify') {
-                return `[gsd] ${event.message ?? ''}`;
+                return `[gsd]     ${event.message ?? ''}`;
+            }
+            if (event.method === 'setStatus') {
+                return `[status]  ${event.message ?? ''}`;
             }
             return null;
         default:
@@ -133,6 +150,11 @@ function isBlockedNotification(event) {
         return false;
     return String(event.message ?? '').toLowerCase().includes('blocked');
 }
+function isMilestoneReadyNotification(event) {
+    if (event.type !== 'extension_ui_request' || event.method !== 'notify')
+        return false;
+    return /milestone\s+m\d+.*ready/i.test(String(event.message ?? ''));
+}
 // ---------------------------------------------------------------------------
 // Quick Command Detection
 // ---------------------------------------------------------------------------
@@ -148,11 +170,69 @@ function isQuickCommand(command) {
 // ---------------------------------------------------------------------------
 // Main Orchestrator
 // ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Context Loading (new-milestone)
+// ---------------------------------------------------------------------------
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+async function loadContext(options) {
+    if (options.contextText)
+        return options.contextText;
+    if (options.context === '-') {
+        return readStdin();
+    }
+    if (options.context) {
+        return readFileSync(resolve(options.context), 'utf-8');
+    }
+    throw new Error('No context provided. Use --context <file> or --context-text <text>');
+}
+/**
+ * Bootstrap .gsd/ directory structure for headless new-milestone.
+ * Mirrors the bootstrap logic from guided-flow.ts showSmartEntry().
+ */
+function bootstrapGsdProject(basePath) {
+    const gsdDir = join(basePath, '.gsd');
+    mkdirSync(join(gsdDir, 'milestones'), { recursive: true });
+    mkdirSync(join(gsdDir, 'runtime'), { recursive: true });
+}
 export async function runHeadless(options) {
     const startTime = Date.now();
-    // Validate .gsd/ directory
+    const isNewMilestone = options.command === 'new-milestone';
+    // For new-milestone, load context and bootstrap .gsd/ before spawning RPC child
+    if (isNewMilestone) {
+        if (!options.context && !options.contextText) {
+            process.stderr.write('[headless] Error: new-milestone requires --context <file> or --context-text <text>\n');
+            process.exit(1);
+        }
+        let contextContent;
+        try {
+            contextContent = await loadContext(options);
+        }
+        catch (err) {
+            process.stderr.write(`[headless] Error loading context: ${err instanceof Error ? err.message : String(err)}\n`);
+            process.exit(1);
+        }
+        // Bootstrap .gsd/ if needed
+        const gsdDir = join(process.cwd(), '.gsd');
+        if (!existsSync(gsdDir)) {
+            if (!options.json) {
+                process.stderr.write('[headless] Bootstrapping .gsd/ project structure...\n');
+            }
+            bootstrapGsdProject(process.cwd());
+        }
+        // Write context to temp file for the RPC child to read
+        const runtimeDir = join(gsdDir, 'runtime');
+        mkdirSync(runtimeDir, { recursive: true });
+        writeFileSync(join(runtimeDir, 'headless-context.md'), contextContent, 'utf-8');
+    }
+    // Validate .gsd/ directory (skip for new-milestone since we just bootstrapped it)
     const gsdDir = join(process.cwd(), '.gsd');
-    if (!existsSync(gsdDir)) {
+    if (!isNewMilestone && !existsSync(gsdDir)) {
         process.stderr.write('[headless] Error: No .gsd/ directory found in current directory.\n');
         process.stderr.write("[headless] Run 'gsd' interactively first to initialize a project.\n");
         process.exit(1);
@@ -178,6 +258,7 @@ export async function runHeadless(options) {
     let blocked = false;
     let completed = false;
     let exitCode = 0;
+    let milestoneReady = false; // tracks "Milestone X ready." for auto-chaining
     const recentEvents = [];
     function trackEvent(event) {
         totalEvents++;
@@ -231,7 +312,7 @@ export async function runHeadless(options) {
         }
         else {
             // Progress output to stderr
-            const line = formatProgress(eventObj);
+            const line = formatProgress(eventObj, !!options.verbose);
             if (line)
                 process.stderr.write(line + '\n');
         }
@@ -241,6 +322,10 @@ export async function runHeadless(options) {
             if (isBlockedNotification(eventObj)) {
                 blocked = true;
             }
+            // Detect "Milestone X ready." for auto-mode chaining
+            if (isMilestoneReadyNotification(eventObj)) {
+                milestoneReady = true;
+            }
             if (isTerminalNotification(eventObj)) {
                 completed = true;
             }
@@ -319,6 +404,29 @@ export async function runHeadless(options) {
     if (exitCode === 0 || exitCode === 2) {
         await completionPromise;
     }
+    // Auto-mode chaining: if --auto and milestone creation succeeded, send /gsd auto
+    if (isNewMilestone && options.auto && milestoneReady && !blocked && exitCode === 0) {
+        if (!options.json) {
+            process.stderr.write('[headless] Milestone ready — chaining into auto-mode...\n');
+        }
+        // Reset completion state for the auto-mode phase
+        completed = false;
+        milestoneReady = false;
+        blocked = false;
+        const autoCompletionPromise = new Promise((resolve) => {
+            resolveCompletion = resolve;
+        });
+        try {
+            await client.prompt('/gsd auto');
+        }
+        catch (err) {
+            process.stderr.write(`[headless] Error: Failed to start auto-mode: ${err instanceof Error ? err.message : String(err)}\n`);
+            exitCode = 1;
+        }
+        if (exitCode === 0 || exitCode === 2) {
+            await autoCompletionPromise;
+        }
+    }
     // Cleanup
     clearTimeout(timeoutTimer);
     if (idleTimer)

package/dist/help-text.js

@@ -35,15 +35,30 @@ const SUBCOMMAND_HELP = {
         'Run /gsd commands without the TUI. Default command: auto',
         '',
         'Flags:',
-        '  --timeout N     Overall timeout in ms (default: 300000)',
-        '  --json          JSONL event stream to stdout',
-        '  --model ID      Override model',
+        '  --timeout N          Overall timeout in ms (default: 300000)',
+        '  --json               JSONL event stream to stdout',
+        '  --model ID           Override model',
+        '',
+        'Commands:',
+        '  auto                 Run all queued units continuously (default)',
+        '  next                 Run one unit',
+        '  status               Show progress dashboard',
+        '  new-milestone        Create a milestone from a specification document',
+        '',
+        'new-milestone flags:',
+        '  --context <path>     Path to spec/PRD file (use \'-\' for stdin)',
+        '  --context-text <txt> Inline specification text',
+        '  --auto               Start auto-mode after milestone creation',
+        '  --verbose            Show tool calls in progress output',
         '',
         'Examples:',
-        '  gsd headless                    Run /gsd auto',
-        '  gsd headless next               Run one unit',
-        '  gsd headless --json status      Machine-readable status',
-        '  gsd headless --timeout 60000    With 1-minute timeout',
+        '  gsd headless                                    Run /gsd auto',
+        '  gsd headless next                               Run one unit',
+        '  gsd headless --json status                      Machine-readable status',
+        '  gsd headless --timeout 60000                    With 1-minute timeout',
+        '  gsd headless new-milestone --context spec.md    Create milestone from file',
+        '  cat spec.md | gsd headless new-milestone --context -   From stdin',
+        '  gsd headless new-milestone --context spec.md --auto    Create + auto-execute',
         '',
         'Exit codes: 0 = complete, 1 = error/timeout, 2 = blocked',
     ].join('\n'),

package/dist/resource-loader.js

@@ -1,6 +1,6 @@
 import { DefaultResourceLoader } from '@gsd/pi-coding-agent';
 import { homedir } from 'node:os';
-import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { chmodSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { compareSemver } from './update-check.js';
@@ -113,6 +113,38 @@ export function getNewerManagedResourceVersion(agentDir, currentVersion) {
     }
     return compareSemver(managedVersion, currentVersion) > 0 ? managedVersion : null;
 }
+/**
+ * Recursively makes all files and directories under dirPath owner-writable.
+ *
+ * Files copied from the Nix store inherit read-only modes (0444/0555).
+ * Calling this before cpSync prevents overwrite failures on subsequent upgrades,
+ * and calling it after ensures the next run can overwrite the copies too.
+ *
+ * Preserves existing permission bits (including executability) and only adds
+ * owner-write (and for directories, owner-exec) without widening group/other
+ * permissions.
+ */
+function makeTreeWritable(dirPath) {
+    if (!existsSync(dirPath))
+        return;
+    const stats = statSync(dirPath);
+    const isDir = stats.isDirectory();
+    const currentMode = stats.mode & 0o777;
+    // Ensure owner-write; for directories also ensure owner-exec so they remain traversable.
+    let newMode = currentMode | 0o200;
+    if (isDir) {
+        newMode |= 0o100;
+    }
+    if (newMode !== currentMode) {
+        chmodSync(dirPath, newMode);
+    }
+    if (isDir) {
+        for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
+            const entryPath = join(dirPath, entry.name);
+            makeTreeWritable(entryPath);
+        }
+    }
+}
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
  *
@@ -130,26 +162,49 @@ export function getNewerManagedResourceVersion(agentDir, currentVersion) {
  */
 export function initResources(agentDir) {
     mkdirSync(agentDir, { recursive: true });
-    // Skip resource sync when versions match — saves ~128ms of cpSync per launch
-    const currentVersion = getBundledGsdVersion();
-    const managedVersion = readManagedResourceVersion(agentDir);
-    if (managedVersion && managedVersion === currentVersion) {
-        return;
-    }
-    // Sync extensions — overwrite so updates land on next launch
+    // Sync extensions — clean bundled subdirs first to remove stale leftover files,
+    // then overwrite so updates land on next launch. Only bundled subdirs are removed;
+    // user-created extension directories are preserved.
     const destExtensions = join(agentDir, 'extensions');
+    makeTreeWritable(destExtensions);
+    for (const entry of readdirSync(bundledExtensionsDir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            const target = join(destExtensions, entry.name);
+            if (existsSync(target))
+                rmSync(target, { recursive: true, force: true });
+        }
+    }
     cpSync(bundledExtensionsDir, destExtensions, { recursive: true, force: true });
+    makeTreeWritable(destExtensions);
     // Sync agents
     const destAgents = join(agentDir, 'agents');
     const srcAgents = join(resourcesDir, 'agents');
     if (existsSync(srcAgents)) {
+        makeTreeWritable(destAgents);
+        for (const entry of readdirSync(srcAgents, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                const target = join(destAgents, entry.name);
+                if (existsSync(target))
+                    rmSync(target, { recursive: true, force: true });
+            }
+        }
         cpSync(srcAgents, destAgents, { recursive: true, force: true });
+        makeTreeWritable(destAgents);
     }
-    // Sync skills — overwrite so updates land on next launch
+    // Sync skills
     const destSkills = join(agentDir, 'skills');
     const srcSkills = join(resourcesDir, 'skills');
     if (existsSync(srcSkills)) {
+        makeTreeWritable(destSkills);
+        for (const entry of readdirSync(srcSkills, { withFileTypes: true })) {
+            if (entry.isDirectory()) {
+                const target = join(destSkills, entry.name);
+                if (existsSync(target))
+                    rmSync(target, { recursive: true, force: true });
+            }
+        }
         cpSync(srcSkills, destSkills, { recursive: true, force: true });
+        makeTreeWritable(destSkills);
     }
     writeManagedResourceManifest(agentDir);
 }

package/dist/resources/extensions/gsd/auto-dispatch.ts

@@ -14,9 +14,11 @@ import type { GSDPreferences } from "./preferences.js";
 import type { UatType } from "./files.js";
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import {
-  resolveMilestoneFile, resolveSliceFile,
-  relSliceFile,
+  resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile,
+  relSliceFile, buildMilestoneFileName,
 } from "./paths.js";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import {
   buildResearchMilestonePrompt,
   buildPlanMilestonePrompt,
@@ -25,6 +27,7 @@ import {
   buildExecuteTaskPrompt,
   buildCompleteSlicePrompt,
   buildCompleteMilestonePrompt,
+  buildValidateMilestonePrompt,
   buildReplanSlicePrompt,
   buildRunUatPrompt,
   buildReassessRoadmapPrompt,
@@ -246,6 +249,20 @@ const DISPATCH_RULES: DispatchRule[] = [
       const sTitle = state.activeSlice!.title;
       const tid = state.activeTask.id;
       const tTitle = state.activeTask.title;
+
+      // Guard: refuse to dispatch execute-task when the task plan file is missing.
+      // This prevents the agent from running blind after a failed plan-slice that
+      // wrote S{sid}-PLAN.md but omitted the individual T{tid}-PLAN.md files.
+      // (See issue #739 — missing task plan caused runaway execution and EPIPE crash.)
+      const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
+      if (!taskPlanPath || !existsSync(taskPlanPath)) {
+        return {
+          action: "stop",
+          reason: `Task plan ${tid}-PLAN.md is missing for ${mid}/${sid}/${tid}. Re-run plan-slice to regenerate task plans, or create the file manually and resume.`,
+          level: "error",
+        };
+      }
+
       return {
         action: "dispatch",
         unitType: "execute-task",
@@ -254,6 +271,38 @@ const DISPATCH_RULES: DispatchRule[] = [
       };
     },
   },
+  {
+    name: "validating-milestone → validate-milestone",
+    match: async ({ state, mid, midTitle, basePath, prefs }) => {
+      if (state.phase !== "validating-milestone") return null;
+      // Skip preference: write a minimal pass-through VALIDATION file
+      if (prefs?.phases?.skip_milestone_validation) {
+        const mDir = resolveMilestonePath(basePath, mid);
+        if (mDir) {
+          if (!existsSync(mDir)) mkdirSync(mDir, { recursive: true });
+          const validationPath = join(mDir, buildMilestoneFileName(mid, "VALIDATION"));
+          const content = [
+            "---",
+            "verdict: pass",
+            "remediation_round: 0",
+            "---",
+            "",
+            "# Milestone Validation (skipped by preference)",
+            "",
+            "Milestone validation was skipped via `skip_milestone_validation` preference.",
+          ].join("\n");
+          writeFileSync(validationPath, content, "utf-8");
+        }
+        return { action: "skip" };
+      }
+      return {
+        action: "dispatch",
+        unitType: "validate-milestone",
+        unitId: mid,
+        prompt: await buildValidateMilestonePrompt(mid, midTitle, basePath),
+      };
+    },
+  },
   {
     name: "completing-milestone → complete-milestone",
     match: async ({ state, mid, midTitle, basePath }) => {

package/dist/resources/extensions/gsd/auto-prompts.ts

@@ -855,6 +855,79 @@ export async function buildCompleteMilestonePrompt(
   });
 }
 
+export async function buildValidateMilestonePrompt(
+  mid: string, midTitle: string, base: string, level?: InlineLevel,
+): Promise<string> {
+  const inlineLevel = level ?? resolveInlineLevel();
+  const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+  const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
+
+  const inlined: string[] = [];
+  inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
+
+  // Inline all slice summaries and UAT results
+  const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
+  if (roadmapContent) {
+    const roadmap = parseRoadmap(roadmapContent);
+    const seenSlices = new Set<string>();
+    for (const slice of roadmap.slices) {
+      if (seenSlices.has(slice.id)) continue;
+      seenSlices.add(slice.id);
+      const summaryPath = resolveSliceFile(base, mid, slice.id, "SUMMARY");
+      const summaryRel = relSliceFile(base, mid, slice.id, "SUMMARY");
+      inlined.push(await inlineFile(summaryPath, summaryRel, `${slice.id} Summary`));
+
+      const uatPath = resolveSliceFile(base, mid, slice.id, "UAT-RESULT");
+      const uatRel = relSliceFile(base, mid, slice.id, "UAT-RESULT");
+      const uatInline = await inlineFileOptional(uatPath, uatRel, `${slice.id} UAT Result`);
+      if (uatInline) inlined.push(uatInline);
+    }
+  }
+
+  // Inline existing VALIDATION file if this is a re-validation round
+  const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
+  const validationRel = relMilestoneFile(base, mid, "VALIDATION");
+  const validationContent = validationPath ? await loadFile(validationPath) : null;
+  let remediationRound = 0;
+  if (validationContent) {
+    const roundMatch = validationContent.match(/remediation_round:\s*(\d+)/);
+    remediationRound = roundMatch ? parseInt(roundMatch[1], 10) + 1 : 1;
+    inlined.push(`### Previous Validation (re-validation round ${remediationRound})\nSource: \`${validationRel}\`\n\n${validationContent.trim()}`);
+  }
+
+  // Inline root GSD files
+  if (inlineLevel !== "minimal") {
+    const requirementsInline = await inlineRequirementsFromDb(base);
+    if (requirementsInline) inlined.push(requirementsInline);
+    const decisionsInline = await inlineDecisionsFromDb(base, mid);
+    if (decisionsInline) inlined.push(decisionsInline);
+    const projectInline = await inlineProjectFromDb(base);
+    if (projectInline) inlined.push(projectInline);
+  }
+  const knowledgeInline = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
+  if (knowledgeInline) inlined.push(knowledgeInline);
+  // Inline milestone context file
+  const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
+  const contextRel = relMilestoneFile(base, mid, "CONTEXT");
+  const contextInline = await inlineFileOptional(contextPath, contextRel, "Milestone Context");
+  if (contextInline) inlined.push(contextInline);
+
+  const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+
+  const validationOutputPath = join(base, `${relMilestonePath(base, mid)}/${mid}-VALIDATION.md`);
+  const roadmapOutputPath = `${relMilestonePath(base, mid)}/${mid}-ROADMAP.md`;
+
+  return loadPrompt("validate-milestone", {
+    workingDirectory: base,
+    milestoneId: mid,
+    milestoneTitle: midTitle,
+    roadmapPath: roadmapOutputPath,
+    inlinedContext,
+    validationPath: validationOutputPath,
+    remediationRound: String(remediationRound),
+  });
+}
+
 export async function buildReplanSlicePrompt(
   mid: string, midTitle: string, sid: string, sTitle: string, base: string,
 ): Promise<string> {

package/dist/resources/extensions/gsd/auto-recovery.ts

@@ -11,7 +11,7 @@ import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import {
   clearUnitRuntimeRecord,
 } from "./unit-runtime.js";
-import { clearParseCache } from "./files.js";
+import { clearParseCache, parseRoadmap, parsePlan } from "./files.js";
 import {
   nativeConflictFiles,
   nativeCommit,
@@ -36,7 +36,6 @@ import {
   clearPathCache,
   resolveGsdRootFile,
 } from "./paths.js";
-import { parseRoadmap } from "./files.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, renameSync } from "node:fs";
 import { dirname, join } from "node:path";
 
@@ -83,6 +82,10 @@ export function resolveExpectedArtifactPath(unitType: string, unitId: string, ba
       const dir = resolveSlicePath(base, mid, sid!);
       return dir ? join(dir, buildSliceFileName(sid!, "SUMMARY")) : null;
     }
+    case "validate-milestone": {
+      const dir = resolveMilestonePath(base, mid);
+      return dir ? join(dir, buildMilestoneFileName(mid, "VALIDATION")) : null;
+    }
     case "complete-milestone": {
       const dir = resolveMilestonePath(base, mid);
       return dir ? join(dir, buildMilestoneFileName(mid, "SUMMARY")) : null;
@@ -157,6 +160,31 @@ export function verifyExpectedArtifact(unitType: string, unitId: string, base: s
     }
   }
 
+  // plan-slice must also produce individual task plan files for every task listed
+  // in the slice plan. Without this check, a plan-slice that wrote S{sid}-PLAN.md
+  // but omitted T{tid}-PLAN.md files would be marked complete, causing execute-task
+  // to dispatch with a missing task plan (see issue #739).
+  if (unitType === "plan-slice") {
+    const parts = unitId.split("/");
+    const mid = parts[0];
+    const sid = parts[1];
+    if (mid && sid) {
+      try {
+        const planContent = readFileSync(absPath, "utf-8");
+        const plan = parsePlan(planContent);
+        const tasksDir = resolveTasksDir(base, mid, sid);
+        if (plan.tasks.length > 0 && tasksDir) {
+          for (const task of plan.tasks) {
+            const taskPlanFile = join(tasksDir, `${task.id}-PLAN.md`);
+            if (!existsSync(taskPlanFile)) return false;
+          }
+        }
+      } catch {
+        // Parse failure — don't block; slice plan may have non-standard format
+      }
+    }
+  }
+
   // complete-slice must also produce a UAT file AND mark the slice [x] in the roadmap.
   // Without the roadmap check, a crash after writing SUMMARY+UAT but before updating
   // the roadmap causes an infinite skip loop: the idempotency key says "done" but the
@@ -244,6 +272,8 @@ export function diagnoseExpectedArtifact(unitType: string, unitId: string, base:
       return `${relSliceFile(base, mid!, sid!, "ASSESSMENT")} (roadmap reassessment)`;
     case "run-uat":
       return `${relSliceFile(base, mid!, sid!, "UAT-RESULT")} (UAT result)`;
+    case "validate-milestone":
+      return `${relMilestoneFile(base, mid!, "VALIDATION")} (milestone validation report)`;
     case "complete-milestone":
       return `${relMilestoneFile(base, mid!, "SUMMARY")} (milestone summary)`;
     default:
@@ -537,6 +567,15 @@ export function buildLoopRemediationSteps(unitType: string, unitId: string, base
         `   4. Resume auto-mode`,
       ].join("\n");
     }
+    case "validate-milestone": {
+      if (!mid) break;
+      const artifactRel = relMilestoneFile(base, mid, "VALIDATION");
+      return [
+        `   1. Write ${artifactRel} with verdict: pass`,
+        `   2. Run \`gsd doctor\``,
+        `   3. Resume auto-mode`,
+      ].join("\n");
+    }
     default:
       break;
   }

package/dist/resources/extensions/gsd/auto-worktree.ts

@@ -158,7 +158,15 @@ export function createAutoWorktree(basePath: string, milestoneId: string): strin
   // Planning artifacts may be untracked if the project's .gitignore had a
   // blanket .gsd/ rule (pre-v2.14.0). Without this copy, auto-mode loops
   // on plan-slice because the plan file doesn't exist in the worktree.
-  copyPlanningArtifacts(basePath, info.path);
+  //
+  // IMPORTANT: Skip when re-attaching to an existing branch (#759).
+  // The branch checkout already has committed artifacts with correct state
+  // (e.g. [x] for completed slices). Copying from the project root would
+  // overwrite them with stale data ([ ] checkboxes) because the root is
+  // not always fully synced.
+  if (!branchExists) {
+    copyPlanningArtifacts(basePath, info.path);
+  }
 
   // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
   const hookError = runWorktreePostCreateHook(basePath, info.path);
@@ -429,8 +437,12 @@ export function mergeMilestoneToMain(
   const integrationBranch = readIntegrationBranch(originalBasePath_, milestoneId);
   const mainBranch = integrationBranch ?? prefs.main_branch ?? "main";
 
-  // 5. Checkout integration branch
-  nativeCheckoutBranch(originalBasePath_, mainBranch);
+  // 5. Checkout integration branch (skip if already current — avoids git error
+  //    when main is already checked out in the project-root worktree, #757)
+  const currentBranchAtBase = nativeGetCurrentBranch(originalBasePath_);
+  if (currentBranchAtBase !== mainBranch) {
+    nativeCheckoutBranch(originalBasePath_, mainBranch);
+  }
 
   // 6. Build rich commit message
   const milestoneTitle = roadmap.title.replace(/^M\d+:\s*/, "").trim() || milestoneId;