gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.710c06e97

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

@@ -219,6 +219,169 @@ export async function inlineFileSmart(absPath, relPath, label, query, threshold
     const truncated = truncateAtSectionBoundary(content, threshold).content;
     return `### ${label}\nSource: \`${relPath}\`\n\n${truncated}`;
 }
+function inlineCompactTemplate(name, label) {
+    const compact = {
+        plan: [
+            "# {{sliceId}}: {{sliceTitle}}",
+            "",
+            "**Goal:** {{goal}}",
+            "**Demo:** {{demo}}",
+            "",
+            "## Must-Haves",
+            "- {{mustHave}}",
+            "",
+            "## Threat Surface",
+            "- Abuse: {{abuseScenarios}}",
+            "- Data exposure: {{sensitiveDataAccessible}}",
+            "- Input trust: {{untrustedInput}}",
+            "",
+            "## Requirement Impact",
+            "- Requirements touched: {{requirementIds}}",
+            "- Re-verify: {{whatMustBeRetested}}",
+            "- Decisions revisited: {{decisionIds}}",
+            "",
+            "## Proof Level",
+            "- This slice proves: {{contract | integration | operational | final-assembly}}",
+            "- Real runtime required: {{yes/no}}",
+            "- Human/UAT required: {{yes/no}}",
+            "",
+            "## Verification",
+            "- {{testFileOrCommand}}",
+            "",
+            "## Observability / Diagnostics",
+            "- Runtime signals: {{signalOrNone}}",
+            "- Inspection surfaces: {{surfaceOrNone}}",
+            "- Failure visibility: {{failureSignalOrNone}}",
+            "- Redaction constraints: {{secretOrPiiBoundaryOrNone}}",
+            "",
+            "## Integration Closure",
+            "- Upstream surfaces consumed: {{filesModulesContracts}}",
+            "- New wiring introduced: {{entrypointOrNone}}",
+            "- Remaining end-to-end work: {{listOrNothing}}",
+            "",
+            "## Tasks",
+            "- [ ] **T01: {{taskTitle}}** `est:{{estimate}}`",
+            "  - Why: {{whyThisTaskExists}}",
+            "  - Files: `{{filePath}}`",
+            "  - Do: {{specificImplementationStepsAndConstraints}}",
+            "  - Verify: {{testCommandOrRuntimeCheck}}",
+            "  - Done when: {{measurableAcceptanceCondition}}",
+            "",
+            "## Files Likely Touched",
+            "- `{{filePath}}`",
+        ].join("\n"),
+        "task-summary": [
+            "---",
+            "id: {{taskId}}",
+            "parent: {{sliceId}}",
+            "milestone: {{milestoneId}}",
+            "provides: [{{whatThisTaskProvides}}]",
+            "key_files: [{{filePath}}]",
+            "key_decisions: [{{decision}}]",
+            "patterns_established: [{{pattern}}]",
+            "observability_surfaces: [{{diagnosticOrNone}}]",
+            "duration: {{duration}}",
+            "verification_result: passed",
+            "completed_at: {{date}}",
+            "blocker_discovered: false",
+            "---",
+            "",
+            "# {{taskId}}: {{taskTitle}}",
+            "**{{oneLiner}}**",
+            "",
+            "## What Happened",
+            "{{narrative}}",
+            "",
+            "## Verification",
+            "{{whatWasVerifiedAndHow}}",
+            "",
+            "## Verification Evidence",
+            "| # | Command | Exit Code | Verdict | Duration |",
+            "|---|---------|-----------|---------|----------|",
+            "| {{row}} | {{command}} | {{exitCode}} | {{verdict}} | {{duration}} |",
+            "",
+            "## Diagnostics",
+            "{{diagnosticsOrNone}}",
+            "",
+            "## Deviations",
+            "{{deviationsFromPlan_OR_none}}",
+            "",
+            "## Known Issues",
+            "{{issuesDiscoveredButNotFixed_OR_none}}",
+            "",
+            "## Files Created/Modified",
+            "- `{{filePath}}` - {{description}}",
+        ].join("\n"),
+        "slice-summary": [
+            "---",
+            "id: {{sliceId}}",
+            "parent: {{milestoneId}}",
+            "milestone: {{milestoneId}}",
+            "provides: [{{whatThisSliceProvides}}]",
+            "requires: []",
+            "affects: []",
+            "key_files: [{{filePath}}]",
+            "key_decisions: [{{decision}}]",
+            "patterns_established: [{{pattern}}]",
+            "observability_surfaces: [{{diagnosticOrNone}}]",
+            "drill_down_paths: [{{pathToTaskSummary}}]",
+            "duration: {{duration}}",
+            "verification_result: passed",
+            "completed_at: {{date}}",
+            "---",
+            "",
+            "# {{sliceId}}: {{sliceTitle}}",
+            "**{{oneLiner}}**",
+            "",
+            "## What Happened",
+            "{{narrative}}",
+            "",
+            "## Verification",
+            "{{whatWasVerifiedAcrossAllTasks}}",
+            "",
+            "## Requirements Advanced",
+            "- {{requirementId}} - {{howThisSliceAdvancedIt}}",
+            "",
+            "## Requirements Validated",
+            "- {{requirementId}} - {{whatProofNowMakesItValidated}}",
+            "",
+            "## New Requirements Surfaced",
+            "- {{newRequirementOr_none}}",
+            "",
+            "## Requirements Invalidated or Re-scoped",
+            "- {{requirementIdOr_none}} - {{whatChanged}}",
+            "",
+            "## Operational Readiness",
+            "- Health signal: {{healthSignalOrNA}}",
+            "- Failure signal: {{failureSignalOrNA}}",
+            "- Recovery: {{recoveryOrNA}}",
+            "- Monitoring gaps: {{gapsOrNone}}",
+            "",
+            "## Deviations",
+            "{{deviationsFromPlan_OR_none}}",
+            "",
+            "## Known Limitations",
+            "{{whatDoesntWorkYet_OR_whatWasDeferredToLaterSlices}}",
+            "",
+            "## Follow-ups",
+            "{{workDeferredOrDiscoveredDuringExecution_OR_none}}",
+            "",
+            "## Files Created/Modified",
+            "- `{{filePath}}` - {{description}}",
+            "",
+            "## Forward Intelligence",
+            "### What the next slice should know",
+            "- {{insightThatWouldHelpDownstreamWork}}",
+            "### What's fragile",
+            "- {{fragileAreaOrThinImplementation}} - {{whyItMatters}}",
+            "### Authoritative diagnostics",
+            "- {{whereAFutureAgentShouldLookFirst}} - {{whyThisSignalIsTrustworthy}}",
+            "### What assumptions changed",
+            "- {{originalAssumption}} - {{whatActuallyHappened}}",
+        ].join("\n"),
+    };
+    return `${compact[name]}\n\n### Output Template: ${label}\nSource: \`templates/${name}.md\``;
+}
 /**
  * Compact slice-summary excerpt for milestone-level closers (#4780).
  *
@@ -1493,7 +1656,7 @@ async function renderSlicePrompt(options) {
     const graphBlock = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
     if (graphBlock)
         inlined.push(graphBlock);
-    inlined.push(inlineTemplate("plan", "Slice Plan"));
+    inlined.push(level === "minimal" ? inlineCompactTemplate("plan", "Slice Plan") : inlineTemplate("plan", "Slice Plan"));
     if (level === "full") {
         inlined.push(inlineTemplate("task-plan", "Task Plan"));
     }
@@ -1648,7 +1811,7 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     // Knowledge graph: tight subgraph for this task (graceful — skipped if no graph.json)
     const graphBlockET = await inlineGraphSubgraph(base, `${tid} ${tTitle}`, { budget: 2000 });
     const inlinedTemplates = inlineLevel === "minimal"
-        ? inlineTemplate("task-summary", "Task Summary")
+        ? inlineCompactTemplate("task-summary", "Task Summary")
         : [
             inlineTemplate("task-summary", "Task Summary"),
             inlineTemplate("decisions", "Decisions"),
@@ -1782,7 +1945,9 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
                 return blocks.length > 0 ? blocks.join("\n\n---\n\n") : null;
             }
             case "templates": {
-                const parts = [inlineTemplate("slice-summary", "Slice Summary")];
+                const parts = [inlineLevel === "minimal"
+                        ? inlineCompactTemplate("slice-summary", "Slice Summary")
+                        : inlineTemplate("slice-summary", "Slice Summary")];
                 if (inlineLevel !== "minimal") {
                     parts.push(inlineTemplate("uat", "UAT"));
                 }

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 } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -120,7 +120,22 @@ export function hasImplementationArtifacts(basePath, milestoneId) {
                 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 tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
+            if (!tagged.ok)
+                return "unknown";
+            if (tagged.matched)
+                return classifyImplementationFiles(tagged.files);
+        }
+        return "absent";
     }
     catch (e) {
         // Non-fatal — if git operations fail, return unknown so callers can decide
@@ -217,7 +232,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 +243,18 @@ 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 scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
     try {
@@ -510,66 +534,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);
@@ -595,6 +585,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-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: