gsd-pi 2.31.2 → 2.32.0-dev.d792ba5

package/dist/resources/extensions/gsd/tests/progress-score.test.ts

@@ -0,0 +1,206 @@
+/**
+ * progress-score.test.ts — Tests for progress score / traffic light (#1221).
+ *
+ * Tests:
+ *   - Score computation from health signals
+ *   - Signal evaluation (trend, error streak, recent errors)
+ *   - Context-aware scoring (retry counts, unit progress)
+ *   - Formatting (single-line, detailed report)
+ */
+
+import {
+  recordHealthSnapshot,
+  resetProactiveHealing,
+} from "../doctor-proactive.ts";
+
+import {
+  computeProgressScore,
+  computeProgressScoreWithContext,
+  formatProgressLine,
+  formatProgressReport,
+} from "../progress-score.ts";
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+async function main(): Promise<void> {
+  try {
+    // ── Base Score: No Data ─────────────────────────────────────────────
+    console.log("\n=== progress: green with no data ===");
+    {
+      resetProactiveHealing();
+      const score = computeProgressScore();
+      assertEq(score.level, "green", "green when no data available");
+      assertTrue(score.summary.includes("Progressing well"), "summary says progressing");
+      assertTrue(score.signals.length > 0, "has signals");
+    }
+
+    // ── Green: Clean Health Data ────────────────────────────────────────
+    console.log("\n=== progress: green with clean health ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(0, 0, 0);
+      }
+      const score = computeProgressScore();
+      assertEq(score.level, "green", "green with all clean snapshots");
+    }
+
+    // ── Yellow: Some Warnings ──────────────────────────────────────────
+    console.log("\n=== progress: yellow with error streak ===");
+    {
+      resetProactiveHealing();
+      recordHealthSnapshot(1, 2, 0);
+      recordHealthSnapshot(1, 1, 0);
+      const score = computeProgressScore();
+      assertEq(score.level, "yellow", "yellow with consecutive errors");
+      assertTrue(score.summary.includes("Struggling"), "summary says struggling");
+    }
+
+    // ── Red: Degrading Health ──────────────────────────────────────────
+    console.log("\n=== progress: red with degrading trend ===");
+    {
+      resetProactiveHealing();
+      // 5 older clean snapshots
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(0, 0, 0);
+      }
+      // 5 recent error snapshots — triggers degrading trend
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(3, 5, 0);
+      }
+      const score = computeProgressScore();
+      assertEq(score.level, "red", "red with degrading trend and persistent errors");
+      assertTrue(score.summary.includes("Stuck"), "summary says stuck");
+    }
+
+    // ── Red: High Error Streak ─────────────────────────────────────────
+    console.log("\n=== progress: red with high error streak ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 4; i++) {
+        recordHealthSnapshot(2, 0, 0);
+      }
+      const score = computeProgressScore();
+      assertEq(score.level, "red", "red with 4 consecutive error units");
+    }
+
+    // ── Context-Aware Scoring ──────────────────────────────────────────
+    console.log("\n=== progress: context with retries ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 3; i++) {
+        recordHealthSnapshot(0, 0, 0);
+      }
+      const score = computeProgressScoreWithContext({
+        currentUnitId: "M001/S01/T03",
+        completedUnits: 2,
+        totalUnits: 5,
+        retryCount: 0,
+        maxRetries: 5,
+      });
+      assertEq(score.level, "green", "green with no retries");
+      assertTrue(score.summary.includes("M001/S01/T03"), "summary includes unit ID");
+      assertTrue(score.summary.includes("2 of 5"), "summary includes progress");
+    }
+
+    console.log("\n=== progress: context with high retry count ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 3; i++) {
+        recordHealthSnapshot(0, 0, 0);
+      }
+      const score = computeProgressScoreWithContext({
+        currentUnitId: "M001/S01/T03",
+        retryCount: 4,
+        maxRetries: 5,
+      });
+      assertEq(score.level, "red", "red with high retry count");
+      assertTrue(score.summary.includes("looping"), "summary mentions looping");
+    }
+
+    console.log("\n=== progress: context with moderate retries ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 3; i++) {
+        recordHealthSnapshot(0, 0, 0);
+      }
+      const score = computeProgressScoreWithContext({
+        currentUnitId: "M001/S01/T03",
+        retryCount: 1,
+        maxRetries: 5,
+      });
+      assertEq(score.level, "yellow", "yellow with 1 retry");
+    }
+
+    // ── Formatting ─────────────────────────────────────────────────────
+    console.log("\n=== progress: formatProgressLine ===");
+    {
+      resetProactiveHealing();
+      const score = computeProgressScore();
+      const line = formatProgressLine(score);
+      assertTrue(line.includes("Progressing well"), "line includes summary");
+      // Should start with green circle emoji
+      assertTrue(line.startsWith("\uD83D\uDFE2"), "starts with green circle");
+    }
+
+    console.log("\n=== progress: formatProgressLine yellow ===");
+    {
+      resetProactiveHealing();
+      recordHealthSnapshot(1, 0, 0);
+      recordHealthSnapshot(1, 0, 0);
+      const score = computeProgressScore();
+      const line = formatProgressLine(score);
+      assertTrue(line.startsWith("\uD83D\uDFE1"), "starts with yellow circle");
+    }
+
+    console.log("\n=== progress: formatProgressReport ===");
+    {
+      resetProactiveHealing();
+      recordHealthSnapshot(0, 1, 0);
+      const score = computeProgressScore();
+      const detailed = formatProgressReport(score);
+      assertTrue(detailed.includes("Signals:"), "report has signals section");
+      assertTrue(detailed.includes("health_trend"), "report includes trend signal");
+      assertTrue(detailed.includes("error_streak"), "report includes streak signal");
+    }
+
+    // ── Signal Details ─────────────────────────────────────────────────
+    console.log("\n=== progress: signal names are consistent ===");
+    {
+      resetProactiveHealing();
+      recordHealthSnapshot(0, 0, 0);
+      const score = computeProgressScore();
+      const names = score.signals.map(s => s.name);
+      assertTrue(names.includes("health_trend"), "has health_trend signal");
+      assertTrue(names.includes("error_streak"), "has error_streak signal");
+      assertTrue(names.includes("recent_errors"), "has recent_errors signal");
+      assertTrue(names.includes("artifact_production"), "has artifact_production signal");
+      assertTrue(names.includes("dispatch_velocity"), "has dispatch_velocity signal");
+    }
+
+    console.log("\n=== progress: all signals have valid levels ===");
+    {
+      resetProactiveHealing();
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(1, 1, 1);
+      }
+      const score = computeProgressScore();
+      for (const signal of score.signals) {
+        assertTrue(
+          signal.level === "green" || signal.level === "yellow" || signal.level === "red",
+          `signal ${signal.name} has valid level: ${signal.level}`,
+        );
+        assertTrue(signal.detail.length > 0, `signal ${signal.name} has non-empty detail`);
+      }
+    }
+
+  } finally {
+    resetProactiveHealing();
+  }
+
+  report();
+}
+
+main();

