gsd-pi 2.38.0-dev.96dc7fb → 2.38.0-dev.98b44dc

package/dist/resources/extensions/gsd/git-service.js

@@ -14,7 +14,7 @@ import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { detectWorktreeName, SLICE_BRANCH_RE, } from "./worktree.js";
-import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAll, nativeResetPaths, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, } from "./native-git-bridge.js";
 import { GSDError, GSD_MERGE_CONFLICT, GSD_GIT_ERROR } from "./errors.js";
 import { getErrorMessage } from "./error-utils.js";
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
@@ -36,12 +36,19 @@ export function buildTaskCommitMessage(ctx) {
         : description;
     const subject = `${type}(${scope}): ${truncated}`;
     // Build body with key files if available
+    const bodyParts = [];
     if (ctx.keyFiles && ctx.keyFiles.length > 0) {
         const fileLines = ctx.keyFiles
             .slice(0, 8) // cap at 8 files to keep commit concise
             .map(f => `- ${f}`)
             .join("\n");
-        return `${subject}\n\n${fileLines}`;
+        bodyParts.push(fileLines);
+    }
+    if (ctx.issueNumber) {
+        bodyParts.push(`Resolves #${ctx.issueNumber}`);
+    }
+    if (bodyParts.length > 0) {
+        return `${subject}\n\n${bodyParts.join("\n\n")}`;
     }
     return subject;
 }
@@ -254,7 +261,9 @@ export class GitServiceImpl {
             }
             this._runtimeFilesCleanedUp = true;
         }
-        // Stage everything, then unstage excluded paths.
+        // Stage everything using pathspec exclusions so excluded paths are never
+        // hashed by git. The old approach of `git add -A` followed by unstaging
+        // hangs indefinitely on repos with large untracked artifact trees (#1605).
         //
         // Exclude only RUNTIME paths from staging — not the entire .gsd/ directory.
         // When .gsd/milestones/ files are already tracked in the index (projects
@@ -264,15 +273,9 @@ export class GitServiceImpl {
         // the second half of a milestone's artifacts are never committed (#1326).
         //
         // If .gsd/ IS in .gitignore (the default for external state projects),
-        // git add -A already skips it and the reset is a harmless no-op.
-        nativeAddAll(this.basePath);
-        const runtimeExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
-        for (const exclusion of runtimeExclusions) {
-            try {
-                nativeResetPaths(this.basePath, [exclusion]);
-            }
-            catch { /* path not staged — ignore */ }
-        }
+        // git add -A already skips it and the exclusions are harmless no-ops.
+        const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
+        nativeAddAllWithExclusions(this.basePath, allExclusions);
     }
     /** Tracks whether runtime file cleanup has run this session. */
     _runtimeFilesCleanedUp = false;
@@ -433,6 +436,21 @@ export class GitServiceImpl {
         }
     }
 }
