gsd-pi 2.73.1-dev.6ddfa43 → 2.73.1-dev.9a4cd44

package/dist/resource-loader.js

@@ -358,7 +358,7 @@ function reconcileMergedNodeModules(agentNodeModules, hoisted, internal) {
             if (entry.name.startsWith('.'))
                 continue;
             try {
-                symlinkSync(join(hoisted, entry.name), join(agentNodeModules, entry.name));
+                symlinkSync(join(hoisted, entry.name), join(agentNodeModules, entry.name), 'junction');
                 linkedCount++;
             }
             catch { /* skip individual */ }
@@ -382,7 +382,7 @@ function reconcileMergedNodeModules(agentNodeModules, hoisted, internal) {
             }
             catch { /* didn't exist — will create below */ }
             try {
-                symlinkSync(join(internal, entry.name), link);
+                symlinkSync(join(internal, entry.name), link, 'junction');
                 linkedCount++;
             }
             catch { /* skip individual */ }

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

@@ -320,10 +320,13 @@ export async function runPreDispatch(ic, loopState) {
         }
         else if (state.phase === "blocked") {
             const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
-            await deps.stopAuto(ctx, pi, blockerMsg);
-            ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
-            deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention", basename(s.originalBasePath || s.basePath));
-            deps.logCmuxEvent(prefs, blockerMsg, "error");
+            // Pause instead of hard-stop so the session is resumable with `/gsd auto`.
+            // Hard-stop here was causing premature termination when slice dependencies
+            // were temporarily unresolvable (e.g. after reassessment added new slices).
+            await deps.pauseAuto(ctx, pi);
+            ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto to resume.`, "warning");
+            deps.sendDesktopNotification("GSD", blockerMsg, "warning", "attention", basename(s.originalBasePath || s.basePath));
+            deps.logCmuxEvent(prefs, blockerMsg, "warning");
         }
         else {
             const ids = incomplete.map((m) => m.id).join(", ");
@@ -392,13 +395,16 @@ export async function runPreDispatch(ic, loopState) {
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "milestone-complete", milestoneId: mid } });
         return { action: "break", reason: "milestone-complete" };
     }
-    // Terminal: blocked
+    // Terminal: blocked — pause instead of hard-stop so the session is resumable.
     if (state.phase === "blocked") {
         const blockerMsg = `Blocked: ${state.blockers.join(", ")}`;
-        await closeoutAndStop(ctx, pi, s, deps, blockerMsg);
-        ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto.`, "warning");
-        deps.sendDesktopNotification("GSD", blockerMsg, "error", "attention", basename(s.originalBasePath || s.basePath));
-        deps.logCmuxEvent(prefs, blockerMsg, "error");
+        if (s.currentUnit) {
+            await deps.closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, deps.buildSnapshotOpts(s.currentUnit.type, s.currentUnit.id));
+        }
+        await deps.pauseAuto(ctx, pi);
+        ctx.ui.notify(`${blockerMsg}. Fix and run /gsd auto to resume.`, "warning");
+        deps.sendDesktopNotification("GSD", blockerMsg, "warning", "attention", basename(s.originalBasePath || s.basePath));
+        deps.logCmuxEvent(prefs, blockerMsg, "warning");
         debugLog("autoLoop", { phase: "exit", reason: "blocked" });
         deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "terminal", data: { reason: "blocked", blockers: state.blockers } });
         return { action: "break", reason: "blocked" };

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