package/dist/resources/extensions/gsd/tests/run-uat.test.ts

@@ -6,7 +6,8 @@
 //   (a)–(j)  extractUatType classification (17 assertions from T01)
 //   (k)      run-uat prompt template loading and content integrity (8 assertions)
 //   (l)      dispatch precondition assertions via resolveSliceFile (4 assertions)
-//   (m)      stale replay guard: existing UAT-RESULT never re-dispatches (2 assertions)
+//   (m)      non-artifact UAT skip: human-experience UATs are not dispatched (1 assertion)
+//   (n)      stale replay guard: existing UAT-RESULT never re-dispatches (1 assertion)
 
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
@@ -254,8 +255,8 @@ async function main(): Promise<void> {
     'prompt contains artifact-driven execution language (artifact/execute/run)',
   );
   assertTrue(
-    /surfaced for human review/i.test(promptResult ?? ''),
-    'prompt contains "surfaced for human review" text for non-artifact-driven path',
+    !/surfaced for human review/i.test(promptResult ?? ''),
+    'prompt does not contain "surfaced for human review" (non-artifact UATs are skipped, not dispatched)',
   );
 
   // ─── (l) dispatch precondition assertions via resolveSliceFile ────────────
@@ -310,8 +311,56 @@ async function main(): Promise<void> {
     }
   }
 