+// ─── Draft PR Creation ─────────────────────────────────────────────────────
+/**
+ * Create a draft pull request for a completed milestone using `gh pr create`.
+ * Returns the PR URL on success, or null on failure.
+ * Non-fatal: callers should treat failure as best-effort.
+ */
+export function createDraftPR(basePath, milestoneId, title, body) {
+    try {
+        const result = execSync(`gh pr create --draft --title ${JSON.stringify(title)} --body ${JSON.stringify(body)}`, { cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV });
+        return result.trim();
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Factory ───────────────────────────────────────────────────────────────
 /** Create a GitServiceImpl with the current effective git preferences. */
 export function createGitService(basePath) {

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

@@ -6,9 +6,11 @@
  * Both idempotent — non-destructive if already present.
  */
 import { join } from "node:path";
+import { execFileSync } from "node:child_process";
 import { existsSync, lstatSync, readFileSync, writeFileSync } from "node:fs";
 import { nativeRmCached, nativeLsFiles } from "./native-git-bridge.js";
 import { gsdRoot } from "./paths.js";
+import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 /**
  * GSD runtime patterns for git index cleanup.
  * With external state (symlink), these are a no-op in most cases,
@@ -93,11 +95,22 @@ export function hasGitTrackedGsdFiles(basePath) {
     // Check if git tracks any files under .gsd/
     try {
         const tracked = nativeLsFiles(basePath, ".gsd");
-        return tracked.length > 0;
+        if (tracked.length > 0)
+            return true;
+        // nativeLsFiles swallows git failures and returns []. An empty result
+        // could mean "nothing tracked" OR "git failed silently". Verify git is
+        // reachable before trusting the empty result — if it isn't, fail safe
+        // by assuming files ARE tracked to prevent data loss.
+        execFileSync("git", ["rev-parse", "--git-dir"], {
+            cwd: basePath,
+            stdio: "pipe",
+            env: GIT_NO_PROMPT_ENV,
+        });
+        return false;
     }
     catch {
-        // Not a git repo or git not available — safe to proceed
-        return false;
+        // git unavailable, index locked, or repo corrupt — fail safe
+        return true;
     }
 }
 /**

package/dist/resources/extensions/gsd/guided-flow.js

@@ -8,6 +8,7 @@
 import { showNextAction } from "../shared/mod.js";
 import { loadFile, parseRoadmap } from "./files.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
+import { buildSkillActivationBlock } from "./auto-prompts.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { startAuto } from "./auto.js";
@@ -28,6 +29,7 @@ import { showConfirm } from "../shared/mod.js";
 import { debugLog } from "./debug-logger.js";
 import { findMilestoneIds, nextMilestoneId } from "./milestone-ids.js";
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
+import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, } from "./milestone-ids.js";
 export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesContext, } from "./guided-flow-queue.js";
@@ -153,8 +155,32 @@ function parseMilestoneSequenceFromProject(content) {
 /**
  * Read GSD-WORKFLOW.md and dispatch it to the LLM with a contextual note.
  * This is the only way the wizard triggers work — everything else is the LLM's job.
+ *
+ * When a unitType is provided, resolves the user's model preference for that
+ * phase (e.g., models.planning → "plan-milestone") and applies it before
+ * dispatching. This ensures guided-flow dispatches respect the same
+ * per-phase model preferences that auto-mode uses.
  */
-function dispatchWorkflow(pi, note, customType = "gsd-run") {
+async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType) {
+    // Apply model preference for this unit type (if configured)
+    if (ctx && unitType) {
+        const modelConfig = resolveModelWithFallbacksForUnit(unitType);
+        if (modelConfig) {
+            const availableModels = ctx.modelRegistry.getAvailable();
+            const modelsToTry = [modelConfig.primary, ...modelConfig.fallbacks];
+            for (const modelId of modelsToTry) {
+                // Resolve model from available models (same logic as auto-model-selection)
+                const model = resolveAvailableModel(modelId, availableModels, ctx.model?.provider);
+                if (!model)
+                    continue;
+                const ok = await pi.setModel(model, { persist: false });
+                if (ok) {
+                    debugLog("guided-flow-model-applied", { unitType, model: `${model.provider}/${model.id}` });
+                    break;
+                }
+            }
+        }
+    }
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     pi.sendMessage({
@@ -163,6 +189,31 @@ function dispatchWorkflow(pi, note, customType = "gsd-run") {
         display: false,
     }, { triggerTurn: true });
 }
+/**
+ * Resolve a model ID string to a model object from available models.
+ * Handles "provider/model" and bare ID formats.
+ */
+function resolveAvailableModel(modelId, availableModels, currentProvider) {
+    const slashIdx = modelId.indexOf("/");
+    if (slashIdx !== -1) {
+        const maybeProvider = modelId.substring(0, slashIdx);
+        const id = modelId.substring(slashIdx + 1);
+        const knownProviders = new Set(availableModels.map(m => m.provider.toLowerCase()));
+        if (knownProviders.has(maybeProvider.toLowerCase())) {
+            const match = availableModels.find(m => m.provider.toLowerCase() === maybeProvider.toLowerCase()
+                && m.id.toLowerCase() === id.toLowerCase());
+            if (match)
+                return match;
+        }
+        // Try matching the full string as a model ID (OpenRouter-style)
+        const lower = modelId.toLowerCase();
+        return availableModels.find(m => m.id.toLowerCase() === lower
+            || `${m.provider}/${m.id}`.toLowerCase() === lower);
+    }
+    // Bare ID — prefer current provider, then first available
+    const exactProviderMatch = availableModels.find(m => m.id === modelId && m.provider === currentProvider);
+    return exactProviderMatch ?? availableModels.find(m => m.id === modelId);
+}
 /**
  * Build the discuss-and-plan prompt for a new milestone.
  * Used by all three "new milestone" paths (first ever, no active, all complete).
@@ -244,8 +295,8 @@ export async function showHeadlessMilestoneCreation(ctx, pi, basePath, seedConte
     const prompt = buildHeadlessDiscussPrompt(nextId, seedContext, basePath);
     // Set pending auto start (auto-mode triggers on "Milestone X ready." via checkAutoStartAfterDiscuss)
     pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId };
-    // Dispatch
-    dispatchWorkflow(pi, prompt);
+    // Dispatch — headless milestone creation is a planning activity
+    await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "plan-milestone");
 }
 // ─── Discuss Flow ─────────────────────────────────────────────────────────────
 /**
@@ -381,23 +432,23 @@ export async function showDiscuss(ctx, pi, basePath) {
                 ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
                 : basePrompt;
             pendingAutoStart = { ctx, pi, basePath, milestoneId: mid, step: false };
-            dispatchWorkflow(pi, seed, "gsd-discuss");
+            await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "plan-milestone");
         }
         else if (choice === "discuss_fresh") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
             pendingAutoStart = { ctx, pi, basePath, milestoneId: mid, step: false };
-            dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
+            await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                 milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-            }), "gsd-discuss");
+            }), "gsd-discuss", ctx, "plan-milestone");
         }
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: false };
-            dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
         }
         return;
     }
@@ -484,7 +535,7 @@ export async function showDiscuss(ctx, pi, basePath) {
                 continue;
         }
         const prompt = await buildDiscussSlicePrompt(mid, chosen.id, chosen.title, basePath, { rediscuss: isRediscuss });
-        dispatchWorkflow(pi, prompt, "gsd-discuss");
+        await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "plan-slice");
         // Wait for the discuss session to finish, then loop back to the picker
         await ctx.waitForIdle();
         invalidateAllCaches();
@@ -611,7 +662,7 @@ async function handleMilestoneActions(ctx, pi, basePath, milestoneId, milestoneT
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
         const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
         pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-        dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+        await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
         return true;
     }
     // "back" or null
@@ -729,7 +780,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         if (isFirst) {
             // First ever — skip wizard, just ask directly
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-            dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath));
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath), "gsd-run", ctx, "plan-milestone");
         }
         else {
             const choice = await showNextAction(ctx, {
@@ -747,7 +798,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             });
             if (choice === "new_milestone") {
                 pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-                dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+                await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
             }
         }
         return;
@@ -779,7 +830,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-            dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
         }
         else if (choice === "status") {
             const { fireStatusViaCommand } = await import("./commands.js");
@@ -825,23 +876,23 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
                 : basePrompt;
             pendingAutoStart = { ctx, pi, basePath, milestoneId, step: stepMode };
-            dispatchWorkflow(pi, seed, "gsd-discuss");
+            await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "plan-milestone");
         }
         else if (choice === "discuss_fresh") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
             pendingAutoStart = { ctx, pi, basePath, milestoneId, step: stepMode };
-            dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
+            await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                 milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-            }), "gsd-discuss");
+            }), "gsd-discuss", ctx, "plan-milestone");
         }
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-            dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
         }
         return;
     }
@@ -893,24 +944,33 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                     inlineTemplate("secrets-manifest", "Secrets Manifest"),
                 ].join("\n\n---\n\n");
                 const secretsOutputPath = relMilestoneFile(basePath, milestoneId, "SECRETS");
-                dispatchWorkflow(pi, loadPrompt("guided-plan-milestone", {
-                    milestoneId, milestoneTitle, secretsOutputPath, inlinedTemplates: planMilestoneTemplates,
-                }));
+                await dispatchWorkflow(pi, loadPrompt("guided-plan-milestone", {
+                    milestoneId,
+                    milestoneTitle,
+                    secretsOutputPath,
+                    inlinedTemplates: planMilestoneTemplates,
+                    skillActivation: buildSkillActivationBlock({
+                        base: basePath,
+                        milestoneId,
+                        milestoneTitle,
+                        extraContext: [planMilestoneTemplates],
+                    }),
+                }), "gsd-run", ctx, "plan-milestone");
             }
             else if (choice === "discuss") {
                 const discussMilestoneTemplates = inlineTemplate("context", "Context");
                 const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
-                dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
+                await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                     milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                     commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                }));
+                }), "gsd-run", ctx, "plan-milestone");
             }
             else if (choice === "skip_milestone") {
                 const milestoneIds = findMilestoneIds(basePath);
                 const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
                 const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
                 pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-                dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+                await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
             }
             else if (choice === "discard_milestone") {
                 const confirmed = await showConfirm(ctx, {
@@ -1021,18 +1081,38 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 inlineTemplate("plan", "Slice Plan"),
                 inlineTemplate("task-plan", "Task Plan"),
             ].join("\n\n---\n\n");
-            dispatchWorkflow(pi, loadPrompt("guided-plan-slice", {
-                milestoneId, sliceId, sliceTitle, inlinedTemplates: planSliceTemplates,
-            }));
+            await dispatchWorkflow(pi, loadPrompt("guided-plan-slice", {
+                milestoneId,
+                sliceId,
+                sliceTitle,
+                inlinedTemplates: planSliceTemplates,
+                skillActivation: buildSkillActivationBlock({
+                    base: basePath,
+                    milestoneId,
+                    sliceId,
+                    sliceTitle,
+                    extraContext: [planSliceTemplates],
+                }),
+            }), "gsd-run", ctx, "plan-slice");
         }
         else if (choice === "discuss") {
-            dispatchWorkflow(pi, await buildDiscussSlicePrompt(milestoneId, sliceId, sliceTitle, basePath, { rediscuss: hasContext }));
+            await dispatchWorkflow(pi, await buildDiscussSlicePrompt(milestoneId, sliceId, sliceTitle, basePath, { rediscuss: hasContext }), "gsd-run", ctx, "plan-slice");
         }
         else if (choice === "research") {
             const researchTemplates = inlineTemplate("research", "Research");
-            dispatchWorkflow(pi, loadPrompt("guided-research-slice", {
-                milestoneId, sliceId, sliceTitle, inlinedTemplates: researchTemplates,
-            }));
+            await dispatchWorkflow(pi, loadPrompt("guided-research-slice", {
+                milestoneId,
+                sliceId,
+                sliceTitle,
+                inlinedTemplates: researchTemplates,
+                skillActivation: buildSkillActivationBlock({
+                    base: basePath,
+                    milestoneId,
+                    sliceId,
+                    sliceTitle,
+                    extraContext: [researchTemplates],
+                }),
+            }), "gsd-run", ctx, "research-slice");
         }
         else if (choice === "status") {
             const { fireStatusViaCommand } = await import("./commands.js");
@@ -1075,9 +1155,20 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 inlineTemplate("slice-summary", "Slice Summary"),
                 inlineTemplate("uat", "UAT"),
             ].join("\n\n---\n\n");
-            dispatchWorkflow(pi, loadPrompt("guided-complete-slice", {
-                workingDirectory: basePath, milestoneId, sliceId, sliceTitle, inlinedTemplates: completeSliceTemplates,
-            }));
+            await dispatchWorkflow(pi, loadPrompt("guided-complete-slice", {
+                workingDirectory: basePath,
+                milestoneId,
+                sliceId,
+                sliceTitle,
+                inlinedTemplates: completeSliceTemplates,
+                skillActivation: buildSkillActivationBlock({
+                    base: basePath,
+                    milestoneId,
+                    sliceId,
+                    sliceTitle,
+                    extraContext: [completeSliceTemplates],
+                }),
+            }), "gsd-run", ctx, "complete-slice");
         }
         else if (choice === "status") {
             const { fireStatusViaCommand } = await import("./commands.js");
@@ -1138,15 +1229,35 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         }
         if (choice === "execute") {
             if (hasInterrupted) {
-                dispatchWorkflow(pi, loadPrompt("guided-resume-task", {
-                    milestoneId, sliceId,
-                }));
+                await dispatchWorkflow(pi, loadPrompt("guided-resume-task", {
+                    milestoneId,
+                    sliceId,
+                    skillActivation: buildSkillActivationBlock({
+                        base: basePath,
+                        milestoneId,
+                        sliceId,
+                        taskId,
+                        taskTitle,
+                    }),
+                }), "gsd-run", ctx, "execute-task");
             }
             else {
                 const executeTaskTemplates = inlineTemplate("task-summary", "Task Summary");
-                dispatchWorkflow(pi, loadPrompt("guided-execute-task", {
-                    milestoneId, sliceId, taskId, taskTitle, inlinedTemplates: executeTaskTemplates,
-                }));
+                await dispatchWorkflow(pi, loadPrompt("guided-execute-task", {
+                    milestoneId,
+                    sliceId,
+                    taskId,
+                    taskTitle,
+                    inlinedTemplates: executeTaskTemplates,
+                    skillActivation: buildSkillActivationBlock({
+                        base: basePath,
+                        milestoneId,
+                        sliceId,
+                        taskId,
+                        taskTitle,
+                        extraContext: [executeTaskTemplates],
+                    }),
+                }), "gsd-run", ctx, "execute-task");
             }
         }
         else if (choice === "status") {

package/dist/resources/extensions/gsd/health-widget-core.js

@@ -4,65 +4,18 @@
  * Separates project-state detection and line rendering from the widget's
  * runtime integrations so the regressions can be tested directly.
  */
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync } from "node:fs";
+import { detectProjectState } from "./detection.js";
 import { gsdRoot } from "./paths.js";
-import { join } from "node:path";
 export function detectHealthWidgetProjectState(basePath) {
-    const root = gsdRoot(basePath);
-    if (!existsSync(root))
+    if (!existsSync(gsdRoot(basePath)))
         return "none";
-    // Lightweight milestone count — avoids the full detectProjectState() scan
-    // (CI markers, Makefile targets, etc.) that is unnecessary on the 60s refresh.
-    try {
-        const milestonesDir = join(root, "milestones");
-        if (existsSync(milestonesDir)) {
-            const entries = readdirSync(milestonesDir, { withFileTypes: true });
-            if (entries.some(e => e.isDirectory()))
-                return "active";
-        }
-    }
-    catch { /* non-fatal */ }
-    return "initialized";
+    const { state } = detectProjectState(basePath);
+    return state === "v2-gsd" ? "active" : "initialized";
 }
 function formatCost(n) {
     return n >= 1 ? `$${n.toFixed(2)}` : `${(n * 100).toFixed(1)}¢`;
 }
-function formatProgress(progress) {
-    if (!progress)
-        return null;
-    const parts = [];
-    parts.push(`M ${progress.milestones.done}/${progress.milestones.total}`);
-    if (progress.slices)
-        parts.push(`S ${progress.slices.done}/${progress.slices.total}`);
-    if (progress.tasks)
-        parts.push(`T ${progress.tasks.done}/${progress.tasks.total}`);
-    return parts.length > 0 ? `Progress: ${parts.join(" · ")}` : null;
-}
-function formatEnvironmentSummary(errorCount, warningCount) {
-    if (errorCount <= 0 && warningCount <= 0)
-        return null;
-    const parts = [];
-    if (errorCount > 0)
-        parts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
-    if (warningCount > 0)
-        parts.push(`${warningCount} warning${warningCount > 1 ? "s" : ""}`);
-    return `Env: ${parts.join(", ")}`;
-}
-function formatBudgetSummary(data) {
-    if (data.budgetCeiling !== undefined && data.budgetCeiling > 0) {
-        const pct = Math.min(100, (data.budgetSpent / data.budgetCeiling) * 100);
-        return `Budget: ${formatCost(data.budgetSpent)}/${formatCost(data.budgetCeiling)} (${pct.toFixed(0)}%)`;
-    }
-    if (data.budgetSpent > 0) {
-        return `Spent: ${formatCost(data.budgetSpent)}`;
-    }
-    return null;
-}
-function buildExecutionHeadline(data) {
-    const status = data.executionStatus ?? "Active project";
-    const target = data.executionTarget ?? data.blocker ?? "loading status…";
-    return `  GSD  ${status}${target ? ` - ${target}` : ""}`;
-}
 /**
  * Build compact health lines for the widget.
  * Returns a string array suitable for setWidget().
@@ -74,23 +27,32 @@ export function buildHealthLines(data) {
     if (data.projectState === "initialized") {
         return ["  GSD  Project initialized — run /gsd to continue setup"];
     }
-    const lines = [buildExecutionHeadline(data)];
-    const details = [];
-    const progress = formatProgress(data.progress);
-    if (progress)
-        details.push(progress);
-    if (data.providerIssue)
-        details.push(data.providerIssue);
-    const environment = formatEnvironmentSummary(data.environmentErrorCount, data.environmentWarningCount);
-    if (environment)
-        details.push(environment);
-    const budget = formatBudgetSummary(data);
-    if (budget)
-        details.push(budget);
-    if (data.eta)
-        details.push(data.eta);
-    if (details.length > 0) {
-        lines.push(`  ${details.join("  │  ")}`);
+    const parts = [];
+    const totalIssues = data.environmentErrorCount + data.environmentWarningCount + (data.providerIssue ? 1 : 0);
+    if (totalIssues === 0) {
+        parts.push("● System OK");
+    }
+    else if (data.environmentErrorCount > 0 || data.providerIssue?.includes("✗")) {
+        parts.push(`✗ ${totalIssues} issue${totalIssues > 1 ? "s" : ""}`);
+    }
+    else {
+        parts.push(`⚠ ${totalIssues} warning${totalIssues > 1 ? "s" : ""}`);
+    }
+    if (data.budgetCeiling !== undefined && data.budgetCeiling > 0) {
+        const pct = Math.min(100, (data.budgetSpent / data.budgetCeiling) * 100);
+        parts.push(`Budget: ${formatCost(data.budgetSpent)}/${formatCost(data.budgetCeiling)} (${pct.toFixed(0)}%)`);
+    }
+    else if (data.budgetSpent > 0) {
+        parts.push(`Spent: ${formatCost(data.budgetSpent)}`);
+    }
+    if (data.providerIssue) {
+        parts.push(data.providerIssue);
+    }
+    if (data.environmentErrorCount > 0) {
+        parts.push(`Env: ${data.environmentErrorCount} error${data.environmentErrorCount > 1 ? "s" : ""}`);
+    }
+    else if (data.environmentWarningCount > 0) {
+        parts.push(`Env: ${data.environmentWarningCount} warning${data.environmentWarningCount > 1 ? "s" : ""}`);
     }
-    return lines;
+    return [`  ${parts.join("  │  ")}`];
 }