@@ -216,7 +216,12 @@ export const DISPATCH_RULES = [
     {
         name: "reassess-roadmap (post-completion)",
         match: async ({ state, mid, midTitle, basePath, prefs }) => {
-            if (prefs?.phases?.skip_reassess || !prefs?.phases?.reassess_after_slice)
+            if (prefs?.phases?.skip_reassess)
+                return null;
+            // Default reassess_after_slice to true — reassessment after slice completion
+            // is essential for roadmap integrity. Opt-out via explicit `false`.
+            const reassessEnabled = prefs?.phases?.reassess_after_slice ?? true;
+            if (!reassessEnabled)
                 return null;
             const needsReassess = await checkNeedsReassessment(basePath, mid, state);
             if (!needsReassess)
@@ -710,11 +715,14 @@ export async function resolveDispatch(ctx) {
             return result;
         }
     }
-    // No rule matched — unhandled phase
+    // No rule matched — unhandled phase.
+    // Use level "warning" so the loop pauses (resumable) instead of hard-stopping.
+    // Hard-stop here was causing premature termination for transient phase gaps
+    // (e.g. after reassessment modifies the roadmap and state needs re-derivation).
     return {
         action: "stop",
         reason: `Unhandled phase "${ctx.state.phase}" — run /gsd doctor to diagnose.`,
-        level: "info",
+        level: "warning",
         matchedRule: "<no-match>",
     };
 }

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,15 @@ 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).`;
+}
 /**
  * Pre-verification processing: parallel worker signal check, cache invalidation,
  * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
@@ -509,6 +519,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 +866,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-start.js

@@ -632,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

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

@@ -55,7 +55,7 @@ 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 ──────────────────────────────────────────────────────
@@ -63,6 +63,7 @@ import { startUnitSupervision } from "./auto-timers.js";
 import { runPostUnitVerification } from "./auto-verification.js";
 import { 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");
 }

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -17,6 +17,11 @@ import { projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
 const UPDATE_REGISTRY_URL = "https://registry.npmjs.org/gsd-pi/latest";
 const UPDATE_FETCH_TIMEOUT_MS = 5000;
+function resolveInstallCommand(pkg) {
+    if ('bun' in process.versions)
+        return `bun add -g ${pkg}`;
+    return `npm install -g ${pkg}`;
+}
 async function fetchLatestVersionForCommand() {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), UPDATE_FETCH_TIMEOUT_MS);
@@ -344,13 +349,14 @@ export async function handleUpdate(ctx) {
         return;
     }
     ctx.ui.notify(`Updating: v${current} → v${latest}...`, "info");
+    const installCmd = resolveInstallCommand(`${NPM_PACKAGE}@latest`);
     try {
-        execSync(`npm install -g ${NPM_PACKAGE}@latest`, {
+        execSync(installCmd, {
             stdio: ["ignore", "pipe", "ignore"],
         });
         ctx.ui.notify(`Updated to v${latest}. Restart your GSD session to use the new version.`, "info");
     }
     catch {
-        ctx.ui.notify(`Update failed. Try manually: npm install -g ${NPM_PACKAGE}@latest`, "error");
+        ctx.ui.notify(`Update failed. Try manually: ${installCmd}`, "error");
     }
 }

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -157,7 +157,7 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `phases`: fine-grained control over which phases run. Usually set by `token_profile`, but can be overridden. Keys:
   - `skip_research`: boolean — skip milestone-level research. Default: `false`.
-  - `reassess_after_slice`: boolean — run roadmap reassessment after each completed slice. Default: `false`.
+  - `reassess_after_slice`: boolean — run roadmap reassessment after each completed slice. Default: `true`.
   - `skip_reassess`: boolean — force-disable roadmap reassessment even if `reassess_after_slice` is enabled. Default: `false`.
   - `skip_slice_research`: boolean — skip per-slice research. Default: `false`.
 

package/dist/resources/extensions/gsd/notification-widget.js

@@ -1,6 +1,6 @@
 // GSD Extension — Notification Widget
 // Always-on ambient widget rendered belowEditor showing unread count and
-// the most recent notification message. Refreshes every 5 seconds.
+// the most recent notification message. Refreshes every 30 seconds.
 // Widget key: "gsd-notifications", placement: "belowEditor"
 import { getUnreadCount, onNotificationStoreChange } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
@@ -12,7 +12,7 @@ export function buildNotificationWidgetLines() {
     return [`  🔔 Notifications: ${unread} unread  (${formattedShortcutPair("notifications")})`];
 }
 // ─── Widget init ────────────────────────────────────────────────────────
-const REFRESH_INTERVAL_MS = 5_000;
+const REFRESH_INTERVAL_MS = 30_000;
 /**
  * Initialize the always-on notification widget (belowEditor).
  * Call once from session_start after the notification store is initialized.

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

@@ -312,6 +312,10 @@ function reconcileDiskToDb(basePath) {
 function buildCompletenessSet(basePath, milestones) {
     const completeMilestoneIds = new Set();
     const parkedMilestoneIds = new Set();
+    // DB-authoritative: a milestone is only "complete" when its DB row says so.
+    // SUMMARY-file presence is NOT a completion signal here — an orphan SUMMARY
+    // (crashed complete-milestone turn, partial merge, manual edit) must not
+    // flip derived state to complete and cascade into a false auto-merge (#4179).
     for (const m of milestones) {
         const parkedFile = resolveMilestoneFile(basePath, m.id, "PARKED");
         if (parkedFile || m.status === 'parked') {
@@ -322,11 +326,6 @@ function buildCompletenessSet(basePath, milestones) {
             completeMilestoneIds.add(m.id);
             continue;
         }
-        const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
-        if (summaryFile) {
-            completeMilestoneIds.add(m.id);
-            continue;
-        }
     }
     return { completeMilestoneIds, parkedMilestoneIds };
 }
@@ -347,17 +346,22 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
             if (isGhostMilestone(basePath, m.id))
                 continue;
         }
-        const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
-        if (completeMilestoneIds.has(m.id) || (summaryFile !== null)) {
+        // DB-authoritative completeness (#4179): only trust completeMilestoneIds,
+        // which is itself derived from DB status. SUMMARY-file presence alone must
+        // not imply completion. The summary file may still be consulted below as a
+        // title source for legitimately-complete milestones whose DB row has no title.
+        if (completeMilestoneIds.has(m.id)) {
             let title = stripMilestonePrefix(m.title) || m.id;
-            if (summaryFile && !m.title) {
-                const summaryContent = await loadFile(summaryFile);
-                if (summaryContent) {
-                    title = parseSummary(summaryContent).title || m.id;
+            if (!m.title) {
+                const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
+                if (summaryFile) {
+                    const summaryContent = await loadFile(summaryFile);
+                    if (summaryContent) {
+                        title = parseSummary(summaryContent).title || m.id;
+                    }
                 }
             }
             registry.push({ id: m.id, title, status: 'complete' });
-            completeMilestoneIds.add(m.id);
             continue;
         }
         const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
@@ -391,7 +395,14 @@ async function buildRegistryAndFindActive(basePath, milestones, completeMileston
                 const validationFile = resolveMilestoneFile(basePath, m.id, "VALIDATION");
                 const validationContent = validationFile ? await loadFile(validationFile) : null;
                 const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
-                if (!validationTerminal || (validationTerminal && !summaryFile)) {
+                // DB-authoritative (#4179): completeness is already decided by
+                // completeMilestoneIds above. If we reached this branch, the DB says
+                // the milestone is NOT complete — so any SUMMARY file on disk is an
+                // orphan (crashed complete-milestone, partial merge, manual edit) and
+                // must not short-circuit this path. When validation is terminal, fall
+                // through to the default active-push below so `complete-milestone` can
+                // re-run idempotently.
+                if (!validationTerminal) {
                     activeMilestone = { id: m.id, title };
                     activeMilestoneSlices = slices;
                     activeMilestoneFound = true;
@@ -516,6 +527,9 @@ function resolveSliceDependencies(activeMilestoneSlices) {
             return { activeSlice: null, activeSliceRow: null };
         }
     }
+    // First pass: find a slice with ALL dependencies satisfied (strict)
+    let bestFallback = null;
+    let bestFallbackSatisfied = -1;
     for (const s of activeMilestoneSlices) {
         if (isStatusDone(s.status))
             continue;
@@ -524,6 +538,23 @@ function resolveSliceDependencies(activeMilestoneSlices) {
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             return { activeSlice: { id: s.id, title: s.title }, activeSliceRow: s };
         }
+        // Track the slice with the most satisfied dependencies as fallback
+        const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
+        if (satisfied > bestFallbackSatisfied || (satisfied === bestFallbackSatisfied && !bestFallback)) {
+            bestFallback = s;
+            bestFallbackSatisfied = satisfied;
+        }
+    }
+    // Fallback: if no slice has all deps met but there ARE incomplete non-deferred
+    // slices, pick the one with the most deps satisfied. This prevents hard-blocking
+    // when dependency metadata is stale (e.g. after reassessment added/removed slices)
+    // or when deps reference slices from previous milestones.
+    if (bestFallback) {
+        const unmet = bestFallback.depends.filter(dep => !doneSliceIds.has(dep));
+        logWarning("state", `No slice has all deps satisfied — falling back to ${bestFallback.id} ` +
+            `(${bestFallbackSatisfied}/${bestFallback.depends.length} deps met, ` +
+            `unmet: ${unmet.join(", ")})`, { mid: activeMilestoneSlices[0]?.milestone_id, sid: bestFallback.id });
+        return { activeSlice: { id: bestFallback.id, title: bestFallback.title }, activeSliceRow: bestFallback };
     }
     return { activeSlice: null, activeSliceRow: null };
 }
@@ -567,7 +598,7 @@ async function reconcileSliceTasks(basePath, milestoneId, sliceId, planFile) {
         const summaryPath = resolveTaskFile(basePath, milestoneId, sliceId, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             try {
-                updateTaskStatus(milestoneId, sliceId, t.id, "complete");
+                updateTaskStatus(milestoneId, sliceId, t.id, "complete", new Date().toISOString());
                 logWarning("reconcile", `task ${milestoneId}/${sliceId}/${t.id} status reconciled from "${t.status}" to "complete" (#2514)`, { mid: milestoneId, sid: sliceId, tid: t.id });
                 reconciled = true;
             }