-  // ─── (m) stale replay guard: existing UAT-RESULT never re-dispatches ─────
-  console.log('\n── (m) stale replay guard');
+  // ─── (m) non-artifact UATs are skipped (not dispatched) ─────────────────
+  console.log('\n── (m) non-artifact UAT skip');
+
+  {
+    const base = createFixtureBase();
+    try {
+      const roadmapDir = join(base, '.gsd', 'milestones', 'M001');
+      mkdirSync(roadmapDir, { recursive: true });
+      writeFileSync(
+        join(roadmapDir, 'M001-ROADMAP.md'),
+        [
+          '# M001: Test roadmap',
+          '',
+          '## Slices',
+          '',
+          '- [x] **S01: First slice** `risk:low` `depends:[]`',
+          '- [ ] **S02: Next slice** `risk:low` `depends:[S01]`',
+          '',
+          '## Boundary Map',
+          '',
+        ].join('\n'),
+      );
+
+      // human-experience UAT — should not dispatch
+      writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('human-experience'));
+
+      const state = {
+        activeMilestone: { id: 'M001', title: 'Test roadmap' },
+        activeSlice: { id: 'S02', title: 'Next slice' },
+        activeTask: null,
+        phase: 'planning',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: 'Plan S02',
+        registry: [],
+      } as const;
+
+      const result = await checkNeedsRunUat(base, 'M001', state as any, { uat_dispatch: true } as any);
+      assertEq(
+        result,
+        null,
+        'human-experience UAT is skipped — auto-mode only dispatches artifact-driven UATs',
+      );
+    } finally {
+      cleanup(base);
+    }
+  }
+
+  // ─── (n) existing UAT-RESULT never re-dispatches ──────────────────────
+  console.log('\n── (n) stale replay guard');
 
   {
     const base = createFixtureBase();
@@ -334,7 +383,7 @@ async function main(): Promise<void> {
       );
 
       writeSliceFile(base, 'M001', 'S01', 'UAT', makeUatContent('artifact-driven'));
-      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '---\nverdict: surfaced-for-human-review\n---\n');
+      writeSliceFile(base, 'M001', 'S01', 'UAT-RESULT', '---\nverdict: FAIL\n---\n');
 
       const state = {
         activeMilestone: { id: 'M001', title: 'Test roadmap' },
@@ -351,7 +400,7 @@ async function main(): Promise<void> {
       assertEq(
         result,
         null,
-        'existing UAT-RESULT with non-PASS verdict does not re-dispatch run-uat; verdict gate owns blocking',
+        'existing UAT-RESULT with FAIL verdict does not re-dispatch; verdict gate owns blocking',
       );
     } finally {
       cleanup(base);

package/dist/resources/extensions/gsd/tests/visualizer-views.test.ts

@@ -60,6 +60,9 @@ function makeVisualizerData(overrides: Partial<VisualizerData> = {}): Visualizer
       toolCalls: 0,
       assistantMessages: 0,
       userMessages: 0,
+      providers: [],
+      skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null },
+      environmentIssues: [],
     },
     discussion: [],
     stats: {
@@ -503,6 +506,9 @@ console.log("\n=== renderAgentView ===");
       truncationRate: 15.5, continueHereRate: 5.0,
       tierBreakdown: [], tierSavingsLine: "",
       toolCalls: 20, assistantMessages: 15, userMessages: 8,
+      providers: [],
+      skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null },
+      environmentIssues: [],
     },
     captures: { entries: [], pendingCount: 3, totalCount: 5 },
   });
@@ -669,6 +675,9 @@ console.log("\n=== renderHealthView ===");
       toolCalls: 50,
       assistantMessages: 30,
       userMessages: 15,
+      providers: [],
+      skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null },
+      environmentIssues: [],
     },
   });
 
@@ -693,6 +702,9 @@ console.log("\n=== renderHealthView ===");
       truncationRate: 0, continueHereRate: 0,
       tierBreakdown: [], tierSavingsLine: "",
       toolCalls: 0, assistantMessages: 0, userMessages: 0,
+      providers: [],
+      skillSummary: { total: 0, warningCount: 0, criticalCount: 0, topIssue: null },
+      environmentIssues: [],
     },
   });
 

package/dist/resources/extensions/gsd/visualizer-data.ts

@@ -18,6 +18,9 @@ import {
 } from './metrics.js';
 import { loadAllCaptures, countPendingCaptures } from './captures.js';
 import { loadEffectiveGSDPreferences } from './preferences.js';
+import { runProviderChecks, type ProviderCheckResult } from './doctor-providers.js';
+import { generateSkillHealthReport } from './skill-health.js';
+import { runEnvironmentChecks, type EnvironmentCheckResult } from './doctor-environment.js';
 
 import type { Phase } from './types.js';
 import type { CaptureEntry } from './captures.js';
@@ -142,6 +145,22 @@ export interface CapturesInfo {
   totalCount: number;
 }
 
