gsd-pi 2.79.0 → 2.80.0-dev.4ea7d80e7

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

@@ -12,7 +12,7 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -110,17 +110,32 @@ export function hasImplementationArtifacts(basePath, milestoneId) {
         // milestone commits instead of treating the self-diff as proof of no work.
         if (changedFiles.length === 0) {
             if (milestoneId && currentBranch === integrationBranch) {
-                const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
-                if (!tagged.ok)
+                const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+                if (!milestoneEvidence.ok)
                     return "unknown";
-                if (tagged.matched)
-                    return classifyImplementationFiles(tagged.files);
+                if (milestoneEvidence.matched)
+                    return classifyImplementationFiles(milestoneEvidence.files);
             }
             if (currentBranch && currentBranch !== "HEAD")
                 return "absent";
             return "unknown";
         }
-        return classifyImplementationFiles(changedFiles);
+        const branchClassification = classifyImplementationFiles(changedFiles);
+        if (branchClassification === "present")
+            return "present";
+        // A completing milestone branch can have a non-empty diff containing only
+        // .gsd/ closeout files after implementation commits already landed on the
+        // recorded integration branch. In that topology, the branch diff alone is
+        // insufficient; use the same milestone-tagged evidence fallback as the
+        // self-diff retry path before declaring the milestone implementation-free.
+        if (milestoneId) {
+            const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+            if (!milestoneEvidence.ok)
+                return "unknown";
+            if (milestoneEvidence.matched)
+                return classifyImplementationFiles(milestoneEvidence.files);
+        }
+        return "absent";
     }
     catch (e) {
         // Non-fatal — if git operations fail, return unknown so callers can decide
@@ -148,6 +163,9 @@ function classifyImplementationFiles(files) {
 function isImplementationPath(file) {
     return !file.startsWith(".gsd/") && !file.startsWith(".gsd\\");
 }
+function normalizeRepoPath(file) {
+    return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
 /**
  * Detect the main/master branch name.
  */
@@ -217,7 +235,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     ]);
     if (!scoped.ok)
         return scoped;
-    if (scoped.matched)
+    if (scoped.matched && classifyImplementationFiles(scoped.files) === "present")
         return scoped;
     // Fallback (#5033): when .gsd/ is gitignored / external / untracked, the
     // path-scoped scan matches no commits even though GSD-tagged commits
@@ -228,9 +246,137 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // Intentionally unbounded — symmetric with the primary scan, and avoids
     // reintroducing the rolling-depth failure class removed in #4699 where
     // milestone evidence aged out behind unrelated activity.
-    return scanGsdTaggedCommits(basePath, milestoneId, [
+    const unscoped = scanGsdTaggedCommits(basePath, milestoneId, [
         "log", "--format=%H%x1f%B%x1e", "HEAD",
     ]);
+    if (!unscoped.ok)
+        return scoped.matched ? scoped : unscoped;
+    if (!unscoped.matched)
+        return scoped;
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...scoped.files, ...unscoped.files])],
+    };
+}
+function getChangedFilesFromMilestoneEvidence(basePath, milestoneId) {
+    const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
+    if (!tagged.ok)
+        return tagged;
+    if (tagged.matched && classifyImplementationFiles(tagged.files) === "present")
+        return tagged;
+    const attributed = getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId);
+    if (!attributed.ok)
+        return tagged.matched ? tagged : attributed;
+    if (attributed.matched && classifyImplementationFiles(attributed.files) === "present")
+        return attributed;
+    const backfilled = backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId);
+    if (!backfilled.ok)
+        return tagged.matched ? tagged : attributed.matched ? attributed : backfilled;
+    if (!backfilled.matched) {
+        if (tagged.matched)
+            return tagged;
+        return attributed.matched ? attributed : backfilled;
+    }
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...tagged.files, ...attributed.files, ...backfilled.files])],
+    };
+}
+function getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const shas = getMilestoneCommitAttributionShas(milestoneId);
+        if (shas.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const files = new Set();
+        let matched = false;
+        for (const sha of shas) {
+            if (!isFullCommitSha(sha))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, sha);
+            if (commitFiles.length === 0)
+                continue;
+            matched = true;
+            for (const file of commitFiles)
+                files.add(file);
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution scan failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const milestone = getMilestone(milestoneId);
+        const milestoneStartedAt = milestone?.created_at ? Math.floor(Date.parse(milestone.created_at) / 1000) * 1000 : NaN;
+        if (!Number.isFinite(milestoneStartedAt))
+            return { ok: true, matched: false, files: [] };
+        const taskFileHints = getCompletedMilestoneTaskFileHints(milestoneId);
+        if (taskFileHints.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const hintSet = new Set(taskFileHints.map(normalizeRepoPath).filter(Boolean));
+        if (hintSet.size === 0)
+            return { ok: true, matched: false, files: [] };
+        const records = getCommitRecords(basePath);
+        const files = new Set();
+        let matched = false;
+        for (const record of records) {
+            if (!isFullCommitSha(record.hash))
+                continue;
+            if (Date.parse(record.committedAt) < milestoneStartedAt)
+                continue;
+            if (record.parents.trim().split(/\s+/).filter(Boolean).length > 1)
+                continue;
+            if (commitMessageHasGsdTrailer(record.message))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, record.hash);
+            const implementationFiles = commitFiles.map(normalizeRepoPath).filter(isImplementationPath);
+            if (implementationFiles.length === 0)
+                continue;
+            if (!implementationFiles.some((file) => hintSet.has(file)))
+                continue;
+            matched = true;
+            for (const file of implementationFiles)
+                files.add(file);
+            recordMilestoneCommitAttribution({
+                commitSha: record.hash,
+                milestoneId,
+                source: "backfill",
+                confidence: 0.8,
+                files: implementationFiles,
+                createdAt: new Date().toISOString(),
+            });
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution backfill failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function getCommitRecords(basePath) {
+    const logOutput = execFileSync("git", ["log", "--format=%H%x1f%P%x1f%cI%x1f%B%x1e", "HEAD"], {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+    });
+    return logOutput
+        .split("\x1e")
+        .map((record) => record.trim())
+        .filter(Boolean)
+        .flatMap((record) => {
+        const parts = record.split("\x1f");
+        if (parts.length < 4)
+            return [];
+        const [hash, parents, committedAt, ...messageParts] = parts;
+        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message: messageParts.join("\x1f") }];
+    });
+}
+function isFullCommitSha(value) {
+    return /^[0-9a-f]{40}$/i.test(value);
 }
 function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
     try {
@@ -257,7 +403,7 @@ function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
             if (!commitMessageHasGsdTrailer(message))
                 continue;
             const commitFiles = getChangedFilesForCommit(basePath, hash);
-            if (!commitMatchesMilestone(message, milestoneId, commitFiles))
+            if (!commitMatchesMilestone(basePath, message, milestoneId, commitFiles))
                 continue;
             matched = true;
             for (const file of commitFiles) {
@@ -278,22 +424,37 @@ function getChangedFilesForCommit(basePath, hash) {
 function commitMessageHasGsdTrailer(message) {
     return /^GSD-(?:Task|Unit):\s*\S+/m.test(message);
 }
-function commitMatchesMilestone(message, milestoneId, files) {
+function commitMatchesMilestone(basePath, message, milestoneId, files) {
     if (commitTrailerStartsWithMilestone(message, milestoneId))
         return true;
     // Meaningful execute-task commits currently store task scope as Sxx/Tyy
     // rather than Mxx/Sxx/Tyy. Bind those commits back to the milestone when
     // either the commit touched this milestone's artifacts, or — for projects
     // where .gsd/ is gitignored/external (#5033) — the message explicitly
-    // names the milestone.
+    // names the milestone or local GSD state proves the task belongs here.
     if (/^GSD-Task:\s*S[^/\s]+\/T\S+/m.test(message)) {
         if (files.some((file) => isMilestoneArtifactPath(file, milestoneId)))
             return true;
         if (commitMessageMentionsMilestone(message, milestoneId))
             return true;
+        if (commitTaskTrailerBelongsToMilestone(basePath, message, milestoneId))
+            return true;
     }
     return false;
 }
+function commitTaskTrailerBelongsToMilestone(basePath, message, milestoneId) {
+    const match = message.match(/^GSD-Task:\s*(S[^/\s]+)\/(T[^\s]+)/m);
+    if (!match)
+        return false;
+    const [, sliceId, taskId] = match;
+    if (getTask(milestoneId, sliceId, taskId))
+        return true;
+    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
+    if (!tasksDir)
+        return false;
+    return existsSync(join(tasksDir, `${taskId}-PLAN.md`))
+        || existsSync(join(tasksDir, `${taskId}-SUMMARY.md`));
+}
 function commitMessageMentionsMilestone(message, milestoneId) {
     if (!MILESTONE_ID_RE.test(milestoneId))
         return false;
@@ -495,66 +656,32 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             return false;
         }
     }
-    // plan-slice must produce a plan with actual task entries, not just a scaffold.
-    // The plan file may exist from a prior discussion/context step with only headings
-    // but no tasks. Without this check the artifact is considered "complete" and the
-    // unit gets skipped — but deriveState still returns phase:"planning" because the
-    // plan has no tasks, creating an infinite skip loop (#699).
-    if (unitType === "plan-slice") {
-        const planContent = readFileSync(absPath, "utf-8");
-        // Accept checkbox-style (- [x] **T01: ...) or heading-style (### T01 -- / ### T01: / ### T01 —)
-        const hasCheckboxTask = /^- \[[xX ]\] \*\*T\d+:/m.test(planContent);
-        const hasHeadingTask = /^#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
-        if (!hasCheckboxTask && !hasHeadingTask) {
-            logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
-            return false;
-        }
-    }
-    // execute-task: DB status is authoritative. Fall back to checked-checkbox
-    // detection when the DB is unavailable (unmigrated projects), or when the
-    // disk artifacts already reflect completion but the DB replay is one beat
-    // behind the completion write.
-    if (unitType === "execute-task") {
-        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-        if (mid && sid && tid) {
-            const dbTask = getTask(mid, sid, tid);
-            if (dbTask) {
-                if (dbTask.status !== "complete" && dbTask.status !== "done" && !hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) {
-                    return false;
-                }
-            }
-            else if (!isDbAvailable()) {
-                // LEGACY: Pre-migration fallback for projects without DB.
-                // Require a CHECKED checkbox — a bare heading or unchecked checkbox
-                // does not prove gsd_complete_task ran. Summary file on disk alone
-                // is not sufficient evidence (could be a rogue write) (#3607).
-                if (!hasCheckedTaskCompletionOnDisk(base, mid, sid, tid))
-                    return false;
-            }
-            else {
-                // DB available but task row not found — completion tool never ran (#3607)
-                return false;
-            }
-        }
-    }
-    // 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).
+    // plan-slice verification is DB-primary. The slice plan is a projection, so
+    // DB task rows prove the slice was planned even if the rendered markdown no
+    // longer uses legacy checkbox/heading syntax.
     if (unitType === "plan-slice") {
         const { milestone: mid, slice: sid } = parseUnitId(unitId);
         if (mid && sid) {
             try {
-                // DB primary path — get task IDs to verify task plan files exist
                 let taskIds = null;
                 if (isDbAvailable()) {
-                    const tasks = getSliceTasks(mid, sid);
-                    if (tasks.length > 0)
-                        taskIds = tasks.map(t => t.id);
+                    const refreshed = refreshOpenDatabaseFromDisk();
+                    if (refreshed) {
+                        const tasks = getSliceTasks(mid, sid);
+                        if (tasks.length > 0)
+                            taskIds = tasks.map(t => t.id);
+                    }
                 }
                 if (!taskIds) {
-                    // LEGACY: DB unavailable or no tasks in DB — parse plan file for task IDs
+                    // LEGACY: DB unavailable or no tasks in DB. Require actual task
+                    // entries so an empty scaffold cannot advance the pipeline (#699).
                     const planContent = readFileSync(absPath, "utf-8");
+                    const hasCheckboxTask = /^\s*- \[[xX ]\] \*\*T\d+:/m.test(planContent);
+                    const hasHeadingTask = /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
+                    if (!hasCheckboxTask && !hasHeadingTask) {
+                        logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
+                        return false;
+                    }
                     const plan = parseLegacyPlan(planContent);
                     if (plan.tasks.length > 0)
                         taskIds = plan.tasks.map((t) => t.id);
@@ -580,6 +707,33 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             }
         }
     }
+    // execute-task: DB status is authoritative. Fall back to checked-checkbox
+    // detection when the DB is unavailable (unmigrated projects), or when the
+    // disk artifacts already reflect completion but the DB replay is one beat
+    // behind the completion write.
+    if (unitType === "execute-task") {
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+        if (mid && sid && tid) {
+            const dbTask = getTask(mid, sid, tid);
+            if (dbTask) {
+                if (dbTask.status !== "complete" && dbTask.status !== "done" && !hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) {
+                    return false;
+                }
+            }
+            else if (!isDbAvailable()) {
+                // LEGACY: Pre-migration fallback for projects without DB.
+                // Require a CHECKED checkbox — a bare heading or unchecked checkbox
+                // does not prove gsd_complete_task ran. Summary file on disk alone
+                // is not sufficient evidence (could be a rogue write) (#3607).
+                if (!hasCheckedTaskCompletionOnDisk(base, mid, sid, tid))
+                    return false;
+            }
+            else {
+                // DB available but task row not found — completion tool never ran (#3607)
+                return false;
+            }
+        }
+    }
     // complete-slice: DB status is authoritative for whether the slice is done.
     // Fall back to file-based check (roadmap [x]) when DB is unavailable.
     if (unitType === "complete-slice") {

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -3,11 +3,15 @@ import { AutoSession } from "./auto/session.js";
 import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationError, markToolEnd as markTrackedToolEnd, markToolStart as markTrackedToolStart, } from "./auto-tool-tracking.js";
 export const autoSession = new AutoSession();
 export function getAutoRuntimeSnapshot() {
+    const orchestrationStatus = autoSession.orchestration?.getStatus();
     return {
         active: autoSession.active,
         paused: autoSession.paused,
         currentUnit: autoSession.currentUnit ? { ...autoSession.currentUnit } : null,
         basePath: autoSession.basePath,
+        orchestrationPhase: orchestrationStatus?.phase,
+        orchestrationTransitionCount: orchestrationStatus?.transitionCount,
+        orchestrationLastTransitionAt: orchestrationStatus?.lastTransitionAt,
     };
 }
 export function isAutoActive() {

package/dist/resources/extensions/gsd/auto-start.js

@@ -486,9 +486,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             // Clear survivor flag — finalization is done
             hasSurvivorBranch = false;
         }
-        const deepProjectStagePending = !hasSurvivorBranch
-            ? (await import("./auto-dispatch.js")).hasPendingDeepStage(loadEffectiveGSDPreferences(base)?.preferences, base)
-            : false;
+        const effectivePrefs = loadEffectiveGSDPreferences(base)?.preferences;
+        const { shouldRunDeepProjectSetup } = await import("./auto-dispatch.js");
+        const deepProjectStagePending = shouldRunDeepProjectSetup(state, effectivePrefs, base, { hasSurvivorBranch });
         if (deepProjectStagePending) {
             // Deep project-level setup runs before the first milestone exists. Let
             // the auto loop dispatch workflow-preferences / project / requirements
@@ -526,7 +526,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 const mid = state.activeMilestone.id;
                 const contextFile = resolveMilestoneFile(base, mid, "CONTEXT");
                 const hasContext = !!(contextFile && (await loadFile(contextFile)));
-                if (!hasContext) {
+                if (!hasContext && effectivePrefs?.planning_depth !== "deep") {
                     const { showSmartEntry } = await import("./guided-flow.js");
                     await showSmartEntry(ctx, pi, base, { step: requestedStepMode });
                     // showSmartEntry dispatches via pi.sendMessage() which is fire-and-forget:

package/dist/resources/extensions/gsd/auto-verification.js

@@ -1,14 +1,5 @@
-/**
- * Post-unit verification gate for auto-mode.
- *
- * Runs typecheck/lint/test checks, captures runtime errors, performs
- * dependency audits, handles auto-fix retry logic, and writes
- * verification evidence JSON.
- *
- * Extracted from the pre-loop agent_end handler in auto.ts. Returns a
- * sentinel value instead of calling return/pauseAuto directly — the
- * caller checks the result and handles control flow.
- */
+// Project/App: GSD-2
+// File Purpose: Post-unit verification gate for GSD auto-mode units.
 import { mkdirSync, writeFileSync } from "node:fs";
 import { resolveSlicePath, resolveMilestoneFile } from "./paths.js";
 import { parseUnitId } from "./unit-id.js";

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-mode worktree lifecycle, merge, and cleanup management.
 /**
  * GSD Auto-Worktree -- lifecycle management for auto-mode worktrees.
  *
@@ -6,7 +8,7 @@
  * manages create, enter, detect, and teardown for auto-mode worktrees.
  */
 import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync, rmSync, unlinkSync, statSync, lstatSync as lstatSyncFn, } from "node:fs";
-import { isAbsolute, join, sep as pathSep } from "node:path";
+import { isAbsolute, join, relative, sep as pathSep } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import { reconcileWorktreeDb, isDbAvailable, getMilestone, getMilestoneSlices, closeDatabase, openDatabase, getDbPath, } from "./gsd-db.js";
 import { execFileSync } from "node:child_process";
@@ -15,7 +17,8 @@ import { gsdRoot, resolveGsdPathContract } from "./paths.js";
 import { createWorktree, removeWorktree, resolveGitDir, worktreePath, isInsideWorktreesDir, } from "./worktree-manager.js";
 import { detectWorktreeName, nudgeGitBranchCache, } from "./worktree.js";
 import { isGsdWorktreePath, normalizeWorktreePathForCompare, resolveWorktreeProjectRoot, } from "./worktree-root.js";
-import { MergeConflictError, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
+import { MergeConflictError, createDraftPR, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
+import { buildPrEvidence } from "./pr-evidence.js";
 import { debugLog } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -203,6 +206,41 @@ function setActiveWorkspace(ws) {
 function getActiveWorkspace() {
     return activeWorkspace;
 }
+function gitPathspecForWorktreePath(basePath, targetPath) {
+    let base = basePath;
+    let target = targetPath;
+    try {
+        base = realpathSync.native(basePath);
+    }
+    catch {
+        /* keep original */
+        void base;
+    }
+    try {
+        target = realpathSync.native(targetPath);
+    }
+    catch {
+        /* keep original */
+        void target;
+    }
+    const rel = relative(base, target);
+    if (rel === "" || rel.startsWith("..") || isAbsolute(rel))
+        return null;
+    return rel.replaceAll("\\", "/");
+}
+function gitRemoteExists(basePath, remote) {
+    try {
+        execFileSync("git", ["remote", "get-url", remote], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function clearProjectRootStateFiles(basePath, milestoneId) {
     const gsdDir = gsdRoot(basePath);
     // Phase C pt 2: auto.lock removed from this list — the file is gone
@@ -236,9 +274,12 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
     for (const dir of syncedDirs) {
         try {
             if (existsSync(dir)) {
+                const pathspec = gitPathspecForWorktreePath(basePath, dir);
+                if (!pathspec)
+                    continue;
                 // Only remove files that are untracked by git — tracked files are
                 // managed by the branch checkout and should not be deleted.
-                const untrackedOutput = execFileSync("git", ["ls-files", "--others", "--exclude-standard", dir], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+                const untrackedOutput = execFileSync("git", ["ls-files", "--others", "--exclude-standard", pathspec], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
                 if (untrackedOutput) {
                     for (const f of untrackedOutput.split("\n").filter(Boolean)) {
                         try {
@@ -1899,17 +1940,19 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     let pushed = false;
     if (prefs.auto_push === true && prefs.auto_pr !== true && !nothingToCommit) {
         const remote = prefs.remote ?? "origin";
-        try {
-            execFileSync("git", ["push", remote, mainBranch], {
-                cwd: originalBasePath_,
-                stdio: ["ignore", "pipe", "pipe"],
-                encoding: "utf-8",
-            });
-            pushed = true;
-        }
-        catch (err) {
-            // Push failure is non-fatal
-            logWarning("worktree", `git push failed: ${err instanceof Error ? err.message : String(err)}`);
+        if (gitRemoteExists(originalBasePath_, remote)) {
+            try {
+                execFileSync("git", ["push", remote, mainBranch], {
+                    cwd: originalBasePath_,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    encoding: "utf-8",
+                });
+                pushed = true;
+            }
+            catch (err) {
+                // Push failure is non-fatal
+                logWarning("worktree", `git push failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     // 9b. Auto-create PR if enabled (#2302: no longer gated on pushed/auto_push)
@@ -1917,30 +1960,36 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     if (prefs.auto_pr === true && !nothingToCommit) {
         const remote = prefs.remote ?? "origin";
         const prTarget = prefs.pr_target_branch ?? mainBranch;
-        try {
-            // Push the milestone branch to remote first
-            execFileSync("git", ["push", remote, milestoneBranch], {
-                cwd: originalBasePath_,
-                stdio: ["ignore", "pipe", "pipe"],
-                encoding: "utf-8",
-            });
-            // Create PR via gh CLI with explicit --head and --base (#2302)
-            execFileSync("gh", [
-                "pr", "create", "--draft",
-                "--base", prTarget,
-                "--head", milestoneBranch,
-                "--title", `Milestone ${milestoneId} complete`,
-                "--body", "Auto-created by GSD on milestone completion.",
-            ], {
-                cwd: originalBasePath_,
-                stdio: ["ignore", "pipe", "pipe"],
-                encoding: "utf-8",
-            });
-            prCreated = true;
-        }
-        catch (err) {
-            // PR creation failure is non-fatal — gh may not be installed or authenticated
-            logWarning("worktree", `PR creation failed: ${err instanceof Error ? err.message : String(err)}`);
+        if (gitRemoteExists(originalBasePath_, remote)) {
+            try {
+                // Push the milestone branch to remote first
+                execFileSync("git", ["push", remote, milestoneBranch], {
+                    cwd: originalBasePath_,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    encoding: "utf-8",
+                });
+                const prEvidence = buildPrEvidence({
+                    milestoneId,
+                    milestoneTitle,
+                    changeType: "feat",
+                    summaries: completedSlices.map((slice) => `### ${slice.id}\n${slice.title}`),
+                    testsRun: ["Auto-created after milestone merge. Run `npm run verify:pr` before marking this draft ready."],
+                    rollbackNotes: ["Close the draft PR or revert the merge commit if review finds a behavior regression."],
+                    how: "Generated by git.auto_pr after the milestone branch was pushed and merged locally.",
+                });
+                const prUrl = createDraftPR(originalBasePath_, milestoneId, prEvidence.title, prEvidence.body, {
+                    head: milestoneBranch,
+                    base: prTarget,
+                });
+                if (!prUrl) {
+                    throw new Error("gh pr create returned no URL");
+                }
+                prCreated = true;
+            }
+            catch (err) {
+                // PR creation failure is non-fatal — gh may not be installed or authenticated
+                logWarning("worktree", `PR creation failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     // 11. Guard removed — step 9b (#1792) now handles this with a smarter check: