gsd-pi 2.73.1 → 2.74.0-dev.b741afb

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -67,6 +67,7 @@ const LIFECYCLE_ONLY_UNITS = new Set([
     "replan-slice", "complete-slice", "run-uat",
     "reassess-roadmap", "rewrite-docs",
 ]);
+import { describeNextUnit, } from "./auto-dashboard.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
@@ -179,6 +180,66 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
     }
     return rogues;
 }
+export const STEP_COMPLETE_FALLBACK_MESSAGE = "Step complete. Run /clear, then /gsd to continue (or /gsd auto to run continuously).";
+export function buildStepCompleteMessage(nextState) {
+    if (nextState.phase === "complete") {
+        return "Step complete — milestone finished. Run /gsd status to review, or start the next milestone.";
+    }
+    const next = describeNextUnit(nextState);
+    return `Step complete. Next: ${next.label}\n`
+        + `Run /clear, then /gsd to continue (or /gsd auto to run continuously).`;
+}
+export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
+    try {
+        let taskContext;
+        if (unitType === "execute-task") {
+            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+            if (mid && sid && tid) {
+                const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+                if (summaryPath) {
+                    try {
+                        const summaryContent = await loadFile(summaryPath);
+                        if (summaryContent) {
+                            const summary = parseSummary(summaryContent);
+                            let ghIssueNumber;
+                            try {
+                                const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+                                ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
+                            }
+                            catch (err) {
+                                logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+                            }
+                            taskContext = {
+                                taskId: `${sid}/${tid}`,
+                                taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
+                                oneLiner: summary.oneLiner || undefined,
+                                keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                                issueNumber: ghIssueNumber,
+                            };
+                        }
+                    }
+                    catch (e) {
+                        debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
+                    }
+                }
+            }
+        }
+        _resetHasChangesCache();
+        if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
+            return null;
+        }
+        const commitMsg = autoCommitCurrentBranch(basePath, unitType, unitId, taskContext);
+        if (commitMsg) {
+            ctx?.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
+        }
+        return commitMsg;
+    }
+    catch (e) {
+        debugLog("postUnit", { phase: "auto-commit", error: String(e) });
+        ctx?.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
+        return null;
+    }
+}
 /**
  * Pre-verification processing: parallel worker signal check, cache invalidation,
  * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
@@ -214,62 +275,7 @@ export async function postUnitPreVerification(pctx, opts) {
     // Auto-commit
     if (s.currentUnit) {
         const unit = s.currentUnit;
-        try {
-            let taskContext;
-            if (s.currentUnit.type === "execute-task") {
-                const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
-                if (mid && sid && tid) {
-                    const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
-                    if (summaryPath) {
-                        try {
-                            const summaryContent = await loadFile(summaryPath);
-                            if (summaryContent) {
-                                const summary = parseSummary(summaryContent);
-                                // Look up GitHub issue number for commit linking
-                                let ghIssueNumber;
-                                try {
-                                    const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
-                                    ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
-                                }
-                                catch (err) {
-                                    // GitHub sync not available — skip
-                                    logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-                                }
-                                taskContext = {
-                                    taskId: `${sid}/${tid}`,
-                                    taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
-                                    oneLiner: summary.oneLiner || undefined,
-                                    keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
-                                    issueNumber: ghIssueNumber,
-                                };
-                            }
-                        }
-                        catch (e) {
-                            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-                        }
-                    }
-                }
-            }
-            // Invalidate the nativeHasChanges cache before auto-commit (#1853).
-            // The cache has a 10-second TTL and is keyed by basePath.  A stale
-            // `false` result causes autoCommit to skip staging entirely, leaving
-            // code files only in the working tree where they are destroyed by
-            // `git worktree remove --force` during teardown.
-            _resetHasChangesCache();
-            // Skip auto-commit for lifecycle-only units (#2553) — they only touch
-            // `.gsd/` internal state files. Those files are picked up by the next
-            // actual task commit via smartStage().
-            if (!LIFECYCLE_ONLY_UNITS.has(s.currentUnit.type)) {
-                const commitMsg = autoCommitCurrentBranch(s.basePath, s.currentUnit.type, s.currentUnit.id, taskContext);
-                if (commitMsg) {
-                    ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
-                }
-            }
-        }
-        catch (e) {
-            debugLog("postUnit", { phase: "auto-commit", error: String(e) });
-            ctx.ui.notify(`Auto-commit failed: ${String(e).split("\n")[0]}`, "warning");
-        }
+        await autoCommitUnit(s.basePath, unit.type, unit.id, ctx);
         // GitHub sync (non-blocking, opt-in)
         await runSafely("postUnit", "github-sync", async () => {
             const { runGitHubSync } = await import("../github-sync/sync.js");
@@ -509,6 +515,26 @@ export async function postUnitPreVerification(pctx, opts) {
                     const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
                     s.verificationRetryCount.set(retryKey, attempt);
                     if (attempt > MAX_VERIFICATION_RETRIES) {
+                        // #4175: For complete-milestone, a blocker placeholder is harmful —
+                        // the stub SUMMARY has no recovery value (milestone is terminal),
+                        // it does not update DB status (so deriveState never advances),
+                        // and it fools stopAuto's presence check into merging a milestone
+                        // that was never legitimately completed. Pause auto-mode with a
+                        // clear single failure signal and preserve the worktree branch.
+                        if (s.currentUnit.type === "complete-milestone") {
+                            debugLog("postUnit", {
+                                phase: "artifact-verify-pause-complete-milestone",
+                                unitType: s.currentUnit.type,
+                                unitId: s.currentUnit.id,
+                                attempt,
+                                maxRetries: MAX_VERIFICATION_RETRIES,
+                            });
+                            s.verificationRetryCount.delete(retryKey);
+                            s.pendingVerificationRetry = null;
+                            ctx.ui.notify(`Milestone ${s.currentUnit.id} verification failed after ${MAX_VERIFICATION_RETRIES} retries — worktree branch preserved. Re-run /gsd auto once blockers are resolved.`, "error");
+                            await pauseAuto(ctx, pi);
+                            return "dispatched";
+                        }
                         // Retries exhausted — write a blocker placeholder so the pipeline
                         // can advance past this stuck unit (#2653).
                         debugLog("postUnit", {
@@ -836,8 +862,18 @@ export async function postUnitPostVerification(pctx) {
             debugLog("postUnit", { phase: "quick-task-dispatch", error: String(e) });
         }
     }
-    // Step mode → show wizard instead of dispatch
+    // Step mode → show wizard instead of dispatch.
+    // Without this notify(), /gsd in step mode finishes a unit and silently
+    // exits the loop, leaving the user with no hint to /clear and /gsd again.
     if (s.stepMode) {
+        try {
+            const nextState = await deriveState(s.basePath);
+            ctx.ui.notify(buildStepCompleteMessage(nextState), "info");
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "step-wizard-notify", error: String(e) });
+            ctx.ui.notify(STEP_COMPLETE_FALLBACK_MESSAGE, "info");
+        }
         return "step-wizard";
     }
     return "continue";

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

@@ -20,6 +20,7 @@ import { assertGateCoverage, getGatesForTurn, } from "./gate-registry.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
 import { logWarning } from "./workflow-logger.js";
+import { inlineGraphSubgraph } from "./graph-context.js";
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 const MAX_PREAMBLE_CHARS = 30_000;
 function capPreamble(preamble) {
@@ -1040,6 +1041,10 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
     const knowledgeInlineRS = await inlineKnowledgeScoped(base, keywords);
     if (knowledgeInlineRS)
         inlined.push(knowledgeInlineRS);
+    // Knowledge graph: subgraph for this slice (graceful — skipped if no graph.json)
+    const graphBlockRS = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
+    if (graphBlockRS)
+        inlined.push(graphBlockRS);
     inlined.push(inlineTemplate("research", "Research"));
     const depContent = await inlineDependencySummaries(mid, sid, base);
     const activeOverrides = await loadActiveOverrides(base);
@@ -1111,6 +1116,10 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     const knowledgeInlinePS = await inlineKnowledgeScoped(base, keywordsPS);
     if (knowledgeInlinePS)
         inlined.push(knowledgeInlinePS);
+    // Knowledge graph: subgraph for this slice (graceful — skipped if no graph.json)
+    const graphBlockPS = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
+    if (graphBlockPS)
+        inlined.push(graphBlockPS);
     inlined.push(inlineTemplate("plan", "Slice Plan"));
     if (inlineLevel === "full") {
         inlined.push(inlineTemplate("task-plan", "Task Plan"));
@@ -1194,12 +1203,15 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         : null;
     // Only include if it has content (not a "not found" result)
     const knowledgeContent = knowledgeInlineET && !knowledgeInlineET.includes("not found") ? knowledgeInlineET : null;
+    // 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")
         : [
             inlineTemplate("task-summary", "Task Summary"),
             inlineTemplate("decisions", "Decisions"),
             ...(knowledgeContent ? [knowledgeContent] : []),
+            ...(graphBlockET ? [graphBlockET] : []),
         ].join("\n\n---\n\n");
     const taskSummaryPath = join(base, `${relSlicePath(base, mid, sid)}/tasks/${tid}-SUMMARY.md`);
     const activeOverrides = await loadActiveOverrides(base);

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

@@ -38,7 +38,7 @@ import { existsSync, mkdirSync, readdirSync, rmSync, statSync, unlinkSync, } fro
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
 import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
-import { resolveDefaultSessionModel, resolveDynamicRoutingConfig } from "./preferences-models.js";
+import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
 import { getSessionModelOverride } from "./session-model-override.js";
 /**
  * Bootstrap a fresh auto-mode session. Handles everything from git init
@@ -195,8 +195,18 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
     //
     // This preserves #3517 defaults while honoring explicit runtime model
     // selection for subsequent /gsd runs in the same session.
+    //
+    // Exception (#4122): when the session provider is a custom provider declared
+    // in ~/.gsd/agent/models.json (Ollama, vLLM, OpenAI-compatible proxy, etc.),
+    // PREFERENCES.md is skipped entirely. PREFERENCES.md cannot reference custom
+    // providers, so honoring it would silently reroute auto-mode to a built-in
+    // provider the user is not logged into and surface as "Not logged in · Please
+    // run /login" before pausing and resetting to claude-code/claude-sonnet-4-6.
     const manualSessionOverride = getSessionModelOverride(ctx.sessionManager.getSessionId());
-    const preferredModel = resolveDefaultSessionModel(ctx.model?.provider);
+    const sessionProviderIsCustom = isCustomProvider(ctx.model?.provider);
+    const preferredModel = sessionProviderIsCustom
+        ? null
+        : resolveDefaultSessionModel(ctx.model?.provider);
     // Validate the preferred model against the live registry + provider auth so
     // an unconfigured PREFERENCES.md entry (no API key / OAuth) can't become the
     // start-model snapshot. Without this, every subsequent unit would try to
@@ -622,6 +632,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         }
         ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
         ctx.ui.setFooter(hideFooter);
+        // Hide gsd-health during AUTO — gsd-progress is the single source of truth
+        // for last-commit / cost / health signal while auto is running.
+        ctx.ui.setWidget("gsd-health", undefined);
         const modeLabel = s.stepMode ? "Step-mode" : "Auto-mode";
         const pendingCount = (state.registry ?? []).filter((m) => m.status !== "complete" && m.status !== "parked").length;
         const scopeMsg = pendingCount > 1
@@ -636,12 +649,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         const startModelLabel = s.autoModeStartModel
             ? `${s.autoModeStartModel.provider}/${s.autoModeStartModel.id}`
             : ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "default";
-        // Flat-rate providers (e.g. GitHub Copilot, claude-code) suppress routing
-        // at dispatch time (#3453) — reflect that in the banner.
-        const { isFlatRateProvider } = await import("./auto-model-selection.js");
+        // Flat-rate providers (e.g. GitHub Copilot, claude-code, user-declared
+        // subscription proxies, externalCli CLIs) suppress routing at dispatch
+        // time (#3453) — reflect that in the banner.  Thread the same
+        // FlatRateContext used by selectAndApplyModel so user-declared
+        // flat-rate providers and externalCli auto-detection are respected.
+        const { isFlatRateProvider, buildFlatRateContext } = await import("./auto-model-selection.js");
+        const bannerPrefs = loadEffectiveGSDPreferences()?.preferences;
         const effectiveProvider = s.autoModeStartModel?.provider ?? ctx.model?.provider;
         const effectivelyEnabled = routingConfig.enabled
-            && !(effectiveProvider && isFlatRateProvider(effectiveProvider));
+            && !(effectiveProvider && isFlatRateProvider(effectiveProvider, buildFlatRateContext(effectiveProvider, ctx, bannerPrefs)));
         // The actual ceiling may come from tier_models.heavy, not the start model.
         const effectiveCeiling = (routingConfig.enabled && routingConfig.tier_models?.heavy)
             ? routingConfig.tier_models.heavy

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

@@ -156,6 +156,19 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
         ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: steering ${unitType} ${unitId} to produce ${expected} (attempt ${attemptNumber}, session ${recoveryAttempts + 1}/${maxRecoveryAttempts}).`, "warning");
         return "recovered";
     }
+    // #4175: For complete-milestone, never write a blocker placeholder — a stub
+    // SUMMARY has no recovery value (milestone is terminal), it does not update
+    // DB status, and downstream merge paths can treat the stub as a legitimate
+    // completion signal. Pause instead so the worktree branch is preserved.
+    if (unitType === "complete-milestone") {
+        writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
+            phase: "paused",
+            recoveryAttempts: recoveryAttempts + 1,
+            lastRecoveryReason: reason,
+        });
+        ctx.ui.notify(`Milestone ${unitId} ${reason}-recovery exhausted ${maxRecoveryAttempts} attempt(s) — worktree branch preserved. Re-run /gsd auto once blockers are resolved.`, "error");
+        return "paused";
+    }
     // Retries exhausted — write a blocker placeholder and advance the pipeline
     // instead of silently stalling.
     const placeholder = writeBlockerPlaceholder(unitType, unitId, basePath, `${reason} recovery exhausted ${maxRecoveryAttempts} attempts without producing the artifact.`);

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

@@ -10,10 +10,15 @@
  * checks the result and handles control flow.
  */
 import { mkdirSync, writeFileSync } from "node:fs";
