gsd-pi 2.39.0 → 2.40.0-dev.4a93031

package/src/resources/extensions/gsd/dashboard-overlay.ts

@@ -320,6 +320,16 @@ export class GSDDashboardOverlay {
         : progressScore.level === "yellow" ? th.fg("warning", "●")
           : th.fg("error", "●");
       lines.push(row(`${progressIcon} ${th.fg("text", progressScore.summary)}`));
+
+      // Show signal details when degraded — real-time visibility into what doctor found
+      if (progressScore.level !== "green" && progressScore.signals.length > 0) {
+        for (const signal of progressScore.signals) {
+          const prefix = signal.kind === "positive" ? th.fg("success", "  ✓")
+            : signal.kind === "negative" ? th.fg("error", "  ✗")
+              : th.fg("dim", "  ·");
+          lines.push(row(`${prefix} ${th.fg("dim", signal.label)}`));
+        }
+      }
     }
     lines.push(blank());
 

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

@@ -26,12 +26,26 @@ import { nativeBranchExists, nativeIsRepo } from "./native-git-bridge.js";
 
 // ── Health Score Tracking ──────────────────────────────────────────────────
 
+/** Compact issue detail stored per snapshot for real-time visibility. */
+export interface HealthIssueDetail {
+  code: string;
+  message: string;
+  severity: "error" | "warning" | "info";
+  unitId: string;
+}
+
 export interface HealthSnapshot {
   timestamp: number;
   errors: number;
   warnings: number;
   fixesApplied: number;
   unitIndex: number; // which unit dispatch triggered this snapshot
+  /** Top issues from the doctor run that produced this snapshot. */
+  issues: HealthIssueDetail[];
+  /** Fixes that were auto-applied during this snapshot's doctor run. */
+  fixes: string[];
+  /** Milestone/slice scope this snapshot belongs to (e.g. "M001" or "M001/S02"). */
+  scope?: string;
 }
 
 /** In-memory health history for the current auto-mode session. */
@@ -43,11 +57,33 @@ let consecutiveErrorUnits = 0;
 /** Unit index counter for health tracking. */
 let healthUnitIndex = 0;
 
+/** Previous progress level for state transition detection. */
+let previousProgressLevel: "green" | "yellow" | "red" = "green";
+
+/** Callback for state transition notifications. Set by auto-mode. */
+let onLevelChange: ((from: string, to: string, summary: string) => void) | null = null;
+
+/**
+ * Register a callback for progress level transitions (green→yellow, yellow→red, etc.).
+ * Called once when auto-mode starts. Pass null to unregister.
+ */
+export function setLevelChangeCallback(cb: ((from: string, to: string, summary: string) => void) | null): void {
+  onLevelChange = cb;
+  previousProgressLevel = "green";
+}
+
 /**
  * Record a health snapshot after a doctor run.
- * Called from the post-unit hook in auto.ts.
+ * Called from the post-unit hook in auto-post-unit.ts.
  */