+export interface ProviderStatusSummary {
+  name: string;
+  label: string;
+  category: string;
+  ok: boolean;
+  required: boolean;
+  message: string;
+}
+
+export interface SkillSummaryInfo {
+  total: number;
+  warningCount: number;
+  criticalCount: number;
+  topIssue: string | null;
+}
+
 export interface HealthInfo {
   budgetCeiling: number | undefined;
   tokenProfile: string;
@@ -152,6 +171,9 @@ export interface HealthInfo {
   toolCalls: number;
   assistantMessages: number;
   userMessages: number;
+  providers: ProviderStatusSummary[];
+  skillSummary: SkillSummaryInfo;
+  environmentIssues: import("./doctor-environment.js").EnvironmentCheckResult[];
 }
 
 export interface VisualizerData {
@@ -538,7 +560,7 @@ function loadKnowledge(basePath: string): KnowledgeInfo {
 
 // ─── Health Loader ────────────────────────────────────────────────────────────
 
-function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null): HealthInfo {
+function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null, basePath: string): HealthInfo {
   const prefs = loadEffectiveGSDPreferences();
   const budgetCeiling = prefs?.preferences?.budget_ceiling;
   const tokenProfile = prefs?.preferences?.token_profile ?? 'standard';
@@ -553,6 +575,39 @@ function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null): HealthI
   const tierBreakdown = aggregateByTier(units);
   const tierSavingsLine = formatTierSavings(units);
 
+  // Provider checks — fast (auth.json + env vars only, no network)
+  let providers: ProviderStatusSummary[] = [];
+  try {
+    providers = runProviderChecks().map((r: ProviderCheckResult) => ({
+      name: r.name,
+      label: r.label,
+      category: r.category,
+      ok: r.status === "ok" || r.status === "unconfigured",
+      required: r.required,
+      message: r.message,
+    }));
+  } catch { /* non-fatal */ }
+
+  // Skill health summary
+  let skillSummary: SkillSummaryInfo = { total: 0, warningCount: 0, criticalCount: 0, topIssue: null };
+  try {
+    const report = generateSkillHealthReport(basePath);
+    const warnings = report.suggestions.filter(s => s.severity === "warning");
+    const criticals = report.suggestions.filter(s => s.severity === "critical");
+    skillSummary = {
+      total: report.skills.length,
+      warningCount: warnings.length,
+      criticalCount: criticals.length,
+      topIssue: report.suggestions[0]?.message ?? null,
+    };
+  } catch { /* non-fatal */ }
+
+  // Environment issues (from doctor-environment.ts, #1221)
+  let environmentIssues: EnvironmentCheckResult[] = [];
+  try {
+    environmentIssues = runEnvironmentChecks(basePath).filter(r => r.status !== "ok");
+  } catch { /* non-fatal */ }
+
   return {
     budgetCeiling,
     tokenProfile,
@@ -563,6 +618,9 @@ function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null): HealthI
     toolCalls: totals?.toolCalls ?? 0,
     assistantMessages: totals?.assistantMessages ?? 0,
     userMessages: totals?.userMessages ?? 0,
+    providers,
+    skillSummary,
+    environmentIssues,
   };
 }
 
@@ -780,7 +838,7 @@ export async function loadVisualizerData(basePath: string): Promise<VisualizerDa
     totalCount: allCaptures.length,
   };
 
-  const health = loadHealth(units, totals);
+  const health = loadHealth(units, totals, basePath);
   const stats = buildVisualizerStats(milestones, changelog.entries);
   const discussion = loadDiscussionState(basePath, milestones);
 

package/dist/resources/extensions/gsd/visualizer-views.ts

