gsd-pi 2.66.1 → 2.67.0-dev.43b0159

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

@@ -8,6 +8,7 @@
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
+import { getErrorMessage } from "./error-utils.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { formatShortcut } from "./files.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
@@ -17,7 +18,7 @@ import { makeUI } from "../shared/tui.js";
 import { GLYPH, INDENT } from "../shared/mod.js";
 import { computeProgressScore } from "./progress-score.js";
 import { getActiveWorktreeName } from "./worktree-command.js";
-import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
+import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, parsePreferencesMarkdown, } from "./preferences.js";
 import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
 import { parseUnitId } from "./unit-id.js";
 import { formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-session-stats.js";
@@ -293,26 +294,68 @@ export const hideFooter = () => ({
 const WIDGET_MODES = ["full", "small", "min", "off"];
 let widgetMode = "full";
 let widgetModeInitialized = false;
+let widgetModePreferencePath = null;
+function safeReadTextFile(path) {
+    try {
+        if (!existsSync(path))
+            return null;
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function readWidgetModeFromFile(path) {
+    const raw = safeReadTextFile(path);
+    if (!raw)
+        return undefined;
+    const prefs = parsePreferencesMarkdown(raw);
+    const saved = prefs?.widget_mode;
+    if (saved && WIDGET_MODES.includes(saved)) {
+        return saved;
+    }
+    return undefined;
+}
+function resolveWidgetModePreferencePath(projectPath = getProjectGSDPreferencesPath(), globalPath = getGlobalGSDPreferencesPath()) {
+    if (readWidgetModeFromFile(projectPath)) {
+        return projectPath;
+    }
+    if (readWidgetModeFromFile(globalPath)) {
+        return globalPath;
+    }
+    if (safeReadTextFile(projectPath) !== null)
+        return projectPath;
+    if (safeReadTextFile(globalPath) !== null)
+        return globalPath;
+    return getGlobalGSDPreferencesPath();
+}
 /** Load widget mode from preferences (once). */
-function ensureWidgetModeLoaded() {
+function ensureWidgetModeLoaded(projectPath, globalPath) {
     if (widgetModeInitialized)
         return;
     widgetModeInitialized = true;
     try {
-        const loaded = loadEffectiveGSDPreferences();
-        const saved = loaded?.preferences?.widget_mode;
+        const resolvedProjectPath = projectPath ?? getProjectGSDPreferencesPath();
+        const resolvedGlobalPath = globalPath ?? getGlobalGSDPreferencesPath();
+        const saved = readWidgetModeFromFile(resolvedProjectPath) ?? readWidgetModeFromFile(resolvedGlobalPath);
         if (saved && WIDGET_MODES.includes(saved)) {
             widgetMode = saved;
         }
+        widgetModePreferencePath = resolveWidgetModePreferencePath(resolvedProjectPath, resolvedGlobalPath);
     }
     catch (err) { /* non-fatal — use default */
-        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
+        logWarning("dashboard", `operation failed: ${getErrorMessage(err)}`);
+        widgetModePreferencePath = getGlobalGSDPreferencesPath();
     }
 }
-/** Persist widget mode to global preferences YAML. */
-function persistWidgetMode(mode) {
+/**
+ * Persist widget mode to the preference file that owns the effective value.
+ * Project-scoped widget_mode wins over global; if neither scope defines it,
+ * we prefer an existing project preferences file and otherwise fall back to
+ * the global preferences file.
+ */
+function persistWidgetMode(mode, prefsPath = widgetModePreferencePath ?? resolveWidgetModePreferencePath()) {
     try {
-        const prefsPath = getGlobalGSDPreferencesPath();
         let content = "";
         if (existsSync(prefsPath)) {
             content = readFileSync(prefsPath, "utf-8");
@@ -332,23 +375,30 @@ function persistWidgetMode(mode) {
     }
 }
 /** Cycle to the next widget mode. Returns the new mode. */
-export function cycleWidgetMode() {
-    ensureWidgetModeLoaded();
+export function cycleWidgetMode(projectPath, globalPath) {
+    ensureWidgetModeLoaded(projectPath, globalPath);
     const idx = WIDGET_MODES.indexOf(widgetMode);
     widgetMode = WIDGET_MODES[(idx + 1) % WIDGET_MODES.length];
-    persistWidgetMode(widgetMode);
+    persistWidgetMode(widgetMode, widgetModePreferencePath ?? resolveWidgetModePreferencePath(projectPath, globalPath));
     return widgetMode;
 }
 /** Set widget mode directly. */
-export function setWidgetMode(mode) {
+export function setWidgetMode(mode, projectPath, globalPath) {
+    ensureWidgetModeLoaded(projectPath, globalPath);
     widgetMode = mode;
-    persistWidgetMode(widgetMode);
+    persistWidgetMode(widgetMode, widgetModePreferencePath ?? resolveWidgetModePreferencePath(projectPath, globalPath));
 }
 /** Get current widget mode. */
-export function getWidgetMode() {
-    ensureWidgetModeLoaded();
+export function getWidgetMode(projectPath, globalPath) {
+    ensureWidgetModeLoaded(projectPath, globalPath);
     return widgetMode;
 }
+/** Test-only reset for widget mode caching. */
+export function _resetWidgetModeForTests() {
+    widgetMode = "full";
+    widgetModeInitialized = false;
+    widgetModePreferencePath = null;
+}
 export function updateProgressWidget(ctx, unitType, unitId, state, accessors, tierBadge) {
     if (!ctx.hasUI)
         return;

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

@@ -291,34 +291,8 @@ export const DISPATCH_RULES = [
         },
     },
     {
-        name: "planning (no research, not S01) → research-slice",
-        match: async ({ state, mid, midTitle, basePath, prefs }) => {
-            if (state.phase !== "planning")
-                return null;
-            // Phase skip: skip research when preference or profile says so
-            if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
-                return null;
-            if (!state.activeSlice)
-                return missingSliceStop(mid, state.phase);
-            const sid = state.activeSlice.id;
-            const sTitle = state.activeSlice.title;
-            const researchFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
-            if (researchFile)
-                return null; // has research, fall through
-            // Skip slice research for S01 when milestone research already exists —
-            // the milestone research already covers the same ground for the first slice.
-            const milestoneResearchFile = resolveMilestoneFile(basePath, mid, "RESEARCH");
-            if (milestoneResearchFile && sid === "S01")
-                return null; // fall through to plan-slice
-            return {
-                action: "dispatch",
-                unitType: "research-slice",
-                unitId: `${mid}/${sid}`,
-                prompt: await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, basePath),
-            };
-        },
-    },
-    {
+        // Keep this rule before the single-slice research rule so the multi-slice
+        // path wins whenever 2+ slices are ready.
         name: "planning (multiple slices need research) → parallel-research-slices",
         match: async ({ state, mid, midTitle, basePath, prefs }) => {
             if (state.phase !== "planning")
@@ -360,6 +334,34 @@ export const DISPATCH_RULES = [
             };
         },
     },
+    {
+        name: "planning (no research, not S01) → research-slice",
+        match: async ({ state, mid, midTitle, basePath, prefs }) => {
+            if (state.phase !== "planning")
+                return null;
+            // Phase skip: skip research when preference or profile says so
+            if (prefs?.phases?.skip_research || prefs?.phases?.skip_slice_research)
+                return null;
+            if (!state.activeSlice)
+                return missingSliceStop(mid, state.phase);
+            const sid = state.activeSlice.id;
+            const sTitle = state.activeSlice.title;
+            const researchFile = resolveSliceFile(basePath, mid, sid, "RESEARCH");
+            if (researchFile)
+                return null; // has research, fall through
+            // Skip slice research for S01 when milestone research already exists —
+            // the milestone research already covers the same ground for the first slice.
+            const milestoneResearchFile = resolveMilestoneFile(basePath, mid, "RESEARCH");
+            if (milestoneResearchFile && sid === "S01")
+                return null; // fall through to plan-slice
+            return {
+                action: "dispatch",
+                unitType: "research-slice",
+                unitId: `${mid}/${sid}`,
+                prompt: await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, basePath),
+            };
+        },
+    },
     {
         name: "planning → plan-slice",
         match: async ({ state, mid, midTitle, basePath }) => {

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

@@ -252,8 +252,17 @@ export function resolveModelId(modelId, availableModels, currentProvider) {
         return undefined;
     if (candidates.length === 1)
         return candidates[0];
-    // Extension / CLI-wrapper providers that should never win bare-ID resolution
-    // when a first-class API provider also offers the same model.
+    // When the user's current provider is claude-code (set by startup migration
+    // or explicit selection), honour it for bare IDs.  Routing back to anthropic
+    // would undo the migration and hit the third-party subscription block (#3772).
+    if (currentProvider === "claude-code") {
+        const ccMatch = candidates.find(m => m.provider === "claude-code");
+        if (ccMatch)
+            return ccMatch;
+    }
+    // Extension / CLI-wrapper providers that should not win bare-ID resolution
+    // when a first-class API provider also offers the same model AND the user
+    // has not explicitly chosen the extension provider.
     const EXTENSION_PROVIDERS = new Set(["claude-code"]);
     // Prefer currentProvider only when it is a first-class API provider
     if (currentProvider && !EXTENSION_PROVIDERS.has(currentProvider)) {
@@ -274,7 +283,7 @@ export function resolveModelId(modelId, availableModels, currentProvider) {
  * Uses case-insensitive matching with alias support to prevent fail-open on
  * provider naming variations (e.g. "copilot" vs "github-copilot").
  */
-const FLAT_RATE_PROVIDERS = new Set(["github-copilot", "copilot"]);
+const FLAT_RATE_PROVIDERS = new Set(["github-copilot", "copilot", "claude-code"]);
 export function isFlatRateProvider(provider) {
     return FLAT_RATE_PROVIDERS.has(provider.toLowerCase());
 }

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

@@ -219,7 +219,12 @@ export async function inlineGsdRootFile(base, filename, label) {
 // ─── DB-Aware Inline Helpers ──────────────────────────────────────────────
 /**
  * Inline decisions with optional milestone scoping from the DB.
- * Falls back to filesystem via inlineGsdRootFile when DB unavailable or empty.
+ * Falls back to filesystem via inlineGsdRootFile only when DB is unavailable.
+ *
+ * Cascade logic (R005):
+ * 1. Query with { milestoneId, scope } if scope provided
+ * 2. If empty AND scope was provided, retry with { milestoneId } only (drop scope)
+ * 3. If still empty, return null (intentional per D020)
  */
 export async function inlineDecisionsFromDb(base, milestoneId, scope, level) {
     const inlineLevel = level ?? resolveInlineLevel();
@@ -227,7 +232,12 @@ export async function inlineDecisionsFromDb(base, milestoneId, scope, level) {
         const { isDbAvailable } = await import("./gsd-db.js");
         if (isDbAvailable()) {
             const { queryDecisions, formatDecisionsForPrompt } = await import("./context-store.js");
-            const decisions = queryDecisions({ milestoneId, scope });
+            // First query: try with both milestoneId and scope (if scope provided)
+            let decisions = queryDecisions({ milestoneId, scope });
+            // Cascade: if empty AND scope was provided, retry without scope
+            if (decisions.length === 0 && scope) {
+                decisions = queryDecisions({ milestoneId });
+            }
             if (decisions.length > 0) {
                 // Use compact format for non-full levels to save ~35% tokens
                 const formatted = inlineLevel !== "full"
@@ -235,24 +245,27 @@ export async function inlineDecisionsFromDb(base, milestoneId, scope, level) {
                     : formatDecisionsForPrompt(decisions);
                 return `### Decisions\nSource: \`.gsd/DECISIONS.md\`\n\n${formatted}`;
             }
+            // DB available but cascade returned empty — intentional per D020, don't fall back to file
+            return null;
         }
     }
     catch (err) {
         logWarning("prompt", `inlineDecisionsFromDb failed: ${err instanceof Error ? err.message : String(err)}`);
     }
+    // DB unavailable — fall back to filesystem
     return inlineGsdRootFile(base, "decisions.md", "Decisions");
 }
 /**
- * Inline requirements with optional slice scoping from the DB.
+ * Inline requirements with optional milestone and slice scoping from the DB.
  * Falls back to filesystem via inlineGsdRootFile when DB unavailable or empty.
  */
-export async function inlineRequirementsFromDb(base, sliceId, level) {
+export async function inlineRequirementsFromDb(base, milestoneId, sliceId, level) {
     const inlineLevel = level ?? resolveInlineLevel();
     try {
         const { isDbAvailable } = await import("./gsd-db.js");
         if (isDbAvailable()) {
             const { queryRequirements, formatRequirementsForPrompt } = await import("./context-store.js");
-            const requirements = queryRequirements({ sliceId });
+            const requirements = queryRequirements({ milestoneId, sliceId });
             if (requirements.length > 0) {
                 // Use compact format for non-full levels to save ~40% tokens
                 const formatted = inlineLevel !== "full"
@@ -287,6 +300,117 @@ export async function inlineProjectFromDb(base) {
     }
     return inlineGsdRootFile(base, "project.md", "Project");
 }
+// ─── Stopwords for keyword extraction ─────────────────────────────────────
+const STOPWORDS = new Set(['of', 'the', 'and', 'a', 'for', '+', '-', 'to', 'in', 'on', 'with', 'is', 'as', 'by']);
+// Generic words that don't provide meaningful scope differentiation
+const GENERIC_WORDS = new Set([
+    'setup', 'integration', 'implementation', 'testing', 'test', 'tests',
+    'config', 'configuration', 'init', 'initial', 'basic', 'core',
+    'main', 'primary', 'final', 'complete', 'finish', 'end',
+    'start', 'begin', 'first', 'last', 'update', 'updates',
+    'fix', 'fixes', 'add', 'adds', 'remove', 'removes',
+    'create', 'creates', 'build', 'builds', 'deploy', 'deployment',
+    'refactor', 'refactoring', 'cleanup', 'polish', 'review',
+    // Process/activity words that describe what you're doing, not what domain
+    'hardening', 'validation', 'verification', 'optimization',
+    'improvement', 'enhancement', 'infrastructure',
+]);
+// Pattern to match slice/milestone/task IDs (e.g., S01, M001, T03)
+const UNIT_ID_PATTERN = /^[smt]\d+$/i;
+/**
+ * Derive a scope keyword from slice title and optional description.
+ * Returns the most specific noun (first non-generic keyword) for decision scoping.
+ *
+ * Examples:
+ * - "Auth Middleware & Protected Route" → "auth"
+ * - "Database & User Model Setup" → "database"
+ * - "Integration Testing" → undefined (too generic)
+ * - "API Rate Limiting" → "api"
+ *
+ * @param sliceTitle - The slice title
+ * @param sliceDescription - Optional roadmap description (demo text)
+ * @returns A single lowercase keyword or undefined if no meaningful scope
+ */
+export function deriveSliceScope(sliceTitle, sliceDescription) {
+    // Combine title and description for keyword extraction
+    const combinedText = sliceDescription
+        ? `${sliceTitle} ${sliceDescription}`
+        : sliceTitle;
+    // Extract all words, lowercase, remove punctuation
+    const words = combinedText
+        .split(/[\s&+,;:|/\\()-]+/)
+        .map(w => w.toLowerCase().replace(/[^a-z0-9]/g, ''))
+        .filter(w => w.length >= 2);
+    // Find the first word that is:
+    // 1. Not a stopword
+    // 2. Not a generic word
+    // 3. Not a unit ID (S01, M001, T03)
+    // 4. At least 3 characters (meaningful scope)
+    for (const word of words) {
+        if (STOPWORDS.has(word))
+            continue;
+        if (GENERIC_WORDS.has(word))
+            continue;
+        if (UNIT_ID_PATTERN.test(word))
+            continue;
+        if (word.length < 3)
+            continue;
+        return word;
+    }
+    return undefined;
+}
+/**
+ * Extract keywords from a slice title for scoped knowledge queries.
+ * Splits on whitespace, filters stopwords, lowercases.
+ * Example: 'KNOWLEDGE scoping + roadmap excerpt' → ['knowledge', 'scoping', 'roadmap', 'excerpt']
+ */
+function extractKeywords(title) {
+    return title
+        .split(/\s+/)
+        .map(w => w.toLowerCase().replace(/[^a-z0-9]/g, ''))
+        .filter(w => w.length > 0 && !STOPWORDS.has(w));
+}
+/**
+ * Inline scoped KNOWLEDGE.md content based on keywords from slice title.
+ * Reads KNOWLEDGE.md, filters to sections matching keywords, formats with header.
+ * Returns null if no KNOWLEDGE.md exists or no sections match.
+ */
+export async function inlineKnowledgeScoped(base, keywords) {
+    const knowledgePath = resolveGsdRootFile(base, "KNOWLEDGE");
+    if (!existsSync(knowledgePath))
+        return null;
+    const content = await loadFile(knowledgePath);
+    if (!content)
+        return null;
+    // Import queryKnowledge from context-store
+    const { queryKnowledge } = await import("./context-store.js");
+    const scoped = await queryKnowledge(content, keywords);
+    // Return null if no sections matched (empty string from queryKnowledge)
+    if (!scoped)
+        return null;
+    return `### Project Knowledge (scoped)\nSource: \`${relGsdRootFile("KNOWLEDGE")}\`\n\n${scoped.trim()}`;
+}
+/**
+ * Inline a roadmap excerpt for a specific slice.
+ * Reads full roadmap, extracts minimal excerpt with header + predecessor + target row.
+ * Returns null if roadmap doesn't exist or slice not found.
+ */
+export async function inlineRoadmapExcerpt(base, mid, sid) {
+    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+    if (!roadmapPath || !existsSync(roadmapPath))
+        return null;
+    const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
+    const content = await loadFile(roadmapPath);
+    if (!content)
+        return null;
+    // Import formatRoadmapExcerpt from context-store
+    const { formatRoadmapExcerpt } = await import("./context-store.js");
+    const excerpt = formatRoadmapExcerpt(content, sid, roadmapRel);
+    // Return null if slice not found in roadmap
+    if (!excerpt)
+        return null;
+    return `### Milestone Roadmap (excerpt)\nSource: \`${roadmapRel}\`\n\n${excerpt}`;
+}
 // ─── Skill Activation & Discovery ─────────────────────────────────────────
 function normalizeSkillReference(ref) {
     const normalized = ref.replace(/\\/g, "/").trim();
@@ -772,7 +896,7 @@ export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     const projectInline = await inlineProjectFromDb(base);
     if (projectInline)
         inlined.push(projectInline);
-    const requirementsInline = await inlineRequirementsFromDb(base);
+    const requirementsInline = await inlineRequirementsFromDb(base, mid);
     if (requirementsInline)
         inlined.push(requirementsInline);
     const decisionsInline = await inlineDecisionsFromDb(base, mid);
@@ -823,7 +947,7 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
         const projectInline = await inlineProjectFromDb(base);
         if (projectInline)
             inlined.push(projectInline);
-        const requirementsInline = await inlineRequirementsFromDb(base, undefined, inlineLevel);
+        const requirementsInline = await inlineRequirementsFromDb(base, mid, undefined, inlineLevel);
         if (requirementsInline)
             inlined.push(requirementsInline);
         const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
@@ -884,7 +1008,15 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
     const sliceContextPath = resolveSliceFile(base, mid, sid, "CONTEXT");
     const sliceContextRel = relSliceFile(base, mid, sid, "CONTEXT");
     const inlined = [];
-    inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
+    // Use roadmap excerpt instead of full roadmap for context reduction
+    const roadmapExcerptRS = await inlineRoadmapExcerpt(base, mid, sid);
+    if (roadmapExcerptRS) {
+        inlined.push(roadmapExcerptRS);
+    }
+    else {
+        // Fall back to full roadmap if excerpt fails
+        inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
+    }
     const contextInline = await inlineFileOptional(contextPath, contextRel, "Milestone Context");
     if (contextInline)
         inlined.push(contextInline);
@@ -894,13 +1026,17 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
     const researchInline = await inlineFileOptional(milestoneResearchPath, milestoneResearchRel, "Milestone Research");
     if (researchInline)
         inlined.push(researchInline);
-    const decisionsInline = await inlineDecisionsFromDb(base, mid);
+    // Derive scope from slice title for decision filtering (R005)
+    const derivedScope = deriveSliceScope(sTitle);
+    const decisionsInline = await inlineDecisionsFromDb(base, mid, derivedScope);
     if (decisionsInline)
         inlined.push(decisionsInline);
-    const requirementsInline = await inlineRequirementsFromDb(base, sid);
+    const requirementsInline = await inlineRequirementsFromDb(base, mid, sid);
     if (requirementsInline)
         inlined.push(requirementsInline);
-    const knowledgeInlineRS = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
+    // Use scoped knowledge based on slice title keywords
+    const keywords = extractKeywords(sTitle);
+    const knowledgeInlineRS = await inlineKnowledgeScoped(base, keywords);
     if (knowledgeInlineRS)
         inlined.push(knowledgeInlineRS);
     inlined.push(inlineTemplate("research", "Research"));
@@ -944,7 +1080,15 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     const researchSliceAnchor = readPhaseAnchor(base, mid, "research-slice");
     if (researchSliceAnchor)
         inlined.push(formatAnchorForPrompt(researchSliceAnchor));
-    inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
+    // Use roadmap excerpt instead of full roadmap for context reduction
+    const roadmapExcerptPS = await inlineRoadmapExcerpt(base, mid, sid);
+    if (roadmapExcerptPS) {
+        inlined.push(roadmapExcerptPS);
+    }
+    else {
+        // Fall back to full roadmap if excerpt fails
+        inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
+    }
     const sliceCtxInline = await inlineFileOptional(sliceContextPath, sliceContextRel, "Slice Context (from discussion)");
     if (sliceCtxInline)
         inlined.push(sliceCtxInline);
@@ -952,14 +1096,18 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     if (researchInline)
         inlined.push(researchInline);
     if (inlineLevel !== "minimal") {
-        const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
+        // Derive scope from slice title for decision filtering (R005)
+        const derivedScopePS = deriveSliceScope(sTitle);
+        const decisionsInline = await inlineDecisionsFromDb(base, mid, derivedScopePS, inlineLevel);
         if (decisionsInline)
             inlined.push(decisionsInline);
-        const requirementsInline = await inlineRequirementsFromDb(base, sid, inlineLevel);
+        const requirementsInline = await inlineRequirementsFromDb(base, mid, sid, inlineLevel);
         if (requirementsInline)
             inlined.push(requirementsInline);
     }
-    const knowledgeInlinePS = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
+    // Use scoped knowledge based on slice title keywords
+    const keywordsPS = extractKeywords(sTitle);
+    const knowledgeInlinePS = await inlineKnowledgeScoped(base, keywordsPS);
     if (knowledgeInlinePS)
         inlined.push(knowledgeInlinePS);
     inlined.push(inlineTemplate("plan", "Slice Plan"));
@@ -1117,7 +1265,7 @@ export async function buildCompleteSlicePrompt(mid, _midTitle, sid, sTitle, base
         inlined.push(sliceCtxInline);
     inlined.push(await inlineFile(slicePlanPath, slicePlanRel, "Slice Plan"));
     if (inlineLevel !== "minimal") {
-        const requirementsInline = await inlineRequirementsFromDb(base, sid, inlineLevel);
+        const requirementsInline = await inlineRequirementsFromDb(base, mid, sid, inlineLevel);
         if (requirementsInline)
             inlined.push(requirementsInline);
     }
@@ -1195,7 +1343,7 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     }
     // Inline root GSD files (skip for minimal — completion can read these if needed)
     if (inlineLevel !== "minimal") {
-        const requirementsInline = await inlineRequirementsFromDb(base, undefined, inlineLevel);
+        const requirementsInline = await inlineRequirementsFromDb(base, mid, undefined, inlineLevel);
         if (requirementsInline)
             inlined.push(requirementsInline);
         const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
@@ -1262,7 +1410,7 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     catch (err) {
         logWarning("prompt", `buildValidateMilestonePrompt verification classes lookup failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    // Inline all slice summaries and UAT results
+    // Inline all slice summaries and assessment results
     let valSliceIds = [];
     try {
         const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
@@ -1288,11 +1436,11 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
         const summaryRel = relSliceFile(base, mid, sid, "SUMMARY");
         inlined.push(await inlineFile(summaryPath, summaryRel, `${sid} Summary`));
-        const uatPath = resolveSliceFile(base, mid, sid, "UAT");
-        const uatRel = relSliceFile(base, mid, sid, "UAT");
-        const uatInline = await inlineFileOptional(uatPath, uatRel, `${sid} UAT Result`);
-        if (uatInline)
-            inlined.push(uatInline);
+        const assessmentPath = resolveSliceFile(base, mid, sid, "ASSESSMENT");
+        const assessmentRel = relSliceFile(base, mid, sid, "ASSESSMENT");
+        const assessmentInline = await inlineFileOptional(assessmentPath, assessmentRel, `${sid} Assessment`);
+        if (assessmentInline)
+            inlined.push(assessmentInline);
     }
     // Aggregate unresolved follow-ups and known limitations across slices
     const outstandingItems = [];
@@ -1324,7 +1472,7 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     }
     // Inline root GSD files
     if (inlineLevel !== "minimal") {
-        const requirementsInline = await inlineRequirementsFromDb(base, undefined, inlineLevel);
+        const requirementsInline = await inlineRequirementsFromDb(base, mid, undefined, inlineLevel);
         if (requirementsInline)
             inlined.push(requirementsInline);
         const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);
@@ -1487,7 +1635,7 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
         const projectInline = await inlineProjectFromDb(base);
         if (projectInline)
             inlined.push(projectInline);
-        const requirementsInline = await inlineRequirementsFromDb(base, undefined, inlineLevel);
+        const requirementsInline = await inlineRequirementsFromDb(base, mid, undefined, inlineLevel);
         if (requirementsInline)
             inlined.push(requirementsInline);
         const decisionsInline = await inlineDecisionsFromDb(base, mid, undefined, inlineLevel);

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

@@ -10,7 +10,7 @@ import { parseUnitId } from "./unit-id.js";
 import { appendEvent } from "./workflow-events.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -198,8 +198,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         if (gateIds.length === 0)
             return true;
         try {
-            const { getPendingGates: getPending } = require("./gsd-db.js");
-            const pending = getPending(mid, sid, "slice");
+            const pending = getPendingGates(mid, sid, "slice");
             const pendingIds = new Set(pending.map((g) => g.gate_id));
             // All dispatched gates must no longer be pending
             for (const gid of gateIds) {
@@ -454,9 +453,8 @@ function abortAndResetMerge(basePath, hasMergeHead, squashMsgPath) {
 /**
  * Detect leftover merge state from a prior session and reconcile it.
  * If MERGE_HEAD or SQUASH_MSG exists, check whether conflicts are resolved.
- * If resolved: finalize the commit. If still conflicted: abort and reset.
- *
- * Returns true if state was dirty and re-derivation is needed.
+ * If resolved: finalize the commit. If only .gsd conflicts remain: auto-resolve.
+ * If code conflicts remain: fail safe without modifying the worktree.
  */
 export function reconcileMergeState(basePath, ctx) {
     const mergeHeadPath = join(basePath, ".git", "MERGE_HEAD");
@@ -464,7 +462,7 @@ export function reconcileMergeState(basePath, ctx) {
     const hasMergeHead = existsSync(mergeHeadPath);
     const hasSquashMsg = existsSync(squashMsgPath);
     if (!hasMergeHead && !hasSquashMsg)
-        return false;
+        return "clean";
     const conflictedFiles = nativeConflictFiles(basePath);
     if (conflictedFiles.length === 0) {
         // All conflicts resolved — finalize the merge/squash commit
@@ -481,7 +479,7 @@ export function reconcileMergeState(basePath, ctx) {
         catch (err) {
             const errorMessage = getErrorMessage(err);
             ctx.ui.notify(`Failed to finalize leftover merge/squash commit: ${errorMessage}`, "error");
-            return false;
+            return "blocked";
         }
     }
     else {
@@ -515,12 +513,13 @@ export function reconcileMergeState(basePath, ctx) {
             }
         }
         else {
-            // Code conflicts present — abort and reset
-            abortAndResetMerge(basePath, hasMergeHead, squashMsgPath);
-            ctx.ui.notify("Detected leftover merge state with unresolved conflicts — cleaned up. Re-deriving state.", "warning");
+            // Code conflicts present — fail safe and preserve any manual resolution
+            // work instead of discarding it with merge --abort/reset --hard.
+            ctx.ui.notify("Detected leftover merge state with unresolved code conflicts. Auto-mode will pause without modifying the worktree so manual conflict resolution is preserved.", "error");
+            return "blocked";
         }
     }
-    return true;
+    return "reconciled";
 }
 // ─── Loop Remediation ─────────────────────────────────────────────────────────
 /**

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

@@ -906,7 +906,19 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.active = true;
         s.verbose = verboseMode;
         s.stepMode = requestedStepMode;
-        s.cmdCtx = ctx;
+        // Preserve the original cmdCtx (ExtensionCommandContext with newSession)
+        // when resuming from a provider-error pause. The resume callback receives
+        // an ExtensionContext (from the agent_end hook) which lacks newSession —
+        // using it would crash runUnit with "newSession is not a function".
+        // Only override if the new ctx actually has newSession (user-initiated resume).
+        if ("newSession" in ctx && typeof ctx.newSession === "function") {
+            s.cmdCtx = ctx;
+        }
+        else if (!s.cmdCtx) {
+            // No saved cmdCtx — this shouldn't happen, but handle gracefully
+            s.cmdCtx = ctx;
+        }
+        // else: keep existing s.cmdCtx which has the real newSession
         s.basePath = base;
         setLogBasePath(base);
         if (!s.autoStartTime || s.autoStartTime <= 0)