gsd-pi 2.38.0-dev.63ad7e5 → 2.38.0-dev.785052f

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

@@ -72,11 +72,21 @@ export async function postUnitPreVerification(pctx, opts) {
                             const summaryContent = await loadFile(summaryPath);
                             if (summaryContent) {
                                 const summary = parseSummary(summaryContent);
+                                // Look up GitHub issue number for commit linking
+                                let ghIssueNumber;
+                                try {
+                                    const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+                                    ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
+                                }
+                                catch {
+                                    // GitHub sync not available — skip
+                                }
                                 taskContext = {
                                     taskId: `${sid}/${tid}`,
                                     taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
                                     oneLiner: summary.oneLiner || undefined,
                                     keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                                    issueNumber: ghIssueNumber,
                                 };
                             }
                         }
@@ -94,6 +104,14 @@ export async function postUnitPreVerification(pctx, opts) {
         catch (e) {
             debugLog("postUnit", { phase: "auto-commit", error: String(e) });
         }
+        // GitHub sync (non-blocking, opt-in)
+        try {
+            const { runGitHubSync } = await import("../github-sync/sync.js");
+            await runGitHubSync(s.basePath, s.currentUnit.type, s.currentUnit.id);
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "github-sync", error: String(e) });
+        }
         // Doctor: fix mechanical bookkeeping (skipped for lightweight sidecars)
         if (!opts?.skipDoctor)
             try {
@@ -105,12 +123,18 @@ export async function postUnitPreVerification(pctx, opts) {
                 if (report.fixesApplied.length > 0) {
                     ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
                 }
-                // Proactive health tracking
-                const summary = summarizeDoctorIssues(report.issues);
+                // Proactive health tracking — filter to current milestone to avoid
+                // cross-milestone stale errors inflating the escalation counter
+                const currentMilestoneId = s.currentUnit.id.split("/")[0];
+                const milestoneIssues = currentMilestoneId
+                    ? report.issues.filter(i => i.unitId === currentMilestoneId ||
+                        i.unitId.startsWith(`${currentMilestoneId}/`))
+                    : report.issues;
+                const summary = summarizeDoctorIssues(milestoneIssues);
                 recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
                 // Check if we should escalate to LLM-assisted heal
                 if (summary.errors > 0) {
-                    const unresolvedErrors = report.issues
+                    const unresolvedErrors = milestoneIssues
                         .filter(i => i.severity === "error" && !i.fixable)
                         .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
                     const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
@@ -123,6 +147,7 @@ export async function postUnitPreVerification(pctx, opts) {
                             const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
                             const structuredIssues = formatDoctorIssuesForPrompt(actionable);
                             dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
+                            return "dispatched";
                         }
                         catch (e) {
                             debugLog("postUnit", { phase: "doctor-heal-dispatch", error: String(e) });

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

@@ -5,14 +5,22 @@
  * state, no globals — every dependency is passed as a parameter or imported as a
  * utility.
  */
-import { loadFile, parseContinue, parsePlan, parseRoadmap, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection } from "./files.js";
+import { loadFile, parseContinue, parsePlan, parseRoadmap, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
-import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, } from "./paths.js";
-import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
-import { join } from "node:path";
+import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
+import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
+import { getLoadedSkills } from "@gsd/pi-coding-agent";
+import { join, basename } from "node:path";
 import { existsSync } from "node:fs";
-import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
+import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
+// ─── Preamble Cap ─────────────────────────────────────────────────────────────
+const MAX_PREAMBLE_CHARS = 30_000;
+function capPreamble(preamble) {
+    if (preamble.length <= MAX_PREAMBLE_CHARS)
+        return preamble;
+    return truncateAtSectionBoundary(preamble, MAX_PREAMBLE_CHARS).content;
+}
 // ─── Executor Constraints ─────────────────────────────────────────────────────
 /**
  * Format executor context constraints for injection into the plan-slice prompt.
@@ -124,7 +132,6 @@ export async function inlineFileSmart(absPath, relPath, label, query, threshold
         return `### ${label}\nSource: \`${relPath}\`\n\n${content.trim()}`;
     }
     // For large files, truncate at section boundary
-    const { truncateAtSectionBoundary } = await import("./context-budget.js");
     const truncated = truncateAtSectionBoundary(content, threshold).content;
     return `### ${label}\nSource: \`${relPath}\`\n\n${truncated}`;
 }
@@ -158,7 +165,6 @@ export async function inlineDependencySummaries(mid, sid, base, budgetChars) {
     }
     const result = sections.join("\n\n");
     if (budgetChars !== undefined && result.length > budgetChars) {
-        const { truncateAtSectionBoundary } = await import("./context-budget.js");
         return truncateAtSectionBoundary(result, budgetChars).content;
     }
     return result;
@@ -245,7 +251,129 @@ export async function inlineProjectFromDb(base) {
     }
     return inlineGsdRootFile(base, "project.md", "Project");
 }
-// ─── Skill Discovery ──────────────────────────────────────────────────────
+// ─── Skill Activation & Discovery ─────────────────────────────────────────
+function normalizeSkillReference(ref) {
+    const normalized = ref.replace(/\\/g, "/").trim();
+    const base = basename(normalized).replace(/\.md$/i, "");
+    const name = /^SKILL$/i.test(base)
+        ? basename(normalized.replace(/\/SKILL(?:\.md)?$/i, ""))
+        : base;
+    return name.trim().toLowerCase();
+}
+function tokenizeSkillContext(...parts) {
+    const tokens = new Set();
+    const addVariants = (raw) => {
+        const value = raw.trim().toLowerCase();
+        if (!value || value.length < 2)
+            return;
+        tokens.add(value);
+        tokens.add(value.replace(/[-_]+/g, " "));
+        tokens.add(value.replace(/\s+/g, "-"));
+        tokens.add(value.replace(/\s+/g, ""));
+    };
+    for (const part of parts) {
+        if (!part)
+            continue;
+        const text = part.toLowerCase();
+        const phraseMatches = text.match(/[a-z0-9][a-z0-9+.#/_-]{1,}/g) ?? [];
+        for (const match of phraseMatches) {
+            addVariants(match);
+            for (const piece of match.split(/[^a-z0-9+.#]+/g)) {
+                if (piece.length >= 3)
+                    addVariants(piece);
+            }
+        }
+    }
+    return tokens;
+}
+function skillMatchesContext(skill, contextTokens) {
+    const haystacks = [
+        skill.name.toLowerCase(),
+        skill.name.toLowerCase().replace(/[-_]+/g, " "),
+        skill.description.toLowerCase(),
+    ];
+    return [...contextTokens].some(token => token.length >= 3 && haystacks.some(haystack => haystack.includes(token)));
+}
+function resolvePreferenceSkillNames(refs, base) {
+    if (refs.length === 0)
+        return [];
+    const prefs = { always_use_skills: refs };
+    const report = resolveAllSkillReferences(prefs, base);
+    return refs.map(ref => {
+        const resolution = report.resolutions.get(ref);
+        return normalizeSkillReference(resolution?.resolvedPath ?? ref);
+    }).filter(Boolean);
+}
+function ruleMatchesContext(when, contextTokens) {
+    const whenTokens = tokenizeSkillContext(when);
+    return [...whenTokens].some(token => contextTokens.has(token) || [...contextTokens].some(ctx => ctx.includes(token) || token.includes(ctx)));
+}
+function resolveSkillRuleMatches(prefs, contextTokens, base) {
+    if (!prefs?.skill_rules?.length)
+        return { include: [], avoid: [] };
+    const include = [];
+    const avoid = [];
+    for (const rule of prefs.skill_rules) {
+        if (!ruleMatchesContext(rule.when, contextTokens))
+            continue;
+        include.push(...resolvePreferenceSkillNames([...(rule.use ?? []), ...(rule.prefer ?? [])], base));
+        avoid.push(...resolvePreferenceSkillNames(rule.avoid ?? [], base));
+    }
+    return { include, avoid };
+}
+function resolvePreferredSkillNames(prefs, visibleSkills, contextTokens, base) {
+    if (!prefs?.prefer_skills?.length)
+        return [];
+    const preferred = new Set(resolvePreferenceSkillNames(prefs.prefer_skills, base));
+    return visibleSkills
+        .filter(skill => preferred.has(normalizeSkillReference(skill.name)) && skillMatchesContext(skill, contextTokens))
+        .map(skill => normalizeSkillReference(skill.name));
+}
+function formatSkillActivationBlock(skillNames) {
+    if (skillNames.length === 0)
+        return "";
+    const calls = skillNames.map(name => `Call Skill('${name}')`).join('. ');
+    return `<skill_activation>${calls}.</skill_activation>`;
+}
+export function buildSkillActivationBlock(params) {
+    const prefs = params.preferences ?? loadEffectiveGSDPreferences()?.preferences;
+    const contextTokens = tokenizeSkillContext(params.milestoneId, params.milestoneTitle, params.sliceId, params.sliceTitle, params.taskId, params.taskTitle, ...(params.extraContext ?? []), params.taskPlanContent ?? undefined);
+    const visibleSkills = getLoadedSkills().filter(skill => !skill.disableModelInvocation);
+    const installedNames = new Set(visibleSkills.map(skill => normalizeSkillReference(skill.name)));
+    const avoided = new Set(resolvePreferenceSkillNames(prefs?.avoid_skills ?? [], params.base));
+    const matched = new Set();
+    for (const name of resolvePreferenceSkillNames(prefs?.always_use_skills ?? [], params.base)) {
+        matched.add(name);
+    }
+    const ruleMatches = resolveSkillRuleMatches(prefs, contextTokens, params.base);
+    for (const name of ruleMatches.include)
+        matched.add(name);
+    for (const name of ruleMatches.avoid)
+        avoided.add(name);
+    for (const name of resolvePreferredSkillNames(prefs, visibleSkills, contextTokens, params.base)) {
+        matched.add(name);
+    }
+    if (params.taskPlanContent) {
+        try {
+            const taskPlan = parseTaskPlanFile(params.taskPlanContent);
+            for (const skillName of taskPlan.frontmatter.skills_used) {
+                matched.add(normalizeSkillReference(skillName));
+            }
+        }
+        catch {
+            // Non-fatal — malformed task plan should not break prompt construction
+        }
+    }
+    for (const skill of visibleSkills) {
+        if (skillMatchesContext(skill, contextTokens)) {
+            matched.add(normalizeSkillReference(skill.name));
+        }
+    }
+    const ordered = [...matched]
+        .filter(name => installedNames.has(name) && !avoided.has(name))
+        .sort();
+    return formatSkillActivationBlock(ordered);
+}
 /**
  * Build the skill discovery template variables for research prompts.
  * Returns { skillDiscoveryMode, skillDiscoveryInstructions } for template substitution.
@@ -525,7 +653,7 @@ export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     if (knowledgeInlineRM)
         inlined.push(knowledgeInlineRM);
     inlined.push(inlineTemplate("research", "Research"));
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const outputRelPath = relMilestoneFile(base, mid, "RESEARCH");
     return loadPrompt("research-milestone", {
         workingDirectory: base,
@@ -534,6 +662,12 @@ export async function buildResearchMilestonePrompt(mid, midTitle, base) {
         contextPath: contextRel,
         outputPath: join(base, outputRelPath),
         inlinedContext,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            extraContext: [inlinedContext],
+        }),
         ...buildSkillDiscoveryVars(),
     });
 }
@@ -578,7 +712,7 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
         inlined.push(inlineTemplate("plan", "Slice Plan"));
         inlined.push(inlineTemplate("task-plan", "Task Plan"));
     }
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const outputRelPath = relMilestoneFile(base, mid, "ROADMAP");
     const researchOutputPath = join(base, relMilestoneFile(base, mid, "RESEARCH"));
     const secretsOutputPath = join(base, relMilestoneFile(base, mid, "SECRETS"));
@@ -593,6 +727,12 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
         secretsOutputPath,
         inlinedContext,
         sourceFilePaths: buildSourceFilePaths(base, mid),
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            extraContext: [inlinedContext],
+        }),
         ...buildSkillDiscoveryVars(),
     });
 }
@@ -626,7 +766,7 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
     const overridesInline = formatOverridesSection(activeOverrides);
     if (overridesInline)
         inlined.unshift(overridesInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const outputRelPath = relSliceFile(base, mid, sid, "RESEARCH");
     return loadPrompt("research-slice", {
         workingDirectory: base,
@@ -638,6 +778,13 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
         outputPath: join(base, outputRelPath),
         inlinedContext,
         dependencySummaries: depContent,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            sliceId: sid,
+            sliceTitle: sTitle,
+            extraContext: [inlinedContext, depContent],
+        }),
         ...buildSkillDiscoveryVars(),
     });
 }
@@ -672,7 +819,7 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     const planOverridesInline = formatOverridesSection(planActiveOverrides);
     if (planOverridesInline)
         inlined.unshift(planOverridesInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     // Build executor context constraints from the budget engine
     const executorContextConstraints = formatExecutorConstraints();
     const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
@@ -693,6 +840,13 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
         sourceFilePaths: buildSourceFilePaths(base, mid, sid),
         executorContextConstraints,
         commitInstruction,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            sliceId: sid,
+            sliceTitle: sTitle,
+            extraContext: [inlinedContext, depContent],
+        }),
     });
 }
 export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base, level) {
@@ -760,11 +914,17 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const carryForwardBudget = Math.floor(budgets.inlineContextBudgetChars * 0.4);
     let finalCarryForward = carryForwardSection;
     if (carryForwardSection.length > carryForwardBudget) {
-        const { truncateAtSectionBoundary } = await import("./context-budget.js");
         finalCarryForward = truncateAtSectionBoundary(carryForwardSection, carryForwardBudget).content;
     }
+    // Inline RUNTIME.md if present
+    const runtimePath = resolveRuntimeFile(base);
+    const runtimeContent = existsSync(runtimePath) ? await loadFile(runtimePath) : null;
+    const runtimeContext = runtimeContent
+        ? `### Runtime Context\nSource: \`.gsd/RUNTIME.md\`\n\n${runtimeContent.trim()}`
+        : "";
     return loadPrompt("execute-task", {
         overridesSection,
+        runtimeContext,
         workingDirectory: base,
         milestoneId: mid, sliceId: sid, sliceTitle: sTitle, taskId: tid, taskTitle: tTitle,
         planPath: join(base, relSliceFile(base, mid, sid, "PLAN")),
@@ -778,6 +938,16 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
         taskSummaryPath,
         inlinedTemplates,
         verificationBudget,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            sliceId: sid,
+            sliceTitle: sTitle,
+            taskId: tid,
+            taskTitle: tTitle,
+            taskPlanContent,
+            extraContext: [taskPlanInline, slicePlanExcerpt, finalCarryForward, resumeSection],
+        }),
     });
 }
 export async function buildCompleteSlicePrompt(mid, _midTitle, sid, sTitle, base, level) {
@@ -819,7 +989,7 @@ export async function buildCompleteSlicePrompt(mid, _midTitle, sid, sTitle, base
     const completeOverridesInline = formatOverridesSection(completeActiveOverrides);
     if (completeOverridesInline)
         inlined.unshift(completeOverridesInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const sliceRel = relSlicePath(base, mid, sid);
     const sliceSummaryPath = join(base, `${sliceRel}/${sid}-SUMMARY.md`);
     const sliceUatPath = join(base, `${sliceRel}/${sid}-UAT.md`);
@@ -875,7 +1045,7 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     if (contextInline)
         inlined.push(contextInline);
     inlined.push(inlineTemplate("milestone-summary", "Milestone Summary"));
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const milestoneSummaryPath = join(base, `${relMilestonePath(base, mid)}/${mid}-SUMMARY.md`);
     return loadPrompt("complete-milestone", {
         workingDirectory: base,
@@ -942,7 +1112,7 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     const contextInline = await inlineFileOptional(contextPath, contextRel, "Milestone Context");
     if (contextInline)
         inlined.push(contextInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const validationOutputPath = join(base, `${relMilestonePath(base, mid)}/${mid}-VALIDATION.md`);
     const roadmapOutputPath = `${relMilestonePath(base, mid)}/${mid}-ROADMAP.md`;
     return loadPrompt("validate-milestone", {
@@ -990,7 +1160,7 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
     const replanOverridesInline = formatOverridesSection(replanActiveOverrides);
     if (replanOverridesInline)
         inlined.unshift(replanOverridesInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const replanPath = join(base, `${relSlicePath(base, mid, sid)}/${sid}-REPLAN.md`);
     // Build capture context for replan prompt (captures that triggered this replan)
     let captureContext = "(none)";
@@ -1015,6 +1185,14 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
         inlinedContext,
         replanPath,
         captureContext,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            sliceId: sid,
+            sliceTitle: sTitle,
+            extraContext: [inlinedContext, captureContext],
+        }),
     });
 }
 export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base) {
@@ -1030,7 +1208,7 @@ export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base)
     const projectInline = await inlineProjectFromDb(base);
     if (projectInline)
         inlined.push(projectInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "UAT-RESULT"));
     const uatType = extractUatType(uatContent) ?? "human-experience";
     return loadPrompt("run-uat", {
@@ -1066,7 +1244,7 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
     const knowledgeInlineRA = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
     if (knowledgeInlineRA)
         inlined.push(knowledgeInlineRA);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const assessmentPath = join(base, relSliceFile(base, mid, completedSliceId, "ASSESSMENT"));
     // Build deferred captures context for reassess prompt
     let deferredCaptures = "(none)";

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

@@ -15,10 +15,10 @@ import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, removeWorktree, worktreePath, } from "./worktree-manager.js";
 import { detectWorktreeName, nudgeGitBranchCache, } from "./worktree.js";
-import { MergeConflictError, readIntegrationBranch } from "./git-service.js";
+import { MergeConflictError, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
 import { parseRoadmap } from "./files.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { nativeGetCurrentBranch, nativeWorkingTreeStatus, nativeAddAll, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, } from "./native-git-bridge.js";
 // ─── Module State ──────────────────────────────────────────────────────────
 /** Original project root before chdir into auto-worktree. */
 let originalBase = null;
@@ -656,7 +656,7 @@ function autoCommitDirtyState(cwd) {
         const status = nativeWorkingTreeStatus(cwd);
         if (!status)
             return false;
-        nativeAddAll(cwd);
+        nativeAddAllWithExclusions(cwd, RUNTIME_EXCLUSION_PATHS);
         const result = nativeCommit(cwd, "chore: auto-commit before milestone merge");
         return result !== null;
     }

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

@@ -3,6 +3,7 @@
  *
  * One command, one wizard. Routes to smart entry or status.
  */
+import { importExtensionModule } from "@gsd/pi-coding-agent";
 import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -529,7 +530,7 @@ export async function handleGSDCommand(args, ctx, pi) {
         return;
     }
     if (trimmed === "widget" || trimmed.startsWith("widget ")) {
-        const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await import("./auto-dashboard.js");
+        const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await importExtensionModule(import.meta.url, "./auto-dashboard.js");
         const arg = trimmed.replace(/^widget\s*/, "").trim();
         if (arg === "full" || arg === "small" || arg === "min" || arg === "off") {
             setWidgetMode(arg);

package/dist/resources/extensions/gsd/doctor-providers.js

@@ -98,6 +98,9 @@ function collectConfiguredModelProviders() {
 }
 function resolveKey(providerId) {
     const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
+    if (providerId === "anthropic-vertex" && process.env.ANTHROPIC_VERTEX_PROJECT_ID) {
+        return { found: true, source: "env", backedOff: false };
+    }
     // Check auth.json
     const authPath = getAuthPath();
     if (existsSync(authPath)) {

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

@@ -257,10 +257,23 @@ async function markSliceDoneInRoadmap(basePath, milestoneId, sliceId, fixesAppli
         fixesApplied.push(`marked ${sliceId} done in ${roadmapPath}`);
     }
 }
+async function markSliceUndoneInRoadmap(basePath, milestoneId, sliceId, fixesApplied) {
+    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    if (!roadmapPath)
+        return;
+    const content = await loadFile(roadmapPath);
+    if (!content)
+        return;
+    const updated = content.replace(new RegExp(`^(\\s*-\\s+)\\[x\\]\\s+\\*\\*${sliceId}:`, "m"), `$1[ ] **${sliceId}:`);
+    if (updated !== content) {
+        await saveFile(roadmapPath, updated);
+        fixesApplied.push(`unmarked ${sliceId} in ${roadmapPath} (premature completion)`);
+    }
+}
 function matchesScope(unitId, scope) {
     if (!scope)
         return true;
-    return unitId === scope || unitId.startsWith(`${scope}/`) || unitId.startsWith(`${scope}`);
+    return unitId === scope || unitId.startsWith(`${scope}/`);
 }
 function auditRequirements(content) {
     if (!content)
@@ -828,6 +841,12 @@ export async function runGSDDoctor(basePath, options) {
                     file: relSliceFile(basePath, milestoneId, slice.id, "SUMMARY"),
                     fixable: true,
                 });
+                if (!allTasksDone) {
+                    dryRunCanFix("slice_checked_missing_summary", `uncheck ${slice.id} in roadmap (tasks incomplete)`);
+                    if (shouldFix("slice_checked_missing_summary")) {
+                        await markSliceUndoneInRoadmap(basePath, milestoneId, slice.id, fixesApplied);
+                    }
+                }
             }
             if (slice.done && !hasSliceUat) {
                 issues.push({

package/dist/resources/extensions/gsd/exit-command.js

@@ -1,9 +1,10 @@
+import { importExtensionModule } from "@gsd/pi-coding-agent";
 export function registerExitCommand(pi, deps = {}) {
     pi.registerCommand("exit", {
         description: "Exit GSD gracefully",
         handler: async (_args, ctx) => {
             // Stop auto-mode first so locks and activity state are cleaned up before shutdown.
-            const stopAuto = deps.stopAuto ?? (await import("./auto.js")).stopAuto;
+            const stopAuto = deps.stopAuto ?? (await importExtensionModule(import.meta.url, "./auto.js")).stopAuto;
             await stopAuto(ctx, pi, "Graceful exit");
             ctx.shutdown();
         },

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

@@ -222,13 +222,48 @@ export function formatSecretsManifest(manifest) {
     return lines.join('\n') + '\n';
 }
 // ─── Slice Plan Parser ─────────────────────────────────────────────────────
+function normalizeTaskPlanFrontmatter(frontmatter) {
+    const estimatedStepsRaw = frontmatter.estimated_steps;
+    const estimatedFilesRaw = frontmatter.estimated_files;
+    const skillsUsedRaw = frontmatter.skills_used;
+    const parseOptionalNumber = (value) => {
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+        if (typeof value === 'string' && value.trim()) {
+            const parsed = parseInt(value, 10);
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+        return undefined;
+    };
+    const estimated_steps = parseOptionalNumber(estimatedStepsRaw);
+    const estimated_files = parseOptionalNumber(estimatedFilesRaw);
+    const skills_used = Array.isArray(skillsUsedRaw)
+        ? skillsUsedRaw.map(v => String(v).trim()).filter(Boolean)
+        : typeof skillsUsedRaw === 'string' && skillsUsedRaw.trim()
+            ? [skillsUsedRaw.trim()]
+            : [];
+    return {
+        ...(estimated_steps !== undefined ? { estimated_steps } : {}),
+        ...(estimated_files !== undefined ? { estimated_files } : {}),
+        skills_used,
+    };
+}
+export function parseTaskPlanFile(content) {
+    const [fmLines] = splitFrontmatter(content);
+    const fm = fmLines ? parseFrontmatterMap(fmLines) : {};
+    return {
+        frontmatter: normalizeTaskPlanFrontmatter(fm),
+    };
+}
 export function parsePlan(content) {
     return cachedParse(content, 'plan', _parsePlanImpl);
 }
 function _parsePlanImpl(content) {
     const stopTimer = debugTime("parse-plan");
+    const [, body] = splitFrontmatter(content);
     // Try native parser first for better performance
-    const nativeResult = nativeParsePlanFile(content);
+    const nativeResult = nativeParsePlanFile(body);
     if (nativeResult) {
         stopTimer({ native: true });
         return {
@@ -249,7 +284,7 @@ function _parsePlanImpl(content) {
             filesLikelyTouched: nativeResult.filesLikelyTouched,
         };
     }
-    const lines = content.split('\n');
+    const lines = body.split('\n');
     const h1 = lines.find(l => l.startsWith('# '));
     let id = '';
     let title = '';
@@ -263,11 +298,11 @@ function _parsePlanImpl(content) {
             title = h1.slice(2).trim();
         }
     }
-    const goal = extractBoldField(content, 'Goal') || '';
-    const demo = extractBoldField(content, 'Demo') || '';
-    const mhSection = extractSection(content, 'Must-Haves');
+    const goal = extractBoldField(body, 'Goal') || '';
+    const demo = extractBoldField(body, 'Demo') || '';
+    const mhSection = extractSection(body, 'Must-Haves');
     const mustHaves = mhSection ? parseBullets(mhSection) : [];
-    const tasksSection = extractSection(content, 'Tasks');
+    const tasksSection = extractSection(body, 'Tasks');
     const tasks = [];
     if (tasksSection) {
         const taskLines = tasksSection.split('\n');
@@ -315,7 +350,7 @@ function _parsePlanImpl(content) {
         if (currentTask)
             tasks.push(currentTask);
     }
-    const filesSection = extractSection(content, 'Files Likely Touched');
+    const filesSection = extractSection(body, 'Files Likely Touched');
     const filesLikelyTouched = filesSection ? parseBullets(filesSection) : [];
     const result = { id, title, goal, demo, mustHaves, tasks, filesLikelyTouched };
     stopTimer({ tasks: tasks.length });
@@ -692,6 +727,10 @@ export function extractUatType(content) {
     const rawValue = modeBullet.slice('UAT mode:'.length).trim().toLowerCase();
     if (rawValue.startsWith('artifact-driven'))
         return 'artifact-driven';
+    if (rawValue.startsWith('browser-executable'))
+        return 'browser-executable';
+    if (rawValue.startsWith('runtime-executable'))
+        return 'runtime-executable';
     if (rawValue.startsWith('live-runtime'))
         return 'live-runtime';
     if (rawValue.startsWith('human-experience'))