@@ -1113,5 +1113,59 @@ export function renderHealthView(
   lines.push(`  Tool calls: ${th.fg("text", String(health.toolCalls))}`);
   lines.push(`  Messages: ${th.fg("text", String(health.assistantMessages))} sent / ${th.fg("text", String(health.userMessages))} received`);
 
+  // Environment section — issues only (from doctor-environment.ts, #1221)
+  if (health.environmentIssues?.length > 0) {
+    lines.push("");
+    lines.push(th.fg("accent", th.bold("Environment")));
+    lines.push("");
+    for (const r of health.environmentIssues) {
+      const icon = r.status === "error" ? th.fg("error", "✗") : th.fg("warning", "⚠");
+      lines.push(`  ${icon} ${th.fg("text", r.message)}`);
+      if (r.detail) lines.push(`    ${th.fg("dim", r.detail)}`);
+    }
+  }
+
+  // Providers section
+  if (health.providers?.length > 0) {
+    lines.push("");
+    lines.push(th.fg("accent", th.bold("Providers")));
+    lines.push("");
+    const categoryOrder = ["llm", "remote", "search", "tool"];
+    const categoryLabels: Record<string, string> = { llm: "LLM", remote: "Notifications", search: "Search", tool: "Tools" };
+    const grouped = new Map<string, typeof health.providers>();
+    for (const p of health.providers) {
+      const cat = p.category;
+      if (!grouped.has(cat)) grouped.set(cat, []);
+      grouped.get(cat)!.push(p);
+    }
+    for (const cat of categoryOrder) {
+      const items = grouped.get(cat);
+      if (!items || items.length === 0) continue;
+      lines.push(`  ${th.fg("dim", categoryLabels[cat] ?? cat)}`);
+      for (const p of items) {
+        const icon = p.ok ? th.fg("success", "✓") : th.fg("error", "✗");
+        const msg = p.ok ? th.fg("dim", p.message) : th.fg("text", p.message);
+        lines.push(`    ${icon} ${msg}`);
+      }
+    }
+  }
+
+  // Skills section
+  if (health.skillSummary?.total > 0) {
+    lines.push("");
+    lines.push(th.fg("accent", th.bold("Skills")));
+    lines.push("");
+    const { total, warningCount, criticalCount, topIssue } = health.skillSummary;
+    const issueColor = criticalCount > 0 ? "error" : warningCount > 0 ? "warning" : "success";
+    const issueTag = criticalCount > 0
+      ? `${criticalCount} critical`
+      : warningCount > 0
+        ? `${warningCount} warning${warningCount > 1 ? "s" : ""}`
+        : "all healthy";
+    lines.push(`  ${th.fg("text", String(total))} skills tracked  ·  ${th.fg(issueColor, issueTag)}`);
+    if (topIssue) lines.push(`  ${th.fg("warning", "⚠")} ${th.fg("dim", topIssue)}`);
+    lines.push(`  ${th.fg("dim", "→ /gsd skill-health for full report")}`);
+  }
+
   return lines;
 }

package/dist/worktree-cli.d.ts

@@ -12,7 +12,43 @@
  * On session exit (via session_shutdown event), auto-commits dirty work
  * so nothing is lost. The GSD extension reads GSD_CLI_WORKTREE to know
  * when a session was launched via -w.
+ *
+ * Note: Extension modules are .ts files loaded via jiti (not compiled to .js).
+ * We use createJiti() here because this module is compiled by tsc but imports
+ * from resources/extensions/gsd/ which are shipped as raw .ts (#1283).
  */
+interface ExtensionModules {
+    createWorktree: (basePath: string, name: string) => {
+        path: string;
+        branch: string;
+    };
+    listWorktrees: (basePath: string) => Array<{
+        name: string;
+        path: string;
+        branch: string;
+    }>;
+    removeWorktree: (basePath: string, name: string, opts?: {
+        deleteBranch?: boolean;
+    }) => void;
+    mergeWorktreeToMain: (basePath: string, name: string, commitMessage: string) => void;
+    diffWorktreeAll: (basePath: string, name: string) => {
+        added: any[];
+        modified: any[];
+        removed: any[];
+    };
+    diffWorktreeNumstat: (basePath: string, name: string) => Array<{
+        added: number;
+        removed: number;
+    }>;
+    worktreeBranchName: (name: string) => string;
+    worktreePath: (basePath: string, name: string) => string;
+    runWorktreePostCreateHook: (basePath: string, wtPath: string) => string | null;
+    nativeHasChanges: (path: string) => boolean;
+    nativeDetectMainBranch: (basePath: string) => string;
+    nativeCommitCountBetween: (basePath: string, from: string, to: string) => number;
+    inferCommitType: (name: string) => string;
+    autoCommitCurrentBranch: (wtPath: string, reason: string, name: string) => void;
+}
 interface WorktreeStatus {
     name: string;
     path: string;
@@ -24,11 +60,11 @@ interface WorktreeStatus {
     uncommitted: boolean;
     commits: number;
 }
-declare function getWorktreeStatus(basePath: string, name: string, wtPath: string): WorktreeStatus;
-declare function handleList(basePath: string): void;
+declare function getWorktreeStatus(ext: ExtensionModules, basePath: string, name: string, wtPath: string): WorktreeStatus;
+declare function handleList(basePath: string): Promise<void>;
 declare function handleMerge(basePath: string, args: string[]): Promise<void>;
-declare function handleClean(basePath: string): void;
-declare function handleRemove(basePath: string, args: string[]): void;
-declare function handleStatusBanner(basePath: string): void;
-declare function handleWorktreeFlag(worktreeFlag: boolean | string): void;
+declare function handleClean(basePath: string): Promise<void>;
+declare function handleRemove(basePath: string, args: string[]): Promise<void>;
+declare function handleStatusBanner(basePath: string): Promise<void>;
+declare function handleWorktreeFlag(worktreeFlag: boolean | string): Promise<void>;
 export { handleList, handleMerge, handleClean, handleRemove, handleStatusBanner, handleWorktreeFlag, getWorktreeStatus, };