gsd-pi 2.38.0-dev.7209774 → 2.38.0-dev.785052f

package/README.md

@@ -24,21 +24,25 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.37
+## What's New in v2.38
 
-- **cmux integration** — sidebar status, progress bars, and notifications for [cmux](https://cmux.com) terminal multiplexer users
-- **Redesigned dashboard** — two-column layout with redesigned widget
-- **Search budget enforcement** — session-level search budget prevents unbounded native web search
+- **Reactive task execution (ADR-004)** — graph-derived parallel task dispatch within slices. When enabled, GSD derives a dependency graph from IO annotations in task plans and dispatches multiple non-conflicting tasks in parallel via subagents. Backward compatible — disabled by default. Enable with `reactive_execution: true` in preferences.
+- **Anthropic Vertex AI provider** — run Claude models (Opus 4.6, Sonnet 4.6, Haiku 4.5) through Google Vertex AI. Set `ANTHROPIC_VERTEX_PROJECT_ID` to activate.
+- **CI optimization** — GitHub Actions minutes reduced ~60-70% (~10k → ~3-4k/month)
+- **Reactive batch verification** — dependency-based carry-forward for verification results across parallel task batches
+- **Backtick file path enforcement** — task plan IO sections now require backtick-wrapped paths for reliable parsing
+
+See the full [Changelog](./CHANGELOG.md) for details.
+
+### Previous highlights (v2.34–v2.37)
+
+- **cmux integration** — sidebar status, progress bars, and notifications for cmux terminal multiplexer users
+- **Redesigned dashboard** — two-column layout with 4 widget modes (full → small → min → off)
 - **AGENTS.md support** — deprecated `agent-instructions.md` in favor of standard `AGENTS.md` / `CLAUDE.md`
 - **AI-powered triage** — automated issue and PR triage via Claude Haiku
-- **Auto-generated OpenRouter registry** — model registry built from OpenRouter API for always-current model support
-- **Extension manifest system** — user-managed enable/disable for bundled extensions
-- **Pipeline simplification (ADR-003)** — merged research into planning, mechanical completion
-- **Workflow templates** — right-sized workflows for every task type
-- **Health widget** — always-on environment health checks with progress scoring
+- **Auto-generated OpenRouter registry** — model registry built from OpenRouter API
 - **`/gsd changelog`** — LLM-summarized release notes for any version
-
-See the full [Changelog](./CHANGELOG.md) for details.
+- **Search budget enforcement** — session-level cap prevents unbounded web search
 
 ---
 

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

@@ -5,11 +5,12 @@
  * 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, resolveRuntimeFile, } from "./paths.js";
-import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
-import { join } from "node:path";
+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, truncateAtSectionBoundary } from "./context-budget.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
@@ -250,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.
@@ -539,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(),
     });
 }
@@ -598,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(),
     });
 }
@@ -643,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(),
     });
 }
@@ -698,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) {
@@ -789,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) {
@@ -1026,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) {

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/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 });

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";
@@ -944,7 +945,16 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 ].join("\n\n---\n\n");
                 const secretsOutputPath = relMilestoneFile(basePath, milestoneId, "SECRETS");
                 await dispatchWorkflow(pi, loadPrompt("guided-plan-milestone", {
-                    milestoneId, milestoneTitle, secretsOutputPath, inlinedTemplates: planMilestoneTemplates,
+                    milestoneId,
+                    milestoneTitle,
+                    secretsOutputPath,
+                    inlinedTemplates: planMilestoneTemplates,
+                    skillActivation: buildSkillActivationBlock({
+                        base: basePath,
+                        milestoneId,
+                        milestoneTitle,
+                        extraContext: [planMilestoneTemplates],
+                    }),
                 }), "gsd-run", ctx, "plan-milestone");
             }
             else if (choice === "discuss") {
@@ -1072,7 +1082,17 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 inlineTemplate("task-plan", "Task Plan"),
             ].join("\n\n---\n\n");
             await dispatchWorkflow(pi, loadPrompt("guided-plan-slice", {
-                milestoneId, sliceId, sliceTitle, inlinedTemplates: planSliceTemplates,
+                milestoneId,
+                sliceId,
+                sliceTitle,
+                inlinedTemplates: planSliceTemplates,
+                skillActivation: buildSkillActivationBlock({
+                    base: basePath,
+                    milestoneId,
+                    sliceId,
+                    sliceTitle,
+                    extraContext: [planSliceTemplates],
+                }),
             }), "gsd-run", ctx, "plan-slice");
         }
         else if (choice === "discuss") {
@@ -1081,7 +1101,17 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         else if (choice === "research") {
             const researchTemplates = inlineTemplate("research", "Research");
             await dispatchWorkflow(pi, loadPrompt("guided-research-slice", {
-                milestoneId, sliceId, sliceTitle, inlinedTemplates: researchTemplates,
+                milestoneId,
+                sliceId,
+                sliceTitle,
+                inlinedTemplates: researchTemplates,
+                skillActivation: buildSkillActivationBlock({
+                    base: basePath,
+                    milestoneId,
+                    sliceId,
+                    sliceTitle,
+                    extraContext: [researchTemplates],
+                }),
             }), "gsd-run", ctx, "research-slice");
         }
         else if (choice === "status") {
@@ -1126,7 +1156,18 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 inlineTemplate("uat", "UAT"),
             ].join("\n\n---\n\n");
             await dispatchWorkflow(pi, loadPrompt("guided-complete-slice", {
-                workingDirectory: basePath, milestoneId, sliceId, sliceTitle, inlinedTemplates: completeSliceTemplates,
+                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") {
@@ -1189,13 +1230,33 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         if (choice === "execute") {
             if (hasInterrupted) {
                 await dispatchWorkflow(pi, loadPrompt("guided-resume-task", {
-                    milestoneId, sliceId,
+                    milestoneId,
+                    sliceId,
+                    skillActivation: buildSkillActivationBlock({
+                        base: basePath,
+                        milestoneId,
+                        sliceId,
+                        taskId,
+                        taskTitle,
+                    }),
                 }), "gsd-run", ctx, "execute-task");
             }
             else {
                 const executeTaskTemplates = inlineTemplate("task-summary", "Task Summary");
                 await dispatchWorkflow(pi, loadPrompt("guided-execute-task", {
-                    milestoneId, sliceId, taskId, taskTitle, inlinedTemplates: executeTaskTemplates,
+                    milestoneId,
+                    sliceId,
+                    taskId,
+                    taskTitle,
+                    inlinedTemplates: executeTaskTemplates,
+                    skillActivation: buildSkillActivationBlock({
+                        base: basePath,
+                        milestoneId,
+                        sliceId,
+                        taskId,
+                        taskTitle,
+                        extraContext: [executeTaskTemplates],
+                    }),
                 }), "gsd-run", ctx, "execute-task");
             }
         }

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("  │  ")}`];
 }