-import { resolveSlicePath } from "./paths.js";
+import { resolveSlicePath, resolveMilestoneFile } from "./paths.js";
 import { parseUnitId } from "./unit-id.js";
-import { isDbAvailable, getTask, getSliceTasks } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSliceTasks, getMilestoneSlices } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { extractVerdict } from "./verdict-parser.js";
+import { isClosedStatus } from "./status-guards.js";
+import { loadFile } from "./files.js";
+import { parseRoadmap } from "./parsers-legacy.js";
+import { isMilestoneComplete } from "./state.js";
 import { runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
 import { logWarning } from "./workflow-logger.js";
@@ -22,6 +27,80 @@ import { join } from "node:path";
 function isInfraVerificationFailure(stderr) {
     return /\b(ENOENT|ENOTFOUND|ETIMEDOUT|ECONNRESET|EAI_AGAIN|spawn\s+\S+\s+ENOENT|command not found)\b/i.test(stderr);
 }
+/**
+ * Post-unit guard for `validate-milestone` units (#4094).
+ *
+ * When validate-milestone writes verdict=needs-remediation, the agent is
+ * expected to also call gsd_reassess_roadmap in the same turn to add
+ * remediation slices. If they don't, the state machine re-derives
+ * `phase: validating-milestone` indefinitely (all slices still complete +
+ * verdict still needs-remediation), wasting ~3 dispatches before the stuck
+ * detector fires.
+ *
+ * This guard fires immediately on the first occurrence: if VALIDATION.md
+ * verdict is needs-remediation and no incomplete slices exist for the
+ * milestone, pause the auto-loop with a clear blocker.
+ */
+async function runValidateMilestonePostCheck(vctx, pauseAuto) {
+    const { s, ctx, pi } = vctx;
+    if (!s.currentUnit)
+        return "continue";
+    const { milestone: mid } = parseUnitId(s.currentUnit.id);
+    if (!mid)
+        return "continue";
+    const validationFile = resolveMilestoneFile(s.basePath, mid, "VALIDATION");
+    if (!validationFile)
+        return "continue";
+    const validationContent = await loadFile(validationFile);
+    if (!validationContent)
+        return "continue";
+    const verdict = extractVerdict(validationContent);
+    if (verdict !== "needs-remediation")
+        return "continue";
+    const incompleteSliceCount = await countIncompleteSlices(s.basePath, mid);
+    // If any non-closed slices exist, the agent successfully queued remediation
+    // work — proceed normally. The state machine will execute those slices and
+    // re-validate per the #3596/#3670 fix.
+    if (incompleteSliceCount > 0)
+        return "continue";
+    ctx.ui.notify(`Milestone ${mid} validation returned verdict=needs-remediation but no remediation slices were added. Pausing for human review.`, "error");
+    process.stderr.write(`validate-milestone: pausing — verdict=needs-remediation with no incomplete slices for ${mid}. ` +
+        `The agent must call gsd_reassess_roadmap to add remediation slices before re-validation.\n`);
+    await pauseAuto(ctx, pi);
+    return "pause";
+}
+/**
+ * Count slices for a milestone that are not in a closed status.
+ * DB-backed projects are authoritative (#4094 peer review); falls back to
+ * roadmap parsing only when the DB is unavailable.
+ */
+async function countIncompleteSlices(basePath, milestoneId) {
+    if (isDbAvailable()) {
+        const slices = getMilestoneSlices(milestoneId);
+        if (slices.length === 0) {
+            // No DB rows — treat as "unknown", do not pause.
+            return 1;
+        }
+        return slices.filter((slice) => !isClosedStatus(slice.status)).length;
+    }
+    // Filesystem fallback: parse the roadmap markdown.
+    try {
+        const roadmapFile = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+        if (!roadmapFile)
+            return 1;
+        const roadmapContent = await loadFile(roadmapFile);
+        if (!roadmapContent)
+            return 1;
+        const roadmap = parseRoadmap(roadmapContent);
+        if (roadmap.slices.length === 0)
+            return 1;
+        return isMilestoneComplete(roadmap) ? 0 : 1;
+    }
+    catch {
+        // Parsing failures should not cause false-positive pauses.
+        return 1;
+    }
+}
 /**
  * Run the verification gate for the current execute-task unit.
  * Returns:
@@ -31,7 +110,13 @@ function isInfraVerificationFailure(stderr) {
  */
 export async function runPostUnitVerification(vctx, pauseAuto) {
     const { s, ctx, pi } = vctx;
-    if (!s.currentUnit || s.currentUnit.type !== "execute-task") {
+    if (!s.currentUnit) {
+        return "continue";
+    }
+    if (s.currentUnit.type === "validate-milestone") {
+        return await runValidateMilestonePostCheck(vctx, pauseAuto);
+    }
+    if (s.currentUnit.type !== "execute-task") {
         return "continue";
     }
     try {

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

@@ -36,7 +36,7 @@ import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { deactivateGSD } from "../shared/gsd-phase-state.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
-import { logWarning } from "./workflow-logger.js";
+import { setLogBasePath, logWarning } from "./workflow-logger.js";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -55,14 +55,15 @@ import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
 import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, hideFooter, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
-import { isDbAvailable } from "./gsd-db.js";
+import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { countPendingCaptures } from "./captures.js";
 import { clearCmuxSidebar, logCmuxEvent, syncCmuxSidebar } from "../cmux/index.js";
 // ── Extracted modules ──────────────────────────────────────────────────────
 import { startUnitSupervision } from "./auto-timers.js";
 import { runPostUnitVerification } from "./auto-verification.js";
-import { postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
+import { autoCommitUnit, postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
 import { bootstrapAutoSession, openProjectDbIfPresent } from "./auto-start.js";
+import { initHealthWidget } from "./health-widget.js";
 import { autoLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto-loop.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
@@ -397,6 +398,8 @@ function handleLostSessionLock(ctx, lockStatus) {
     ctx?.ui.setStatus("gsd-auto", undefined);
     ctx?.ui.setWidget("gsd-progress", undefined);
     ctx?.ui.setFooter(undefined);
+    if (ctx)
+        initHealthWidget(ctx);
 }
 /**
  * Lightweight cleanup after autoLoop exits via step-wizard break.
@@ -431,6 +434,7 @@ function cleanupAfterLoopExit(ctx) {
         ctx.ui.setStatus("gsd-auto", undefined);
         ctx.ui.setWidget("gsd-progress", undefined);
         ctx.ui.setFooter(undefined);
+        initHealthWidget(ctx);
     }
     // Restore CWD out of worktree back to original project root
     if (s.originalBasePath) {
@@ -501,17 +505,30 @@ export async function stopAuto(ctx, pi, reason) {
                     ? { notify: ctx.ui.notify.bind(ctx.ui) }
                     : { notify: () => { } };
                 const resolver = buildResolver();
-                // Check if the milestone is complete — SUMMARY file is the authoritative signal.
+                // Check if the milestone is complete. DB status is the authoritative
+                // signal — only a successful gsd_complete_milestone call flips it to
+                // "complete" (tools/complete-milestone.ts). SUMMARY file presence is
+                // NOT sufficient: a blocker placeholder stub or a partial write can
+                // leave a file behind without the milestone actually being done,
+                // which previously caused stopAuto to merge a failed milestone and
+                // emit a misleading metadata-only merge warning (#4175).
+                // DB-unavailable projects fall back to SUMMARY-file presence.
                 let milestoneComplete = false;
                 try {
-                    const summaryPath = resolveMilestoneFile(s.originalBasePath || s.basePath, s.currentMilestoneId, "SUMMARY");
-                    if (!summaryPath) {
-                        // Also check in the worktree path (SUMMARY may not be synced yet)
-                        const wtSummaryPath = resolveMilestoneFile(s.basePath, s.currentMilestoneId, "SUMMARY");
-                        milestoneComplete = wtSummaryPath !== null;
+                    if (isDbAvailable()) {
+                        const dbRow = getMilestone(s.currentMilestoneId);
+                        milestoneComplete = dbRow?.status === "complete";
                     }
                     else {
-                        milestoneComplete = true;
+                        const summaryPath = resolveMilestoneFile(s.originalBasePath || s.basePath, s.currentMilestoneId, "SUMMARY");
+                        if (!summaryPath) {
+                            // Also check in the worktree path (SUMMARY may not be synced yet)
+                            const wtSummaryPath = resolveMilestoneFile(s.basePath, s.currentMilestoneId, "SUMMARY");
+                            milestoneComplete = wtSummaryPath !== null;
+                        }
+                        else {
+                            milestoneComplete = true;
+                        }
                     }
                 }
                 catch (err) {
@@ -676,6 +693,8 @@ export async function stopAuto(ctx, pi, reason) {
         ctx?.ui.setStatus("gsd-auto", undefined);
         ctx?.ui.setWidget("gsd-progress", undefined);
         ctx?.ui.setFooter(undefined);
+        if (ctx)
+            initHealthWidget(ctx);
         restoreProjectRootEnv();
         restoreMilestoneLockEnv();
         // Reset all session state in one call
@@ -762,6 +781,8 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     ctx?.ui.setStatus("gsd-auto", "paused");
     ctx?.ui.setWidget("gsd-progress", undefined);
     ctx?.ui.setFooter(undefined);
+    if (ctx)
+        initHealthWidget(ctx);
     const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
     ctx?.ui.notify(`${s.stepMode ? "Step" : "Auto"}-mode paused (Escape). Type to interact, or ${resumeCmd} to resume.`, "info");
 }
@@ -863,6 +884,7 @@ function buildLoopDeps() {
         getMainBranch,
         // Unit closeout + runtime records
         closeoutUnit,
+        autoCommitUnit,
         recordOutcome,
         writeLock,
         captureAvailableSkills,
@@ -1060,6 +1082,11 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.stepMode = requestedStepMode;
         s.cmdCtx = ctx;
         s.basePath = base;
+        // Ensure the workflow-logger audit log is pinned to the project root
+        // even when auto-mode is entered via a path that bypasses the
+        // bootstrap/dynamic-tools ensureDbOpen() → setLogBasePath() chain
+        // (e.g. /clear resume, hot-reload).
+        setLogBasePath(base);
         s.unitDispatchCount.clear();
         s.unitLifetimeDispatches.clear();
         if (!getLedger())

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -1,5 +1,4 @@
 // GSD2 — Extension registration: wires all GSD tools, commands, and hooks into pi
-import { registerGSDCommand } from "../commands.js";
 import { registerExitCommand } from "../exit-command.js";
 import { registerWorktreeCommand } from "../worktree-command.js";
 import { registerDbTools } from "./db-tools.js";
@@ -9,6 +8,7 @@ import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 import { writeCrashLog } from "./crash-log.js";
+import { logWarning } from "../workflow-logger.js";
 export { writeCrashLog } from "./crash-log.js";
 export function handleRecoverableExtensionProcessError(err) {
     if (err.code === "EPIPE") {
@@ -52,7 +52,8 @@ function installEpipeGuard() {
     }
 }
 export function registerGsdExtension(pi) {
-    registerGSDCommand(pi);
+    // Note: registerGSDCommand is called by index.ts before this function,
+    // so we intentionally skip it here to avoid double-registration.
     registerWorktreeCommand(pi);
     registerExitCommand(pi);
     installEpipeGuard();
@@ -62,10 +63,22 @@ export function registerGsdExtension(pi) {
             process.exit(0);
         },
     });
-    registerDynamicTools(pi);
-    registerDbTools(pi);
-    registerJournalTools(pi);
-    registerQueryTools(pi);
-    registerShortcuts(pi);
-    registerHooks(pi);
+    // Wrap non-critical registrations individually so one failure
+    // doesn't prevent the others from loading.
+    const nonCriticalRegistrations = [
+        ["dynamic-tools", () => registerDynamicTools(pi)],
+        ["db-tools", () => registerDbTools(pi)],
+        ["journal-tools", () => registerJournalTools(pi)],
+        ["query-tools", () => registerQueryTools(pi)],
+        ["shortcuts", () => registerShortcuts(pi)],
+        ["hooks", () => registerHooks(pi)],
+    ];
+    for (const [name, register] of nonCriticalRegistrations) {
+        try {
+            register();
+        }
+        catch (err) {
+            logWarning("bootstrap", `Failed to register ${name}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
 }

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { resolveProjectRoot } from "../worktree.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase|notifications";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -62,6 +62,12 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "rethink", desc: "Conversational project reorganization — reorder, park, discard, add milestones" },
     { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, validate, pause, resume)" },
     { cmd: "codebase", desc: "Generate, refresh, and inspect the codebase map cache (.gsd/CODEBASE.md)" },
+    { cmd: "ship", desc: "Create PR from milestone artifacts and open for review" },
+    { cmd: "do", desc: "Route freeform text to the right GSD command" },
+    { cmd: "session-report", desc: "Session cost, tokens, and work summary" },
+    { cmd: "backlog", desc: "Manage backlog items (add, promote, remove, list)" },
+    { cmd: "pr-branch", desc: "Create clean PR branch filtering .gsd/ commits" },
+    { cmd: "add-tests", desc: "Generate tests for completed slices" },
 ];
 const NESTED_COMPLETIONS = {
     auto: [
@@ -231,6 +237,25 @@ const NESTED_COMPLETIONS = {
         { cmd: "stats", desc: "Show file count, description coverage, and generation time" },
         { cmd: "help", desc: "Show usage and available subcommands" },
     ],
+    ship: [
+        { cmd: "--dry-run", desc: "Preview PR without creating" },
+        { cmd: "--draft", desc: "Open as draft PR" },
+        { cmd: "--base", desc: "Override target branch (default: main)" },
+        { cmd: "--force", desc: "Ship even with pending tasks" },
+    ],
+    "session-report": [
+        { cmd: "--json", desc: "Machine-readable JSON output" },
+        { cmd: "--save", desc: "Save report to .gsd/reports/" },
+    ],
+    backlog: [
+        { cmd: "add", desc: "Add item to backlog" },
+        { cmd: "promote", desc: "Promote backlog item to active slice" },
+        { cmd: "remove", desc: "Remove backlog item" },
+    ],
+    "pr-branch": [
+        { cmd: "--dry-run", desc: "Preview what would be filtered" },
+        { cmd: "--name", desc: "Custom branch name" },
+    ],
 };
 function filterOptions(partial, options, prefix = "") {
     const normalizedPrefix = prefix ? `${prefix} ` : "";