gsd-pi 2.66.0 → 2.66.1-dev.3c26b49

package/dist/claude-cli-check.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if the `claude` binary is installed (regardless of auth state).
+ */
+export declare function isClaudeBinaryInstalled(): boolean;
+/**
+ * Check if the `claude` CLI is installed AND authenticated.
+ */
+export declare function isClaudeCliReady(): boolean;

package/dist/claude-cli-check.js

@@ -0,0 +1,36 @@
+// GSD2 — Claude CLI binary detection for onboarding
+// Lightweight check used at onboarding time (before extensions load).
+// The full readiness check with caching lives in the claude-code-cli extension.
+import { execFileSync } from 'node:child_process';
+/**
+ * Check if the `claude` binary is installed (regardless of auth state).
+ */
+export function isClaudeBinaryInstalled() {
+    try {
+        execFileSync('claude', ['--version'], { timeout: 5_000, stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if the `claude` CLI is installed AND authenticated.
+ */
+export function isClaudeCliReady() {
+    try {
+        execFileSync('claude', ['--version'], { timeout: 5_000, stdio: 'pipe' });
+    }
+    catch {
+        return false;
+    }
+    try {
+        const output = execFileSync('claude', ['auth', 'status'], { timeout: 5_000, stdio: 'pipe' })
+            .toString()
+            .toLowerCase();
+        return !(/not logged in|no credentials|unauthenticated|not authenticated/i.test(output));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli.js

@@ -395,8 +395,28 @@ if (isPrintMode) {
         settingsManager,
         sessionManager,
         resourceLoader,
+        isClaudeCodeReady: () => modelRegistry.isProviderRequestReady('claude-code'),
     });
     markStartup('createAgentSession');
+    // Migrate anthropic OAuth users to claude-code provider when CLI is available (#3772).
+    // Anthropic blocks third-party apps from using subscription quotas — routing through
+    // the local claude CLI binary is TOS-compliant.
+    if (modelRegistry.isProviderRequestReady('claude-code') && settingsManager.getDefaultProvider() === 'anthropic') {
+        const currentModelId = settingsManager.getDefaultModel();
+        if (currentModelId) {
+            const ccModel = modelRegistry.find('claude-code', currentModelId);
+            if (ccModel) {
+                try {
+                    await session.setModel(ccModel);
+                    // Only persist after successful session switch to avoid desync
+                    settingsManager.setDefaultModelAndProvider('claude-code', currentModelId);
+                }
+                catch {
+                    // claude-code provider not ready — leave both session and settings unchanged
+                }
+            }
+        }
+    }
     // Validate configured model AFTER extensions have registered their models (#2626).
     // Before this, extension-provided models (e.g. claude-code/*) were not yet in the
     // registry, causing the user's valid choice to be silently overwritten.
@@ -550,8 +570,28 @@ const { session, extensionsResult, modelFallbackMessage: interactiveFallbackMsg
     settingsManager,
     sessionManager,
     resourceLoader,
+    isClaudeCodeReady: () => modelRegistry.isProviderRequestReady('claude-code'),
 });
 markStartup('createAgentSession');
+// Migrate anthropic OAuth users to claude-code provider when CLI is available (#3772).
+// Anthropic blocks third-party apps from using subscription quotas — routing through
+// the local claude CLI binary is TOS-compliant.
+if (modelRegistry.isProviderRequestReady('claude-code') && settingsManager.getDefaultProvider() === 'anthropic') {
+    const currentModelId = settingsManager.getDefaultModel();
+    if (currentModelId) {
+        const ccModel = modelRegistry.find('claude-code', currentModelId);
+        if (ccModel) {
+            try {
+                await session.setModel(ccModel);
+                // Only persist after successful session switch to avoid desync
+                settingsManager.setDefaultModelAndProvider('claude-code', currentModelId);
+            }
+            catch {
+                // claude-code provider not ready — leave both session and settings unchanged
+            }
+        }
+    }
+}
 // Validate configured model AFTER extensions have registered their models (#2626).
 // Before this, extension-provided models (e.g. claude-code/*) were not yet in the
 // registry, causing the user's valid choice to be silently overwritten.

package/dist/onboarding.js

@@ -14,6 +14,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { renderLogo } from './logo.js';
 import { agentDir } from './app-paths.js';
+import { isClaudeCliReady } from './claude-cli-check.js';
 // ─── Constants ────────────────────────────────────────────────────────────────
 const TOOL_KEYS = [
     {
@@ -39,6 +40,7 @@ const TOOL_KEYS = [
 const LLM_PROVIDER_IDS = [
     'anthropic',
     'anthropic-vertex',
+    'claude-code',
     'openai',
     'github-copilot',
     'openai-codex',
@@ -255,7 +257,12 @@ async function runLlmStep(p, pc, authStorage) {
     if (existingAuth) {
         authOptions.push({ value: 'keep', label: `Keep current (${existingAuth})`, hint: 'already configured' });
     }
-    authOptions.push({ value: 'browser', label: 'Sign in with your browser', hint: 'recommended — same login as claude.ai / ChatGPT' }, { value: 'api-key', label: 'Paste an API key', hint: 'from your provider dashboard' }, { value: 'skip', label: 'Skip for now', hint: 'use /login inside GSD later' });
+    // Show Claude Code CLI option at the top when the CLI is installed and authenticated (#3772).
+    // This is the only TOS-compliant path for Anthropic subscription users.
+    if (isClaudeCliReady()) {
+        authOptions.push({ value: 'claude-cli', label: 'Use Claude Code CLI', hint: 'recommended — uses your existing Claude subscription' });
+    }
+    authOptions.push({ value: 'browser', label: 'Sign in with your browser', hint: 'GitHub Copilot, ChatGPT, Google, etc.' }, { value: 'api-key', label: 'Paste an API key', hint: 'from your provider dashboard' }, { value: 'skip', label: 'Skip for now', hint: 'use /login inside GSD later' });
     const method = await p.select({
         message: existingAuth ? `LLM provider: ${existingAuth} — change it?` : 'How do you want to sign in?',
         options: authOptions,
@@ -264,12 +271,22 @@ async function runLlmStep(p, pc, authStorage) {
         return false;
     if (method === 'keep')
         return true;
+    // ── Claude Code CLI path (#3772) ────────────────────────────────────────
+    if (method === 'claude-cli') {
+        p.log.success('Claude Code CLI detected — routing through local CLI (TOS-compliant)');
+        p.log.info('Your Claude subscription will be used for inference. No API key needed.');
+        // Store sentinel so hasAuth('claude-code') returns true on future boots
+        authStorage.set('claude-code', { type: 'api_key', key: 'cli' });
+        return true;
+    }
     // ── Step 2: Which provider? ──────────────────────────────────────────────
     if (method === 'browser') {
+        // Anthropic OAuth is removed from browser auth — it violates Anthropic TOS for
+        // third-party apps (#3772). Anthropic subscription users should use the Claude
+        // Code CLI path (shown above when CLI is installed) or paste an API key.
         const provider = await p.select({
             message: 'Choose provider',
             options: [
-                { value: 'anthropic', label: 'Anthropic (Claude)', hint: 'recommended' },
                 { value: 'github-copilot', label: 'GitHub Copilot' },
                 { value: 'openai-codex', label: 'ChatGPT Plus/Pro (Codex)' },
                 { value: 'google-gemini-cli', label: 'Google Gemini CLI' },

package/dist/resources/extensions/claude-code-cli/readiness.js

@@ -1,26 +1,77 @@
 /**
  * Readiness check for the Claude Code CLI provider.
  *
- * Verifies the `claude` binary is installed and responsive.
- * Result is cached for 30 seconds to avoid shelling out on every
+ * Verifies the `claude` binary is installed, responsive, AND authenticated.
+ * Results are cached for 30 seconds to avoid shelling out on every
  * model-availability check.
+ *
+ * Auth verification follows the T3 Code pattern: run `claude auth status`
+ * and check the exit code + output for an authenticated session.
  */
-import { execSync } from "node:child_process";
-let cachedReady = null;
+import { execFileSync } from "node:child_process";
+let cachedBinaryPresent = null;
+let cachedAuthed = null;
 let lastCheckMs = 0;
 const CHECK_INTERVAL_MS = 30_000;
-export function isClaudeCodeReady() {
+function refreshCache() {
     const now = Date.now();
-    if (cachedReady !== null && now - lastCheckMs < CHECK_INTERVAL_MS) {
-        return cachedReady;
+    if (cachedBinaryPresent !== null && now - lastCheckMs < CHECK_INTERVAL_MS) {
+        return;
     }
+    // Set timestamp first to prevent re-entrant checks during the same window
+    lastCheckMs = now;
+    // Check binary presence
     try {
-        execSync("claude --version", { timeout: 5_000, stdio: "pipe" });
-        cachedReady = true;
+        execFileSync("claude", ["--version"], { timeout: 5_000, stdio: "pipe" });
+        cachedBinaryPresent = true;
     }
     catch {
-        cachedReady = false;
+        cachedBinaryPresent = false;
+        cachedAuthed = false;
+        return;
     }
-    lastCheckMs = now;
-    return cachedReady;
+    // Check auth status — exit code 0 with non-error output means authenticated
+    try {
+        const output = execFileSync("claude", ["auth", "status"], { timeout: 5_000, stdio: "pipe" })
+            .toString()
+            .toLowerCase();
+        // The CLI outputs "not logged in", "no credentials", or similar when unauthenticated
+        cachedAuthed = !(/not logged in|no credentials|unauthenticated|not authenticated/i.test(output));
+    }
+    catch {
+        // Non-zero exit code means not authenticated
+        cachedAuthed = false;
+    }
+}
+/**
+ * Whether the `claude` binary is installed (regardless of auth state).
+ */
+export function isClaudeBinaryPresent() {
+    refreshCache();
+    return cachedBinaryPresent ?? false;
+}
+/**
+ * Whether the `claude` CLI is authenticated with a valid session.
+ * Returns false if the binary is not installed.
+ */
+export function isClaudeCodeAuthed() {
+    refreshCache();
+    return (cachedBinaryPresent ?? false) && (cachedAuthed ?? false);
+}
+/**
+ * Full readiness check: binary installed AND authenticated.
+ * This is the gating function used by the provider registration.
+ */
+export function isClaudeCodeReady() {
+    refreshCache();
+    return (cachedBinaryPresent ?? false) && (cachedAuthed ?? false);
+}
+/**
+ * Force-clear the cached readiness state.
+ * Useful after the user completes auth setup so the next check is fresh.
+ */
+export function clearReadinessCache() {
+    cachedBinaryPresent = null;
+    cachedAuthed = null;
+    lastCheckMs = 0;
 }

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

@@ -947,8 +947,21 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
             debugLog("autoLoop", { phase: "exit", reason: "provider-pause", isTransient: unitResult.errorContext.isTransient });
             return { action: "break", reason: "provider-pause" };
         }
-        ctx.ui.notify(`Session creation timed out or was cancelled for ${unitType} ${unitId}. Will retry.`, "warning");
-        await deps.stopAuto(ctx, pi, "Session creation failed");
+        // Session creation timeout (not a structural error): pause auto-mode
+        // and let the provider-error-resume timer handle recovery. This matches
+        // the provider-pause path — break out cleanly, don't hard-stop.
+        // Structural errors (TypeError, is not a function) are NOT transient
+        // and must hard-stop to avoid infinite retry loops.
+        if (unitResult.errorContext?.isTransient &&
+            unitResult.errorContext?.category === "timeout") {
+            ctx.ui.notify(`Session creation timed out for ${unitType} ${unitId}. Will retry.`, "warning");
+            debugLog("autoLoop", { phase: "session-timeout-pause", unitType, unitId });
+            await deps.pauseAuto(ctx, pi);
+            return { action: "break", reason: "session-timeout" };
+        }
+        // All other cancelled states (structural errors, non-transient failures): hard stop
+        ctx.ui.notify(`Session creation failed for ${unitType} ${unitId}: ${unitResult.errorContext?.message ?? "unknown"}. Stopping auto-mode.`, "warning");
+        await deps.stopAuto(ctx, pi, `Session creation failed: ${unitResult.errorContext?.message ?? "unknown"}`);
         debugLog("autoLoop", { phase: "exit", reason: "session-failed" });
         return { action: "break", reason: "session-failed" };
     }

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);
@@ -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.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)