@@ -1269,6 +1300,8 @@ export async function _deriveStateImpl(basePath) {
         }
     }
     else {
+        let bestFallbackLegacy = null;
+        let bestFallbackLegacySatisfied = -1;
         for (const s of activeRoadmap.slices) {
             if (s.done)
                 continue;
@@ -1276,6 +1309,20 @@ export async function _deriveStateImpl(basePath) {
                 activeSlice = { id: s.id, title: s.title };
                 break;
             }
+            // Track best fallback
+            const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
+            if (satisfied > bestFallbackLegacySatisfied) {
+                bestFallbackLegacy = s;
+                bestFallbackLegacySatisfied = satisfied;
+            }
+        }
+        // Fallback: if no slice has all deps met, pick the one with the most deps satisfied
+        if (!activeSlice && bestFallbackLegacy) {
+            const unmet = bestFallbackLegacy.depends.filter(dep => !doneSliceIds.has(dep));
+            logWarning("state", `No slice has all deps satisfied — falling back to ${bestFallbackLegacy.id} ` +
+                `(${bestFallbackLegacySatisfied}/${bestFallbackLegacy.depends.length} deps met, ` +
+                `unmet: ${unmet.join(", ")})`);
+            activeSlice = { id: bestFallbackLegacy.id, title: bestFallbackLegacy.title };
         }
     }
     if (!activeSlice) {

package/dist/update-check.d.ts

@@ -9,6 +9,7 @@ export declare function compareSemver(a: string, b: string): number;
 export declare function readUpdateCache(cachePath?: string): UpdateCheckCache | null;
 export declare function writeUpdateCache(cache: UpdateCheckCache, cachePath?: string): void;
 export declare function fetchLatestVersionFromRegistry(registryUrl?: string, fetchTimeoutMs?: number): Promise<string | null>;
+export declare function resolveInstallCommand(pkg: string): string;
 export interface UpdateCheckOptions {
     currentVersion?: string;
     cachePath?: string;