gsd-pi 2.59.0 → 2.60.0-dev.2580e65

package/dist/resources/extensions/ask-user-questions.js

@@ -82,11 +82,14 @@ export default function AskUserQuestions(pi) {
                     return errorResult(`Error: ask_user_questions requires non-empty options for every question (question "${q.id}" has none)`, params.questions);
                 }
             }
+            // Try remote first if configured (works in both interactive and headless modes).
+            // tryRemoteQuestions returns null when no remote channel is configured, so
+            // this is a no-op when the user has not set up Slack/Discord/Telegram.
+            const { tryRemoteQuestions } = await import("./remote-questions/manager.js");
+            const remoteResult = await tryRemoteQuestions(params.questions, signal);
+            if (remoteResult)
+                return { ...remoteResult, details: remoteResult.details };
             if (!ctx.hasUI) {
-                const { tryRemoteQuestions } = await import("./remote-questions/manager.js");
-                const remoteResult = await tryRemoteQuestions(params.questions, signal);
-                if (remoteResult)
-                    return { ...remoteResult, details: remoteResult.details };
                 return errorResult("Error: UI not available (non-interactive mode)", params.questions);
             }
             // Delegate to shared interview UI

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

@@ -487,11 +487,53 @@ export async function runDispatch(ic, preData, loopState) {
 }
 // ─── runGuards ────────────────────────────────────────────────────────────────
 /**
- * Phase 2: Guards — budget ceiling, context window, secrets re-check.
+ * Phase 2: Guards — stop directives, budget ceiling, context window, secrets re-check.
  * Returns break to exit the loop, or next to proceed to dispatch.
  */
 export async function runGuards(ic, mid) {
     const { ctx, pi, s, deps, prefs } = ic;
+    // ── Stop/Backtrack directive guard (#3487) ──
+    // Check for unexecuted stop or backtrack captures BEFORE dispatching any unit.
+    // This ensures user "halt" directives are honored immediately.
+    // IMPORTANT: Fail-closed — any exception during stop handling still breaks the loop
+    // to ensure user halt intent is never silently dropped.
+    try {
+        const { loadStopCaptures, markCaptureExecuted } = await import("../captures.js");
+        const stopCaptures = loadStopCaptures(s.basePath);
+        if (stopCaptures.length > 0) {
+            const first = stopCaptures[0];
+            const isBacktrack = first.classification === "backtrack";
+            const label = isBacktrack
+                ? `Backtrack directive: ${first.text}`
+                : `Stop directive: ${first.text}`;
+            ctx.ui.notify(label, "warning");
+            deps.sendDesktopNotification("GSD", label, "warning", "stop-directive", basename(s.originalBasePath || s.basePath));
+            // Pause first — ensures auto-mode stops even if later steps fail
+            await deps.pauseAuto(ctx, pi);
+            // For backtrack captures, write the backtrack trigger after pausing
+            if (isBacktrack) {
+                try {
+                    const { executeBacktrack } = await import("../triage-resolution.js");
+                    executeBacktrack(s.basePath, mid, first);
+                }
+                catch (e) {
+                    debugLog("guards", { phase: "backtrack-execution-error", error: String(e) });
+                }
+            }
+            // Mark captures as executed only after successful pause/transition
+            for (const cap of stopCaptures) {
+                markCaptureExecuted(s.basePath, cap.id);
+            }
+            debugLog("autoLoop", { phase: "exit", reason: isBacktrack ? "user-backtrack" : "user-stop" });
+            return { action: "break", reason: isBacktrack ? "user-backtrack" : "user-stop" };
+        }
+    }
+    catch (e) {
+        // Fail-closed: if anything in the stop guard throws, break the loop
+        // rather than silently continuing and dropping user halt intent
+        debugLog("guards", { phase: "stop-guard-error", error: String(e) });
+        return { action: "break", reason: "stop-guard-error" };
+    }
     // Budget ceiling guard
     const budgetCeiling = prefs?.budget_ceiling;
     if (budgetCeiling !== undefined && budgetCeiling > 0) {
@@ -843,6 +885,25 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         s.unitDispatchCount.delete(`${unitType}/${unitId}`);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
     }
+    // Write phase handoff anchor after successful research/planning completion
+    const anchorPhases = new Set(["research-milestone", "research-slice", "plan-milestone", "plan-slice"]);
+    if (artifactVerified && mid && anchorPhases.has(unitType)) {
+        try {
+            const { writePhaseAnchor } = await import("../phase-anchor.js");
+            writePhaseAnchor(s.basePath, mid, {
+                phase: unitType,
+                milestoneId: mid,
+                generatedAt: new Date().toISOString(),
+                intent: `Completed ${unitType} for ${unitId}`,
+                decisions: [],
+                blockers: [],
+                nextSteps: [],
+            });
+        }
+        catch (err) { /* non-fatal — anchor is advisory */
+            logWarning("engine", `phase anchor failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitResult.status, artifactVerified, ...(unitResult.errorContext ? { errorContext: unitResult.errorContext } : {}) }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
     return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };
 }

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

@@ -20,6 +20,7 @@ import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./pref
 import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
 import { parseUnitId } from "./unit-id.js";
 import { formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-session-stats.js";
+import { logWarning } from "./workflow-logger.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
@@ -220,8 +221,9 @@ export function updateSliceProgressCache(base, mid, activeSid) {
                     }
                 }
             }
-            catch {
+            catch (err) {
                 // Non-fatal — just omit task count
+                logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
         cachedSliceProgress = {
@@ -232,8 +234,9 @@ export function updateSliceProgressCache(base, mid, activeSid) {
             taskDetails,
         };
     }
-    catch {
+    catch (err) {
         // Non-fatal — widget just won't show progress bar
+        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 export function getRoadmapSlicesSync() {
@@ -263,8 +266,9 @@ function refreshLastCommit(basePath) {
         }
         lastCommitFetchedAt = Date.now();
     }
-    catch {
+    catch (err) {
         // Non-fatal — just skip last commit display
+        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 function getLastCommit(basePath) {
@@ -300,7 +304,9 @@ function ensureWidgetModeLoaded() {
             widgetMode = saved;
         }
     }
-    catch { /* non-fatal — use default */ }
+    catch (err) { /* non-fatal — use default */
+        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }
 /** Persist widget mode to global preferences YAML. */
 function persistWidgetMode(mode) {
@@ -320,7 +326,9 @@ function persistWidgetMode(mode) {
         }
         writeFileSync(prefsPath, content, "utf-8");
     }
-    catch { /* non-fatal — mode still set in memory */ }
+    catch (err) { /* non-fatal — mode still set in memory */
+        logWarning("dashboard", `file write failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }
 /** Cycle to the next widget mode. Returns the new mode. */
 export function cycleWidgetMode() {
@@ -360,7 +368,9 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
     try {
         cachedBranch = getCurrentBranch(accessors.getBasePath());
     }
-    catch { /* not in git repo */ }
+    catch (err) { /* not in git repo */
+        logWarning("dashboard", `git branch detection failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // Cache short pwd (last 2 path segments only) + worktree/branch info
     let widgetPwd;
     {
@@ -394,7 +404,8 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 const savings = sessionId ? getRtkSessionSavings(accessors.getBasePath(), sessionId) : null;
                 cachedRtkLabel = formatRtkSavingsLabel(savings);
             }
-            catch {
+            catch (err) {
+                logWarning("dashboard", `RTK savings lookup failed: ${err instanceof Error ? err.message : String(err)}`);
                 cachedRtkLabel = null;
             }
         };
@@ -416,7 +427,9 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 refreshRtkLabel();
                 cachedLines = undefined;
             }
-            catch { /* non-fatal */ }
+            catch (err) { /* non-fatal */
+                logWarning("dashboard", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }, 15_000);
         return {
             render(width) {

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

@@ -13,7 +13,7 @@ import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { logError } from "./workflow-logger.js";
+import { logWarning, logError } from "./workflow-logger.js";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
 import { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
@@ -564,7 +564,9 @@ export const DISPATCH_RULES = [
                     }
                 }
             }
-            catch { /* fall through — don't block on DB errors */ }
+            catch (err) { /* fall through — don't block on DB errors */
+                logWarning("dispatch", `verification class check failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
             return {
                 action: "dispatch",
                 unitType: "complete-milestone",
@@ -602,8 +604,9 @@ export async function resolveDispatch(ctx) {
         const registry = getRegistry();
         return await registry.evaluateDispatch(ctx);
     }
-    catch {
+    catch (err) {
         // Registry not initialized — fall back to inline loop
+        logWarning("dispatch", `registry dispatch failed, falling back to inline rules: ${err instanceof Error ? err.message : String(err)}`);
     }
     for (const rule of DISPATCH_RULES) {
         const result = await rule.match(ctx);

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -5,7 +5,7 @@
  */
 import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.js";
 import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
-import { resolveModelForComplexity, escalateTier } from "./model-router.js";
+import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabilityOverrides } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
 export function resolvePreferredModelConfig(unitType, autoModeStartModel) {
@@ -68,14 +68,68 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
                         }
                     }
                 }
-                const routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds);
+                // Load user capability overrides from preferences (D-17: deep-merged with built-in profiles)
+                const capabilityOverrides = loadCapabilityOverrides(prefs ?? {});
+                // Fire before_model_select hook (ADR-004, D-03)
+                // Hook can override model selection entirely by returning { modelId }
+                let hookOverride;
+                if (routingConfig.hooks !== false) {
+                    const eligible = getEligibleModels(classification.tier, availableModelIds, routingConfig);
+                    const hookResult = await pi.emitBeforeModelSelect({
+                        unitType,
+                        unitId,
+                        classification: {
+                            tier: classification.tier,
+                            reason: classification.reason,
+                            downgraded: classification.downgraded,
+                        },
+                        taskMetadata: classification.taskMetadata,
+                        eligibleModels: eligible,
+                        phaseConfig: modelConfig ? {
+                            primary: modelConfig.primary,
+                            fallbacks: modelConfig.fallbacks ?? [],
+                        } : undefined,
+                    });
+                    if (hookResult?.modelId) {
+                        hookOverride = hookResult.modelId;
+                    }
+                }
+                let routingResult;
+                if (hookOverride) {
+                    // Hook override bypasses capability scoring entirely
+                    routingResult = {
+                        modelId: hookOverride,
+                        fallbacks: [
+                            ...(modelConfig?.fallbacks ?? []).filter(f => f !== hookOverride),
+                            ...(modelConfig?.primary && modelConfig.primary !== hookOverride ? [modelConfig.primary] : []),
+                        ],
+                        tier: classification.tier,
+                        wasDowngraded: hookOverride !== modelConfig?.primary,
+                        reason: `hook override: ${hookOverride}`,
+                        selectionMethod: "tier-only",
+                    };
+                }
+                else {
+                    routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds, unitType, classification.taskMetadata, capabilityOverrides);
+                }
                 if (routingResult.wasDowngraded) {
                     effectiveModelConfig = {
                         primary: routingResult.modelId,
                         fallbacks: routingResult.fallbacks,
                     };
                     if (verbose) {
-                        ctx.ui.notify(`Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${classification.reason})`, "info");
+                        if (routingResult.selectionMethod === "capability-scored" && routingResult.capabilityScores) {
+                            // Verbose scoring breakdown for capability-scored decisions (D-20)
+                            const tierLbl = tierLabel(classification.tier);
+                            const scores = Object.entries(routingResult.capabilityScores)
+                                .sort(([, a], [, b]) => b - a)
+                                .map(([id, score]) => `${id}: ${score.toFixed(1)}`)
+                                .join(", ");
+                            ctx.ui.notify(`Dynamic routing [${tierLbl}]: ${routingResult.modelId} (capability-scored) — ${scores}`, "info");
+                        }
+                        else {
+                            ctx.ui.notify(`Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${classification.reason})`, "info");
+                        }
                     }
                 }
                 routingTierLabel = ` [${tierLabel(classification.tier)}]`;

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

@@ -26,7 +26,7 @@ import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getA
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
-import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
+import { hasPendingCaptures, loadPendingCaptures, revertExecutorResolvedCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { runSafely } from "./auto-utils.js";
 /** Enqueue a sidecar item (hook, triage, or quick-task) for the main loop to
@@ -208,8 +208,9 @@ export async function postUnitPreVerification(pctx, opts) {
                                     const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
                                     ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
                                 }
-                                catch {
+                                catch (err) {
                                     // GitHub sync not available — skip
+                                    logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
                                 }
                                 taskContext = {
                                     taskId: `${sid}/${tid}`,
@@ -448,7 +449,7 @@ export async function postUnitPostVerification(pctx) {
                         catch (dbErr) {
                             // DB unavailable — fail explicitly rather than silently reverting to markdown mutation.
                             // Use 'gsd recover' to rebuild DB state from disk if needed.
-                            process.stderr.write(`gsd: retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover' to reconcile.\n`);
+                            logError("engine", `retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover' to reconcile.`);
                         }
                     }
                     // 2. Delete SUMMARY.md for the task
@@ -478,6 +479,45 @@ export async function postUnitPostVerification(pctx) {
             }
         }
     }
+    // ── Fast-path stop detection (#3487) ──
+    // Before waiting for triage, check if any PENDING captures contain explicit
+    // stop/halt language. If so, pause immediately — don't wait for triage.
+    if (s.currentUnit && s.currentUnit.type !== "triage-captures") {
+        try {
+            const pending = loadPendingCaptures(s.basePath);
+            // Match only when the capture text starts with a stop/halt directive word,
+            // or the entire text is short and dominated by such a word. This avoids
+            // false positives on captures like "add a pause button" or "stop the timer
+            // from re-rendering" — those are feature descriptions, not halt directives.
+            const STOP_PATTERN = /^(stop|halt|abort|don'?t continue|pause|cease)\b/i;
+            const stopCapture = pending.find(c => STOP_PATTERN.test(c.text.trim()));
+            if (stopCapture) {
+                ctx.ui.notify(`Stop directive detected in pending capture ${stopCapture.id}: "${stopCapture.text}" — pausing auto-mode.`, "warning");
+                debugLog("postUnit", { phase: "fast-stop", captureId: stopCapture.id });
+                await pauseAuto(ctx, pi);
+                return "stopped";
+            }
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "fast-stop-error", error: String(e) });
+        }
+    }
+    // ── Capture protection: revert executor-silenced captures (#3487) ──
+    // Non-triage agents can write **Status:** resolved to CAPTURES.md, bypassing
+    // the triage pipeline. Revert those to pending before the triage check.
+    if (s.currentUnit &&
+        s.currentUnit.type !== "triage-captures") {
+        try {
+            const reverted = revertExecutorResolvedCaptures(s.basePath);
+            if (reverted > 0) {
+                debugLog("postUnit", { phase: "capture-protection", reverted });
+                ctx.ui.notify(`Reverted ${reverted} capture${reverted === 1 ? "" : "s"} silenced by executor — re-queuing for triage.`, "warning");
+            }
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "capture-protection-error", error: String(e) });
+        }
+    }
     // ── Triage check ──
     if (!s.stepMode &&
         s.currentUnit &&

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

@@ -17,6 +17,8 @@ import { existsSync } from "node:fs";
 import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
 import { getPendingGates } from "./gsd-db.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
+import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
+import { logWarning } from "./workflow-logger.js";
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 const MAX_PREAMBLE_CHARS = 30_000;
 function capPreamble(preamble) {
@@ -36,7 +38,8 @@ function formatExecutorConstraints() {
         const prefs = loadEffectiveGSDPreferences();
         windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences);
     }
-    catch {
+    catch (e) {
+        logWarning("prompt", `resolveExecutorContextWindow failed: ${e.message}`);
         windowTokens = 200_000; // safe default
     }
     const budgets = computeBudgets(windowTokens);
@@ -160,7 +163,9 @@ export async function inlineDependencySummaries(mid, sid, base, budgetChars) {
             // If slice not found in DB, fall through to file-based parsing
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `inlineDependencySummaries DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // If DB didn't provide depends, fall back to roadmap parsing
     if (!depends) {
         const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
@@ -232,8 +237,8 @@ export async function inlineDecisionsFromDb(base, milestoneId, scope, level) {
             }
         }
     }
-    catch {
-        // DB not available — fall through to filesystem
+    catch (err) {
+        logWarning("prompt", `inlineDecisionsFromDb failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return inlineGsdRootFile(base, "decisions.md", "Decisions");
 }
@@ -257,8 +262,8 @@ export async function inlineRequirementsFromDb(base, sliceId, level) {
             }
         }
     }
-    catch {
-        // DB not available — fall through to filesystem
+    catch (err) {
+        logWarning("prompt", `inlineRequirementsFromDb failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return inlineGsdRootFile(base, "requirements.md", "Requirements");
 }
@@ -277,8 +282,8 @@ export async function inlineProjectFromDb(base) {
             }
         }
     }
-    catch {
-        // DB not available — fall through to filesystem
+    catch (err) {
+        logWarning("prompt", `inlineProjectFromDb failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return inlineGsdRootFile(base, "project.md", "Project");
 }
@@ -398,8 +403,8 @@ export function buildSkillActivationBlock(params) {
                 matched.add(normalizeSkillReference(skillName));
             }
         }
-        catch {
-            // Non-fatal — malformed task plan should not break prompt construction
+        catch (err) {
+            logWarning("prompt", `parseTaskPlanFile failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     const ordered = [...matched]
@@ -618,7 +623,9 @@ export async function checkNeedsReassessment(base, mid, state) {
             }
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `checkNeedsReassessment DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // File-based fallback using roadmap checkboxes
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     if (!roadmapPath)
@@ -693,7 +700,9 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
             }
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `checkNeedsRunUat DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // File-based fallback using roadmap checkboxes
     if (!prefs?.uat_dispatch)
         return null;
@@ -797,6 +806,10 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
     const researchPath = resolveMilestoneFile(base, mid, "RESEARCH");
     const researchRel = relMilestoneFile(base, mid, "RESEARCH");
     const inlined = [];
+    // Inject phase handoff anchor from research phase (if available)
+    const researchAnchor = readPhaseAnchor(base, mid, "research-milestone");
+    if (researchAnchor)
+        inlined.push(formatAnchorForPrompt(researchAnchor));
     inlined.push(await inlineFile(contextPath, contextRel, "Milestone Context"));
     const researchInline = await inlineFileOptional(researchPath, researchRel, "Milestone Research");
     if (researchInline)
@@ -919,6 +932,10 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     const researchPath = resolveSliceFile(base, mid, sid, "RESEARCH");
     const researchRel = relSliceFile(base, mid, sid, "RESEARCH");
     const inlined = [];
+    // Inject phase handoff anchor from research phase (if available)
+    const researchSliceAnchor = readPhaseAnchor(base, mid, "research-slice");
+    if (researchSliceAnchor)
+        inlined.push(formatAnchorForPrompt(researchSliceAnchor));
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
     const researchInline = await inlineFileOptional(researchPath, researchRel, "Slice Research");
     if (researchInline)
@@ -974,6 +991,8 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         ? level
         : { level: level };
     const inlineLevel = opts.level ?? resolveInlineLevel();
+    // Inject phase handoff anchor from planning phase (if available)
+    const planAnchor = readPhaseAnchor(base, mid, "plan-slice");
     const priorSummaries = opts.carryForwardPaths ?? await getPriorTaskSummaryPaths(mid, sid, tid, base);
     const priorLines = priorSummaries.length > 0
         ? priorSummaries.map(p => `- \`${p}\``).join("\n")
@@ -1042,9 +1061,11 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const runtimeContext = runtimeContent
         ? `### Runtime Context\nSource: \`.gsd/RUNTIME.md\`\n\n${runtimeContent.trim()}`
         : "";
+    const phaseAnchorSection = planAnchor ? formatAnchorForPrompt(planAnchor) : "";
     return loadPrompt("execute-task", {
         overridesSection,
         runtimeContext,
+        phaseAnchorSection,
         workingDirectory: base,
         milestoneId: mid, sliceId: sid, sliceTitle: sTitle, taskId: tid, taskTitle: tTitle,
         planPath: join(base, relSliceFile(base, mid, sid, "PLAN")),
@@ -1137,7 +1158,9 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
             sliceIds = getMilestoneSlices(mid).map(s => s.id);
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `buildCompleteMilestonePrompt DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // File-based fallback: parse roadmap for slice IDs when DB has no data
     if (sliceIds.length === 0 && roadmapPath) {
         const roadmapContent = await loadFile(roadmapPath);
@@ -1220,7 +1243,9 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
             }
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `buildValidateMilestonePrompt verification classes lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // Inline all slice summaries and UAT results
     let valSliceIds = [];
     try {
@@ -1229,7 +1254,9 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
             valSliceIds = getMilestoneSlices(mid).map(s => s.id);
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `buildValidateMilestonePrompt slice IDs lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // File-based fallback: parse roadmap for slice IDs when DB has no data
     if (valSliceIds.length === 0 && roadmapPath) {
         const roadmapContent = await loadFile(roadmapPath);
@@ -1365,8 +1392,8 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
             captureContext = replanCaptures.map(c => `- **${c.id}**: "${c.text}" — ${c.rationale ?? "no rationale"}`).join("\n");
         }
     }
-    catch {
-        // Non-fatal — captures module may not be available
+    catch (err) {
+        logWarning("prompt", `loadReplanCaptures failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return loadPrompt("replan-slice", {
         workingDirectory: base,
@@ -1455,8 +1482,8 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
             deferredCaptures = deferred.map(c => `- **${c.id}**: "${c.text}" — ${c.rationale ?? "deferred during triage"}`).join("\n");
         }
     }
-    catch {
-        // Non-fatal — captures module may not be available
+    catch (err) {
+        logWarning("prompt", `loadDeferredCaptures failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     const reassessCommitInstruction = "Do not commit — .gsd/ planning docs are managed externally and not tracked in git.";
     return loadPrompt("reassess-roadmap", {
@@ -1633,7 +1660,9 @@ export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, o
                             .map(t => ({ id: t.id }));
                     }
                 }
-                catch { /* fall through */ }
+                catch (err) {
+                    logWarning("prompt", `buildRewriteDocsPrompt DB task lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
                 if (!incompleteTasks) {
                     // DB unavailable — no task data to inline
                     incompleteTasks = [];