gsd-pi 2.35.0-dev.cd3b7ea → 2.36.0

package/src/resources/extensions/gsd/commands.ts

@@ -48,6 +48,7 @@ import { computeProgressScore, formatProgressLine } from "./progress-score.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 import { handleLogs } from "./commands-logs.js";
 import { handleStart, handleTemplates, getTemplateCompletions } from "./commands-workflow-templates.js";
+import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
 
 
 /** Resolve the effective project root, accounting for worktree paths. */
@@ -69,6 +70,39 @@ export function projectRoot(): string {
   return root;
 }
 
+/**
+ * Check if another process holds the auto-mode session lock.
+ * Returns the lock data if a remote session is alive, null otherwise.
+ */
+function getRemoteAutoSession(basePath: string): { pid: number } | null {
+  const lockData = readSessionLockData(basePath);
+  if (!lockData) return null;
+  if (lockData.pid === process.pid) return null;
+  if (!isSessionLockProcessAlive(lockData)) return null;
+  return { pid: lockData.pid };
+}
+
+/**
+ * Show a steering menu when auto-mode is running in another process.
+ * Returns true if a remote session was detected (caller should return early).
+ */
+function notifyRemoteAutoActive(ctx: ExtensionCommandContext, basePath: string): boolean {
+  const remote = getRemoteAutoSession(basePath);
+  if (!remote) return false;
+  ctx.ui.notify(
+    `Auto-mode is running in another process (PID ${remote.pid}).\n` +
+    `Use these commands to interact with it:\n` +
+    `  /gsd status   — check progress\n` +
+    `  /gsd discuss  — discuss architecture decisions\n` +
+    `  /gsd queue    — queue the next milestone\n` +
+    `  /gsd steer    — apply an override to active work\n` +
+    `  /gsd capture  — fire-and-forget thought\n` +
+    `  /gsd stop     — stop auto-mode`,
+    "warning",
+  );
+  return true;
+}
+
 export function registerGSDCommand(pi: ExtensionAPI): void {
   pi.registerCommand("gsd", {
     description: "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|visualize|queue|quick|capture|triage|dispatch|history|undo|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|update",
@@ -89,6 +123,7 @@ export function registerGSDCommand(pi: ExtensionAPI): void {
         { cmd: "triage", desc: "Manually trigger triage of pending captures" },
         { cmd: "dispatch", desc: "Dispatch a specific phase directly" },
         { cmd: "history", desc: "View execution history" },
+        { cmd: "rate", desc: "Rate last unit's model tier (over/ok/under) — improves adaptive routing" },
         { cmd: "undo", desc: "Revert last completed unit" },
         { cmd: "skip", desc: "Prevent a unit from auto-mode dispatch" },
         { cmd: "export", desc: "Export milestone/slice results" },
@@ -511,6 +546,7 @@ export async function handleGSDCommand(
           await handleDryRun(ctx, projectRoot());
           return;
         }
+        if (notifyRemoteAutoActive(ctx, projectRoot())) return;
         const verboseMode = trimmed.includes("--verbose");
         const debugMode = trimmed.includes("--debug");
         if (debugMode) enableDebug(projectRoot());
@@ -566,6 +602,12 @@ export async function handleGSDCommand(
         return;
       }
 
+      if (trimmed === "rate" || trimmed.startsWith("rate ")) {
+        const { handleRate } = await import("./commands-rate.js");
+        await handleRate(trimmed.replace(/^rate\s*/, "").trim(), ctx, projectRoot());
+        return;
+      }
+
       if (trimmed.startsWith("skip ")) {
         await handleSkip(trimmed.replace(/^skip\s*/, "").trim(), ctx, projectRoot());
         return;
@@ -899,7 +941,7 @@ Examples:
       }
 
       if (trimmed === "") {
-        // Bare /gsd defaults to step mode
+        if (notifyRemoteAutoActive(ctx, projectRoot())) return;
         await startAuto(ctx, pi, projectRoot(), false, { step: true });
         return;
       }

package/src/resources/extensions/gsd/doctor-environment.ts

@@ -180,26 +180,36 @@ function checkPortConflicts(basePath: string): EnvironmentCheckResult[] {
   const portsToCheck = new Set<number>();
   const pkgPath = join(basePath, "package.json");
 
-  if (existsSync(pkgPath)) {
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-      const scripts = pkg.scripts ?? {};
-      const scriptText = Object.values(scripts).join(" ");
-
-      // Look for --port NNNN, -p NNNN, PORT=NNNN, :NNNN patterns
-      const portMatches = scriptText.matchAll(/(?:--port\s+|(?:^|[^a-z])PORT[=:]\s*|-p\s+|:)(\d{4,5})\b/gi);
-      for (const m of portMatches) {
-        const port = parseInt(m[1], 10);
-        if (port >= 1024 && port <= 65535) portsToCheck.add(port);
-      }
-    } catch {
-      // parse failed — use defaults
+  if (!existsSync(pkgPath)) {
+    // No package.json — this isn't a Node.js project. Skip port checks
+    // entirely to avoid false positives from system services (e.g., macOS
+    // AirPlay Receiver on port 5000). (#1381)
+    return [];
+  }
+
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const scripts = pkg.scripts ?? {};
+    const scriptText = Object.values(scripts).join(" ");
+
+    // Look for --port NNNN, -p NNNN, PORT=NNNN, :NNNN patterns
+    const portMatches = scriptText.matchAll(/(?:--port\s+|(?:^|[^a-z])PORT[=:]\s*|-p\s+|:)(\d{4,5})\b/gi);
+    for (const m of portMatches) {
+      const port = parseInt(m[1], 10);
+      if (port >= 1024 && port <= 65535) portsToCheck.add(port);
     }
+  } catch {
+    // parse failed — skip port checks rather than using defaults
+    return [];
   }
 
-  // If no ports found in scripts, check common defaults
+  // If no ports found in scripts, check common defaults.
+  // Filter out port 5000 on macOS — AirPlay Receiver uses it by default (#1381).
   if (portsToCheck.size === 0) {
-    for (const p of DEFAULT_DEV_PORTS) portsToCheck.add(p);
+    for (const p of DEFAULT_DEV_PORTS) {
+      if (p === 5000 && process.platform === "darwin") continue;
+      portsToCheck.add(p);
+    }
   }
 
   for (const port of portsToCheck) {

package/src/resources/extensions/gsd/files.ts

@@ -590,7 +590,8 @@ export async function loadFile(path: string): Promise<string | null> {
   try {
     return await fs.readFile(path, 'utf-8');
   } catch (err: unknown) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return null;
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT' || code === 'EISDIR') return null;
     throw err;
   }
 }
@@ -804,7 +805,7 @@ export async function inlinePriorMilestoneSummary(mid: string, base: string): Pr
  * file not on disk) - callers can distinguish "no manifest" from "empty manifest".
  */
 export async function getManifestStatus(
-  base: string, milestoneId: string,
+  base: string, milestoneId: string, projectRoot?: string,
 ): Promise<ManifestStatus | null> {
   const resolvedPath = resolveMilestoneFile(base, milestoneId, 'SECRETS');
   if (!resolvedPath) return null;
@@ -814,9 +815,18 @@ export async function getManifestStatus(
 
   const manifest = parseSecretsManifest(content);
   const keys = manifest.entries.map(e => e.key);
+
+  // Check both the base path .env AND the project root .env (#1387).
+  // In worktree mode, base is the worktree path which may not have .env.
+  // The project root's .env is where the user actually defined their keys.
   const existingKeys = await checkExistingEnvKeys(keys, resolve(base, '.env'));
   const existingSet = new Set(existingKeys);
 
+  if (projectRoot && projectRoot !== base) {
+    const rootKeys = await checkExistingEnvKeys(keys, resolve(projectRoot, '.env'));
+    for (const k of rootKeys) existingSet.add(k);
+  }
+
   const result: ManifestStatus = {
     pending: [],
     collected: [],

package/src/resources/extensions/gsd/gitignore.ts

@@ -7,8 +7,8 @@
  */
 
 import { join } from "node:path";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { nativeRmCached } from "./native-git-bridge.js";
+import { existsSync, lstatSync, readFileSync, writeFileSync } from "node:fs";
+import { nativeRmCached, nativeLsFiles } from "./native-git-bridge.js";
 import { gsdRoot } from "./paths.js";
 
 /**
@@ -79,12 +79,47 @@ const BASELINE_PATTERNS = [
 ];
 
 /**
- * Ensure basePath/.gitignore contains a blanket `.gsd/` ignore.
- * Creates the file if missing; appends `.gsd/` if not present.
+ * Check whether `.gsd/` contains files tracked by git.
+ * If so, the project intentionally keeps `.gsd/` in version control
+ * and we must NOT add `.gsd` to `.gitignore` or attempt migration.
+ *
+ * Returns true if git tracks at least one file under `.gsd/`.
+ * Returns false (safe to ignore) if:
+ *   - Not a git repo
+ *   - `.gsd/` is a symlink (external state, should be ignored)
+ *   - `.gsd/` doesn't exist
+ *   - No tracked files found under `.gsd/`
+ */
+export function hasGitTrackedGsdFiles(basePath: string): boolean {
+  const localGsd = join(basePath, ".gsd");
+
+  // If .gsd doesn't exist or is already a symlink, no tracked files concern
+  if (!existsSync(localGsd)) return false;
+  try {
+    if (lstatSync(localGsd).isSymbolicLink()) return false;
+  } catch {
+    return false;
+  }
+
+  // Check if git tracks any files under .gsd/
+  try {
+    const tracked = nativeLsFiles(basePath, ".gsd");
+    return tracked.length > 0;
+  } catch {
+    // Not a git repo or git not available — safe to proceed
+    return false;
+  }
+}
+
+/**
+ * Ensure basePath/.gitignore contains baseline ignore patterns.
+ * Creates the file if missing; appends missing patterns.
  * Returns true if the file was created or modified, false if already complete.
  *
- * `.gsd/` state is managed externally (symlinked to `~/.gsd/projects/<hash>/`),
- * so the entire directory is always gitignored.
+ * **Safety check:** If `.gsd/` contains git-tracked files (i.e., the project
+ * intentionally keeps `.gsd/` in version control), the `.gsd` ignore pattern
+ * is excluded to prevent data loss. Only the `.gsd` pattern is affected —
+ * all other baseline patterns are still applied normally.
  */
 export function ensureGitignore(
   basePath: string,
@@ -108,8 +143,15 @@ export function ensureGitignore(
       .filter((l) => l && !l.startsWith("#")),
   );
 
+  // Determine which patterns to apply. If .gsd/ has tracked files,
+  // exclude the ".gsd" pattern to prevent deleting tracked state.
+  const gsdIsTracked = hasGitTrackedGsdFiles(basePath);
+  const patternsToApply = gsdIsTracked
+    ? BASELINE_PATTERNS.filter((p) => p !== ".gsd")
+    : BASELINE_PATTERNS;
+
   // Find patterns not yet present
-  const missing = BASELINE_PATTERNS.filter((p) => !existingLines.has(p));
+  const missing = patternsToApply.filter((p) => !existingLines.has(p));
 
   if (missing.length === 0) return false;
 
@@ -135,6 +177,11 @@ export function ensureGitignore(
  * already in the index even after .gitignore is updated.
  *
  * Only removes from the index (`--cached`), never from disk. Idempotent.
+ *
+ * Note: These are strictly runtime/ephemeral paths (activity logs, lock files,
+ * metrics, STATE.md). They are always safe to untrack, even when the project
+ * intentionally keeps other `.gsd/` files (like PROJECT.md, milestones/) in
+ * version control.
  */
 export function untrackRuntimeFiles(basePath: string): void {
   const runtimePaths = GSD_RUNTIME_PATTERNS;

package/src/resources/extensions/gsd/guided-flow.ts

@@ -23,6 +23,7 @@ import {
 } from "./paths.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync, unlinkSync } from "node:fs";
+import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
 import { nativeIsRepo, nativeInit } from "./native-git-bridge.js";
 import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -191,7 +192,7 @@ type UIContext = ExtensionContext;
  * This is the only way the wizard triggers work — everything else is the LLM's job.
  */
 function dispatchWorkflow(pi: ExtensionAPI, note: string, customType = "gsd-run"): void {
-  const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".pi", "GSD-WORKFLOW.md");
+  const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
   const workflow = readFileSync(workflowPath, "utf-8");
 
   pi.sendMessage(
@@ -516,8 +517,13 @@ export async function showDiscuss(
     // If all pending slices are discussed, notify and exit instead of looping
     const allDiscussed = pendingSlices.every(s => discussedMap.get(s.id));
     if (allDiscussed) {
+      const lockData = readSessionLockData(basePath);
+      const remoteAutoRunning = lockData && lockData.pid !== process.pid && isSessionLockProcessAlive(lockData);
+      const nextStep = remoteAutoRunning
+        ? "Auto-mode is already running — use /gsd status to check progress."
+        : "Run /gsd to start planning.";
       ctx.ui.notify(
-        `All ${pendingSlices.length} slices discussed. Run /gsd to start planning.`,
+        `All ${pendingSlices.length} slices discussed. ${nextStep}`,
         "info",
       );
       return;

package/src/resources/extensions/gsd/health-widget-core.ts

@@ -0,0 +1,129 @@
+/**
+ * Pure GSD health widget logic.
+ *
+ * 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 { gsdRoot } from "./paths.js";
+import { join } from "node:path";
+import type { GSDState, Phase } from "./types.js";
+
+export type HealthWidgetProjectState = "none" | "initialized" | "active";
+
+export interface HealthWidgetData {
+  projectState: HealthWidgetProjectState;
+  budgetCeiling: number | undefined;
+  budgetSpent: number;
+  providerIssue: string | null;
+  environmentErrorCount: number;
+  environmentWarningCount: number;
+  lastRefreshed: number;
+  executionPhase?: Phase;
+  executionStatus?: string;
+  executionTarget?: string;
+  nextAction?: string;
+  blocker?: string | null;
+  activeMilestoneId?: string;
+  activeSliceId?: string;
+  activeTaskId?: string;
+  progress?: GSDState["progress"];
+  eta?: string | null;
+}
+
+export function detectHealthWidgetProjectState(basePath: string): HealthWidgetProjectState {
+  const root = gsdRoot(basePath);
+  if (!existsSync(root)) 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";
+}
+
+function formatCost(n: number): string {
+  return n >= 1 ? `$${n.toFixed(2)}` : `${(n * 100).toFixed(1)}¢`;
+}
+
+function formatProgress(progress?: GSDState["progress"]): string | null {
+  if (!progress) return null;
+
+  const parts: string[] = [];
+  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: number, warningCount: number): string | null {
+  if (errorCount <= 0 && warningCount <= 0) return null;
+
+  const parts: string[] = [];
+  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: HealthWidgetData): string | null {
+  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: HealthWidgetData): string {
+  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().
+ */
+export function buildHealthLines(data: HealthWidgetData): string[] {
+  if (data.projectState === "none") {
+    return ["  GSD  No project loaded — run /gsd to start"];
+  }
+
+  if (data.projectState === "initialized") {
+    return ["  GSD  Project initialized — run /gsd to continue setup"];
+  }
+
+  const lines = [buildExecutionHeadline(data)];
+  const details: string[] = [];
+
+  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("  │  ")}`);
+  }
+
+  return lines;
+}

package/src/resources/extensions/gsd/health-widget.ts

@@ -9,41 +9,37 @@
  */
 
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
+import type { GSDState } from "./types.js";
 import { runProviderChecks, summariseProviderIssues } from "./doctor-providers.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { loadLedgerFromDisk, getProjectTotals } from "./metrics.js";
+import { describeNextUnit, estimateTimeRemaining, updateSliceProgressCache } from "./auto-dashboard.js";
 import { projectRoot } from "./commands.js";
-
-// ── Types ──────────────────────────────────────────────────────────────────────
-
-interface HealthWidgetData {
-  hasProject: boolean;
-  budgetCeiling: number | undefined;
-  budgetSpent: number;
-  providerIssue: string | null;      // compact summary from summariseProviderIssues()
-  environmentErrorCount: number;
-  environmentWarningCount: number;
-  lastRefreshed: number;
-}
+import { deriveState, invalidateStateCache } from "./state.js";
+import {
+  buildHealthLines,
+  detectHealthWidgetProjectState,
+  type HealthWidgetData,
+} from "./health-widget-core.js";
 
 // ── Data loader ────────────────────────────────────────────────────────────────
 
-function loadHealthWidgetData(basePath: string): HealthWidgetData {
-  let hasProject = false;
+function loadBaseHealthWidgetData(basePath: string): HealthWidgetData {
   let budgetCeiling: number | undefined;
   let budgetSpent = 0;
   let providerIssue: string | null = null;
   let environmentErrorCount = 0;
   let environmentWarningCount = 0;
 
+  const projectState = detectHealthWidgetProjectState(basePath);
+
   try {
     const prefs = loadEffectiveGSDPreferences();
     budgetCeiling = prefs?.preferences?.budget_ceiling;
 
     const ledger = loadLedgerFromDisk(basePath);
     if (ledger) {
-      hasProject = true;
       const totals = getProjectTotals(ledger.units ?? []);
       budgetSpent = totals.cost;
     }
@@ -63,7 +59,7 @@ function loadHealthWidgetData(basePath: string): HealthWidgetData {
   } catch { /* non-fatal */ }
 
   return {
-    hasProject,
+    projectState,
     budgetCeiling,
     budgetSpent,
     providerIssue,
@@ -73,54 +69,88 @@ function loadHealthWidgetData(basePath: string): HealthWidgetData {
   };
 }
 
-// ── Rendering ──────────────────────────────────────────────────────────────────
-
-function formatCost(n: number): string {
-  return n >= 1 ? `$${n.toFixed(2)}` : `${(n * 100).toFixed(1)}¢`;
+function compactText(text: string, max = 64): string {
+  const trimmed = text.replace(/\s+/g, " ").trim();
+  if (trimmed.length <= max) return trimmed;
+  return `${trimmed.slice(0, max - 1).trimEnd()}…`;
 }
 
-/**
- * Build compact health lines for the widget.
- * Returns a string array suitable for setWidget().
- */
-export function buildHealthLines(data: HealthWidgetData): string[] {
-  if (!data.hasProject) {
-    return ["  GSD  No project loaded — run /gsd to start"];
+function summarizeExecutionStatus(state: GSDState): string {
+  switch (state.phase) {
+    case "blocked": return "Blocked";
+    case "paused": return "Paused";
+    case "complete": return "Complete";
+    case "executing": return "Executing";
+    case "planning": return "Planning";
+    case "pre-planning": return "Pre-planning";
+    case "summarizing": return "Summarizing";
+    case "validating-milestone": return "Validating";
+    case "completing-milestone": return "Completing";
+    case "needs-discussion": return "Needs discussion";
+    case "replanning-slice": return "Replanning";
+    default: return "Active";
   }
+}
 
-  const parts: string[] = [];
-
-  // System status signal
-  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" : ""}`);
+function summarizeExecutionTarget(state: GSDState): string {
+  switch (state.phase) {
+    case "needs-discussion":
+      return state.activeMilestone ? `Discuss ${state.activeMilestone.id}` : "Discuss milestone draft";
+    case "pre-planning":
+      return state.activeMilestone ? `Plan ${state.activeMilestone.id}` : "Research & plan milestone";
+    case "planning":
+      return state.activeSlice ? `Plan ${state.activeSlice.id}` : "Plan next slice";
+    case "executing":
+      return state.activeTask ? `Execute ${state.activeTask.id}` : "Execute next task";
+    case "summarizing":
+      return state.activeSlice ? `Complete ${state.activeSlice.id}` : "Complete current slice";
+    case "validating-milestone":
+      return state.activeMilestone ? `Validate ${state.activeMilestone.id}` : "Validate milestone";
+    case "completing-milestone":
+      return state.activeMilestone ? `Complete ${state.activeMilestone.id}` : "Complete milestone";
+    case "replanning-slice":
+      return state.activeSlice ? `Replan ${state.activeSlice.id}` : "Replan current slice";
+    case "blocked":
+      return `waiting on ${compactText(state.blockers[0] ?? state.nextAction, 56)}`;
+    case "paused":
+      return compactText(state.nextAction || "waiting to resume", 56);
+    case "complete":
+      return "All milestones complete";
+    default:
+      return compactText(describeNextUnit(state).label, 56);
   }
+}
 
-  // Budget
-  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)}`);
-  }
+async function enrichHealthWidgetData(basePath: string, baseData: HealthWidgetData): Promise<HealthWidgetData> {
+  if (baseData.projectState !== "active") return baseData;
 
-  // Provider issue (if any)
-  if (data.providerIssue) {
-    parts.push(data.providerIssue);
-  }
+  try {
+    invalidateStateCache();
+    const state = await deriveState(basePath);
 
-  // Environment issues
-  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" : ""}`);
-  }
+    if (state.activeMilestone) {
+      // Warm the slice-progress cache so estimateTimeRemaining() has data
+      updateSliceProgressCache(basePath, state.activeMilestone.id, state.activeSlice?.id);
+    }
 
-  return [`  ${parts.join("  │  ")}`];
+    return {
+      ...baseData,
+      executionPhase: state.phase,
+      executionStatus: summarizeExecutionStatus(state),
+      executionTarget: summarizeExecutionTarget(state),
+      nextAction: state.nextAction,
+      blocker: state.blockers[0] ?? null,
+      activeMilestoneId: state.activeMilestone?.id,
+      activeSliceId: state.activeSlice?.id,
+      activeTaskId: state.activeTask?.id,
+      progress: state.progress,
+      eta: state.phase === "blocked" || state.phase === "paused" || state.phase === "complete"
+        ? null
+        : estimateTimeRemaining(),
+    };
+  } catch {
+    return baseData;
+  }
 }
 
 // ── Widget init ────────────────────────────────────────────────────────────────
@@ -137,20 +167,34 @@ export function initHealthWidget(ctx: ExtensionContext): void {
   const basePath = projectRoot();
 
   // String-array fallback — used in RPC mode (factory is a no-op there)
-  const initialData = loadHealthWidgetData(basePath);
+  const initialData = loadBaseHealthWidgetData(basePath);
   ctx.ui.setWidget("gsd-health", buildHealthLines(initialData), { placement: "belowEditor" });
 
   // Factory-based widget for TUI mode — replaces the string-array above
   ctx.ui.setWidget("gsd-health", (_tui, _theme) => {
     let data = initialData;
     let cachedLines: string[] | undefined;
+    let refreshInFlight = false;
 
-    const refreshTimer = setInterval(() => {
+    const refresh = async () => {
+      if (refreshInFlight) return;
+      refreshInFlight = true;
       try {
-        data = loadHealthWidgetData(basePath);
+        const baseData = loadBaseHealthWidgetData(basePath);
+        data = await enrichHealthWidgetData(basePath, baseData);
         cachedLines = undefined;
         _tui.requestRender();
-      } catch { /* non-fatal */ }
+      } catch { /* non-fatal */ } finally {
+        refreshInFlight = false;
+      }
+    };
+
+    // Fire first enrichment immediately. requestRender() inside is a no-op
+    // if the widget has not yet rendered, so this is safe before factory return.
+    void refresh();
+
+    const refreshTimer = setInterval(() => {
+      void refresh();
     }, REFRESH_INTERVAL_MS);
 
     return {