-export function recordHealthSnapshot(errors: number, warnings: number, fixesApplied: number): void {
+export function recordHealthSnapshot(
+  errors: number,
+  warnings: number,
+  fixesApplied: number,
+  issues?: HealthIssueDetail[],
+  fixes?: string[],
+  scope?: string,
+): void {
   healthUnitIndex++;
   healthHistory.push({
     timestamp: Date.now(),
@@ -55,6 +91,9 @@ export function recordHealthSnapshot(errors: number, warnings: number, fixesAppl
     warnings,
     fixesApplied,
     unitIndex: healthUnitIndex,
+    issues: issues ?? [],
+    fixes: fixes ?? [],
+    scope,
   });
 
   // Keep only the last 50 snapshots to bound memory
@@ -67,6 +106,19 @@ export function recordHealthSnapshot(errors: number, warnings: number, fixesAppl
   } else {
     consecutiveErrorUnits = 0;
   }
+
+  // Detect progress level transitions and notify
+  if (onLevelChange) {
+    const newLevel = consecutiveErrorUnits >= 3 ? "red"
+      : consecutiveErrorUnits >= 1 || getHealthTrend() === "degrading" ? "yellow"
+        : "green";
+    if (newLevel !== previousProgressLevel) {
+      const topIssue = (issues ?? []).find(i => i.severity === "error") ?? (issues ?? [])[0];
+      const detail = topIssue ? `: ${topIssue.message}` : "";
+      onLevelChange(previousProgressLevel, newLevel, `Health ${previousProgressLevel} → ${newLevel}${detail}`);
+      previousProgressLevel = newLevel;
+    }
+  }
 }
 
 /**
@@ -104,6 +156,27 @@ export function getHealthHistory(): readonly HealthSnapshot[] {
   return healthHistory;
 }
 
+/**
+ * Get the latest health issues from the most recent snapshot.
+ * Returns issues from the last snapshot that had any, for real-time visibility.
+ */
+export function getLatestHealthIssues(): HealthIssueDetail[] {
+  for (let i = healthHistory.length - 1; i >= 0; i--) {
+    if (healthHistory[i]!.issues.length > 0) return healthHistory[i]!.issues;
+  }
+  return [];
+}
+
+/**
+ * Get the latest fixes applied from the most recent snapshot.
+ */
+export function getLatestHealthFixes(): string[] {
+  for (let i = healthHistory.length - 1; i >= 0; i--) {
+    if (healthHistory[i]!.fixes.length > 0) return healthHistory[i]!.fixes;
+  }
+  return [];
+}
+
 /**
  * Reset health tracking state. Called on auto-mode start/stop.
  */
@@ -111,6 +184,7 @@ export function resetHealthTracking(): void {
   healthHistory = [];
   consecutiveErrorUnits = 0;
   healthUnitIndex = 0;
+  previousProgressLevel = "green";
 }
 
 // ── Pre-Dispatch Health Gate ───────────────────────────────────────────────
@@ -285,26 +359,48 @@ export function resetEscalation(): void {
 
 /**
  * Format a health summary for display in the auto-mode dashboard.
+ * Human-readable with full words, not abbreviations.
  */
 export function formatHealthSummary(): string {
   if (healthHistory.length === 0) return "No health data yet.";
 
   const latest = healthHistory[healthHistory.length - 1]!;
   const trend = getHealthTrend();
-  const trendIcon = trend === "improving" ? "+" : trend === "degrading" ? "-" : "=";
+  const trendLabel = trend === "improving" ? "improving"
+    : trend === "degrading" ? "degrading"
+      : trend === "stable" ? "stable"
+        : "unknown";
   const totalFixes = healthHistory.reduce((sum, s) => sum + s.fixesApplied, 0);
 
-  const parts = [
-    `Health: ${latest.errors}E/${latest.warnings}W`,
-    `trend:${trendIcon}`,
-    `fixes:${totalFixes}`,
-  ];
+  const parts: string[] = [];
+
+  // Error/warning summary
+  if (latest.errors === 0 && latest.warnings === 0) {
+    parts.push("No issues");
+  } else {
+    const counts: string[] = [];
+    if (latest.errors > 0) counts.push(`${latest.errors} error${latest.errors > 1 ? "s" : ""}`);
+    if (latest.warnings > 0) counts.push(`${latest.warnings} warning${latest.warnings > 1 ? "s" : ""}`);
+    parts.push(counts.join(", "));
+  }
+
+  parts.push(`trend ${trendLabel}`);
+
+  if (totalFixes > 0) {
+    parts.push(`${totalFixes} fix${totalFixes > 1 ? "es" : ""} applied`);
+  }
 
   if (consecutiveErrorUnits > 0) {
-    parts.push(`streak:${consecutiveErrorUnits}/${ESCALATION_THRESHOLD}`);
+    parts.push(`${consecutiveErrorUnits} of ${ESCALATION_THRESHOLD} consecutive errors before escalation`);
+  }
+
+  // Include top issue from latest snapshot
+  if (latest.issues.length > 0) {
+    const topIssue = latest.issues.find(i => i.severity === "error") ?? latest.issues[0]!;
+    parts.push(`latest: ${topIssue.message}`);
   }
 
-  return parts.join(" | ");
+  return parts.join(" · ");
 }
 
 /**

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

@@ -387,18 +387,62 @@ function detectCircularDependencies(slices: RoadmapSliceEntry[]): string[][] {
 }
 
 // ── Helper: doctor run history ──────────────────────────────────────────────
-interface DoctorHistoryEntry { ts: string; ok: boolean; errors: number; warnings: number; fixes: number; codes: string[] }
+export interface DoctorHistoryEntry {
+  ts: string;
+  ok: boolean;
+  errors: number;
+  warnings: number;
+  fixes: number;
+  codes: string[];
+  /** Issue messages with severity and scope (added in Phase 2). */
+  issues?: Array<{ severity: string; code: string; message: string; unitId: string }>;
+  /** Fix descriptions applied during this run (added in Phase 2). */
+  fixDescriptions?: string[];
+  /** Milestone/slice scope this doctor run was scoped to (e.g. "M001/S02"). */
+  scope?: string;
+  /** Human-readable one-line summary of this doctor run. */
+  summary?: string;
+}
 
 async function appendDoctorHistory(basePath: string, report: DoctorReport): Promise<void> {
   try {
     const historyPath = join(gsdRoot(basePath), "doctor-history.jsonl");
+    const errorCount = report.issues.filter(i => i.severity === "error").length;
+    const warningCount = report.issues.filter(i => i.severity === "warning").length;
+    const issueDetails = report.issues
+      .filter(i => i.severity === "error" || i.severity === "warning")
+      .slice(0, 10) // cap to keep JSONL lines bounded
+      .map(i => ({ severity: i.severity, code: i.code, message: i.message, unitId: i.unitId }));
+
+    // Human-readable one-line summary
+    const summaryParts: string[] = [];
+    if (report.ok) {
+      summaryParts.push("Clean");
+    } else {
+      const counts: string[] = [];
+      if (errorCount > 0) counts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
+      if (warningCount > 0) counts.push(`${warningCount} warning${warningCount > 1 ? "s" : ""}`);
+      summaryParts.push(counts.join(", "));
+    }
+    if (report.fixesApplied.length > 0) {
+      summaryParts.push(`${report.fixesApplied.length} fixed`);
+    }
+    if (issueDetails.length > 0) {
+      const topIssue = issueDetails.find(i => i.severity === "error") ?? issueDetails[0]!;
+      summaryParts.push(topIssue.message);
+    }
+
     const entry = JSON.stringify({
       ts: new Date().toISOString(),
       ok: report.ok,
-      errors: report.issues.filter(i => i.severity === "error").length,
-      warnings: report.issues.filter(i => i.severity === "warning").length,
+      errors: errorCount,
+      warnings: warningCount,
       fixes: report.fixesApplied.length,
       codes: [...new Set(report.issues.map(i => i.code))],
+      issues: issueDetails.length > 0 ? issueDetails : undefined,
+      fixDescriptions: report.fixesApplied.length > 0 ? report.fixesApplied : undefined,
+      scope: (report as any).scope as string | undefined,
+      summary: summaryParts.join(" · "),
     } satisfies DoctorHistoryEntry);
     const existing = existsSync(historyPath) ? readFileSync(historyPath, "utf-8") : "";
     await saveFile(historyPath, existing + entry + "\n");

package/src/resources/extensions/gsd/export-html.ts

@@ -296,9 +296,60 @@ function buildHealthSection(data: VisualizerData): string {
       </tbody>
     </table>` : '';
 
+  // Progress score section
+  let progressHtml = '';
+  if (h.progressScore) {
+    const ps = h.progressScore;
+    const scoreColor = ps.level === 'green' ? '#22c55e' : ps.level === 'yellow' ? '#eab308' : '#ef4444';
+    const signalRows = ps.signals.map(s => {
+      const icon = s.kind === 'positive' ? '✓' : s.kind === 'negative' ? '✗' : '·';
+      const color = s.kind === 'positive' ? '#22c55e' : s.kind === 'negative' ? '#ef4444' : '#888';
+      return `<div style="margin-left:1em;color:${color}">${icon} ${esc(s.label)}</div>`;
+    }).join('');
+    progressHtml = `
+      <h3>Progress Score</h3>
+      <div style="font-size:1.1em;font-weight:bold;color:${scoreColor}">● ${esc(ps.summary)}</div>
+      ${signalRows}`;
+  }
+
+  // Doctor history section
+  let historyHtml = '';
+  const doctorHistory = h.doctorHistory ?? [];
+  if (doctorHistory.length > 0) {
+    const historyRows = doctorHistory.slice(0, 20).map(entry => {
+      const statusIcon = entry.ok ? '✓' : '✗';
+      const statusColor = entry.ok ? '#22c55e' : '#ef4444';
+      const ts = entry.ts.replace('T', ' ').slice(0, 19);
+      const scopeTag = entry.scope ? `<span class="mono" style="color:#888"> [${esc(entry.scope)}]</span>` : '';
+      const summaryText = entry.summary ? esc(entry.summary) : `${entry.errors} errors, ${entry.warnings} warnings, ${entry.fixes} fixes`;
+      const issueDetails = (entry.issues ?? []).slice(0, 3).map(i => {
+        const iColor = i.severity === 'error' ? '#ef4444' : '#eab308';
+        return `<div style="margin-left:2em;color:${iColor};font-size:0.85em">${i.severity === 'error' ? '✗' : '⚠'} ${esc(i.message)} <span class="mono" style="color:#888">${esc(i.unitId)}</span></div>`;
+      }).join('');
+      const fixDetails = (entry.fixDescriptions ?? []).slice(0, 2).map(f =>
+        `<div style="margin-left:2em;color:#22c55e;font-size:0.85em">↳ ${esc(f)}</div>`
+      ).join('');
+      return `<tr style="color:${statusColor}">
+        <td class="mono">${statusIcon}</td>
+        <td class="mono">${esc(ts)}${scopeTag}</td>
+        <td>${summaryText}</td>
+      </tr>
+      ${issueDetails || fixDetails ? `<tr><td colspan="3">${issueDetails}${fixDetails}</td></tr>` : ''}`;
+    }).join('');
+
+    historyHtml = `
+      <h3>Doctor Run History</h3>
+      <table class="tbl">
+        <thead><tr><th></th><th>Time</th><th>Summary</th></tr></thead>
+        <tbody>${historyRows}</tbody>
+      </table>`;
+  }
+
   return section('health', 'Health', `
     <table class="tbl tbl-kv"><tbody>${rows.join('')}</tbody></table>
     ${tierRows}
+    ${progressHtml}
+    ${historyHtml}
   `);
 }
 

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

@@ -20,7 +20,7 @@ import type {
   ManifestStatus,
 } from './types.js';
 
-import { checkExistingEnvKeys } from '../env-utils.js';
+import { checkExistingEnvKeys } from './env-utils.js';
 import { parseRoadmapSlices } from './roadmap-slices.js';
 import { nativeParseRoadmap, nativeExtractSection, nativeParsePlanFile, nativeParseSummaryFile, NATIVE_UNAVAILABLE } from './native-parser-bridge.js';
 import { debugTime, debugCount } from './debug-logger.js';

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

@@ -15,7 +15,8 @@ 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";
+import { projectRoot } from "./commands/context.js";
+import { deriveState, invalidateStateCache } from "./state.js";
 import {
   buildHealthLines,
   detectHealthWidgetProjectState,