gsd-pi 2.38.0-dev.eeb3520 → 2.39.0-dev.20aba06

package/src/resources/extensions/gsd/context-budget.ts

@@ -9,7 +9,6 @@
  */
 
 import { type TokenProvider, getCharsPerToken } from "./token-counter.js";
-import { compressToTarget } from "./prompt-compressor.js";
 
 // ─── Budget ratio constants ──────────────────────────────────────────────────
 // Percentages of total context window allocated to each budget category.
@@ -202,22 +201,13 @@ export function resolveExecutorContextWindow(
 }
 
 /**
- * Smart context reduction: compress first, then truncate if still over budget.
- * Returns the content within budget with maximum information preservation.
+ * Reduce content to fit within budget using section-boundary truncation.
  */
 export function reduceToFit(content: string, budgetChars: number): TruncationResult {
   if (!content || content.length <= budgetChars) {
     return { content, droppedSections: 0 };
   }
-
-  // Step 1: Try compression
-  const compressed = compressToTarget(content, budgetChars);
-  if (compressed.compressedChars <= budgetChars) {
-    return { content: compressed.content, droppedSections: 0 };
-  }
-
-  // Step 2: Truncate the compressed content at section boundaries
-  return truncateAtSectionBoundary(compressed.content, budgetChars);
+  return truncateAtSectionBoundary(content, budgetChars);
 }
 
 // ─── Internal helpers ────────────────────────────────────────────────────────

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/detection.ts

@@ -11,6 +11,8 @@ import { join } from "node:path";
 import { homedir } from "node:os";
 import { gsdRoot } from "./paths.js";
 
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+
 // ─── Types ──────────────────────────────────────────────────────────────────────
 
 export interface ProjectDetection {
@@ -400,7 +402,6 @@ function detectVerificationCommands(
  * Check if global GSD setup exists (has ~/.gsd/ with preferences).
  */
 export function hasGlobalSetup(): boolean {
-  const gsdHome = join(homedir(), ".gsd");
   return (
     existsSync(join(gsdHome, "preferences.md")) ||
     existsSync(join(gsdHome, "PREFERENCES.md"))
@@ -412,7 +413,6 @@ export function hasGlobalSetup(): boolean {
  * Returns true if ~/.gsd/ doesn't exist or has no preferences or auth.
  */
 export function isFirstEverLaunch(): boolean {
-  const gsdHome = join(homedir(), ".gsd");
   if (!existsSync(gsdHome)) return true;
 
   // If we have preferences, not first launch

package/src/resources/extensions/gsd/docs/preferences-reference.md

@@ -194,8 +194,6 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `search_provider`: `"brave"`, `"tavily"`, `"ollama"`, `"native"`, or `"auto"` — selects the search backend for research phases. `"native"` forces Anthropic's built-in web search only; provider values force that backend and disable native search; `"auto"` uses the default heuristic. Default: `"auto"`.
 
-- `compression_strategy`: `"truncate"` or `"compress"` — controls how context that exceeds the budget is reduced. `"truncate"` (default) drops sections from the end. `"compress"` applies heuristic compression before truncating, preserving more content at the cost of some fidelity. Default: `"truncate"`.
-
 - `context_selection`: `"full"` or `"smart"` — controls how files are inlined into context. `"full"` inlines entire files; `"smart"` uses semantic chunking to include only the most relevant sections. Default is derived from `token_profile`.
 
 - `parallel`: configures parallel orchestration for running multiple slices concurrently. Keys:

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

@@ -657,6 +657,81 @@ export async function checkRuntimeHealth(
   } catch {
     // Non-fatal — external state check failed
   }
+
+  // ── Metrics ledger integrity ───────────────────────────────────────────
+  try {
+    const metricsPath = join(root, "metrics.json");
+    if (existsSync(metricsPath)) {
+      try {
+        const raw = readFileSync(metricsPath, "utf-8");
+        const ledger = JSON.parse(raw);
+        if (ledger.version !== 1 || !Array.isArray(ledger.units)) {
+          issues.push({
+            severity: "warning",
+            code: "metrics_ledger_corrupt",
+            scope: "project",
+            unitId: "project",
+            message: "metrics.json has an unexpected structure (version !== 1 or units is not an array) — metrics data may be unreliable",
+            file: ".gsd/metrics.json",
+            fixable: false,
+          });
+        }
+      } catch {
+        issues.push({
+          severity: "warning",
+          code: "metrics_ledger_corrupt",
+          scope: "project",
+          unitId: "project",
+          message: "metrics.json is not valid JSON — metrics data may be corrupt",
+          file: ".gsd/metrics.json",
+          fixable: false,
+        });
+      }
+    }
+  } catch {
+    // Non-fatal — metrics check failed
+  }
+
+  // ── Large planning file detection ──────────────────────────────────────
+  // Files over 100KB can cause LLM context pressure. Report the worst offenders.
+  try {
+    const MAX_FILE_BYTES = 100 * 1024; // 100KB
+    const milestonesPath = milestonesDir(basePath);
+    if (existsSync(milestonesPath)) {
+      const largeFiles: Array<{ path: string; sizeKB: number }> = [];
+      function scanForLargeFiles(dir: string, depth = 0): void {
+        if (depth > 6) return;
+        try {
+          for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            try {
+              const s = statSync(full);
+              if (s.isDirectory()) { scanForLargeFiles(full, depth + 1); continue; }
+              if (entry.endsWith(".md") && s.size > MAX_FILE_BYTES) {
+                largeFiles.push({ path: full.replace(basePath + "/", ""), sizeKB: Math.round(s.size / 1024) });
+              }
+            } catch { /* skip entry */ }
+          }
+        } catch { /* skip dir */ }
+      }
+      scanForLargeFiles(milestonesPath);
+      if (largeFiles.length > 0) {
+        largeFiles.sort((a, b) => b.sizeKB - a.sizeKB);
+        const worst = largeFiles[0]!;
+        issues.push({
+          severity: "warning",
+          code: "large_planning_file",
+          scope: "project",
+          unitId: "project",
+          message: `${largeFiles.length} planning file(s) exceed 100KB — largest: ${worst.path} (${worst.sizeKB}KB). Large files cause LLM context pressure.`,
+          file: worst.path,
+          fixable: false,
+        });
+      }
+    }
+  } catch {
+    // Non-fatal — large file scan failed
+  }
 }
 
 /**

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

@@ -407,6 +407,63 @@ function checkGitRemote(basePath: string): EnvironmentCheckResult | null {
   return { name: "git_remote", status: "ok", message: "Git remote reachable" };
 }
 
+/**
+ * Check if the project build passes (opt-in slow check, use --build flag).
+ * Runs npm run build and reports failure as env_build.
+ */
+function checkBuildHealth(basePath: string): EnvironmentCheckResult | null {
+  const pkgPath = join(basePath, "package.json");
+  if (!existsSync(pkgPath)) return null;
+
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const buildScript = pkg.scripts?.build;
+    if (!buildScript) return null;
+
+    const result = tryExec("npm run build 2>&1", basePath);
+    if (result === null) {
+      return {
+        name: "build",
+        status: "error",
+        message: "Build failed — npm run build exited non-zero",
+        detail: "Fix build errors before dispatching work",
+      };
+    }
+    return { name: "build", status: "ok", message: "Build passes" };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if tests pass (opt-in slow check, use --test flag).
+ * Runs npm test and reports failures as env_test.
+ */
+function checkTestHealth(basePath: string): EnvironmentCheckResult | null {
+  const pkgPath = join(basePath, "package.json");
+  if (!existsSync(pkgPath)) return null;
+
+  try {
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const testScript = pkg.scripts?.test;
+    // Skip if no test script or the default placeholder
+    if (!testScript || testScript.includes("no test specified")) return null;
+
+    const result = tryExec("npm test 2>&1", basePath);
+    if (result === null) {
+      return {
+        name: "test",
+        status: "warning",
+        message: "Tests failing — npm test exited non-zero",
+        detail: "Fix failing tests before shipping",
+      };
+    }
+    return { name: "test", status: "ok", message: "Tests pass" };
+  } catch {
+    return null;
+  }
+}
+
 // ── Public API ─────────────────────────────────────────────────────────────
 
 /**
@@ -454,6 +511,26 @@ export function runFullEnvironmentChecks(basePath: string): EnvironmentCheckResu
   return results;
 }
 
+/**
+ * Run slow opt-in checks (build and/or test).
+ * These are never run on the pre-dispatch gate — only on explicit /gsd doctor --build/--test.
+ */
+export function runSlowEnvironmentChecks(
+  basePath: string,
+  options?: { includeBuild?: boolean; includeTests?: boolean },
+): EnvironmentCheckResult[] {
+  const results: EnvironmentCheckResult[] = [];
+  if (options?.includeBuild) {
+    const buildCheck = checkBuildHealth(basePath);
+    if (buildCheck) results.push(buildCheck);
+  }
+  if (options?.includeTests) {
+    const testCheck = checkTestHealth(basePath);
+    if (testCheck) results.push(testCheck);
+  }
+  return results;
+}
+
 /**
  * Convert environment check results to DoctorIssue format for the doctor pipeline.
  */
@@ -477,12 +554,16 @@ export function environmentResultsToDoctorIssues(results: EnvironmentCheckResult
 export async function checkEnvironmentHealth(
   basePath: string,
   issues: DoctorIssue[],
-  options?: { includeRemote?: boolean },
+  options?: { includeRemote?: boolean; includeBuild?: boolean; includeTests?: boolean },
 ): Promise<void> {
   const results = options?.includeRemote
     ? runFullEnvironmentChecks(basePath)
     : runEnvironmentChecks(basePath);
 
+  if (options?.includeBuild || options?.includeTests) {
+    results.push(...runSlowEnvironmentChecks(basePath, options));
+  }
+
   issues.push(...environmentResultsToDoctorIssues(results));
 }
 

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

@@ -76,3 +76,23 @@ export function formatDoctorIssuesForPrompt(issues: DoctorIssue[]): string {
     return `- [${prefix}] ${issue.unitId} | ${issue.code} | ${issue.message}${issue.file ? ` | file: ${issue.file}` : ""} | fixable: ${issue.fixable ? "yes" : "no"}`;
   }).join("\n");
 }
+
+/**
+ * Serialize a doctor report to JSON — suitable for CI/tooling integration.
+ * Usage: /gsd doctor --json
+ */
+export function formatDoctorReportJson(report: DoctorReport): string {
+  return JSON.stringify(
+    {
+      ok: report.ok,
+      basePath: report.basePath,
+      generatedAt: new Date().toISOString(),
+      summary: summarizeDoctorIssues(report.issues),
+      issues: report.issues,
+      fixesApplied: report.fixesApplied,
+      ...(report.timing ? { timing: report.timing } : {}),
+    },
+    null,
+    2,
+  );
+}

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-providers.ts

@@ -51,10 +51,12 @@ function modelToProviderId(model: string): string | null {
     const prefix = model.split("/")[0].toLowerCase();
     // Map known prefixes to registry IDs
     const prefixMap: Record<string, string> = {
+      "anthropic-vertex": "anthropic-vertex",
       openrouter: "openrouter",
       groq: "groq",
       mistral: "mistral",
       google: "google",
+      "google-vertex": "google-vertex",
       anthropic: "anthropic",
       openai: "openai",
       "github-copilot": "github-copilot",
@@ -88,11 +90,20 @@ function collectConfiguredModelProviders(): Set<string> {
 
     const modelEntries = typeof models === "object" ? Object.values(models) : [];
     for (const entry of modelEntries) {
-      const modelId = typeof entry === "string" ? entry
-        : typeof entry === "object" && entry !== null && "model" in entry
-          ? String((entry as { model: unknown }).model)
-          : null;
-      if (modelId) {
+      if (typeof entry === "string") {
+        const pid = modelToProviderId(entry);
+        if (pid) providers.add(pid);
+        continue;
+      }
+
+      if (typeof entry === "object" && entry !== null && "model" in entry) {
+        const configuredProvider = "provider" in entry ? (entry as { provider?: unknown }).provider : undefined;
+        if (typeof configuredProvider === "string" && configuredProvider.trim().length > 0) {
+          providers.add(configuredProvider);
+          continue;
+        }
+
+        const modelId = String((entry as { model: unknown }).model);
         const pid = modelToProviderId(modelId);
         if (pid) providers.add(pid);
       }
@@ -117,6 +128,10 @@ interface KeyLookup {
 function resolveKey(providerId: string): KeyLookup {
   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)) {
@@ -175,7 +190,9 @@ function checkLlmProviders(): ProviderCheckResult[] {
 
   for (const providerId of required) {
     const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
-    const label = info?.label ?? providerId;
+    const label = providerId === "anthropic-vertex"
+      ? "Anthropic Vertex"
+      : info?.label ?? providerId;
     const lookup = resolveKey(providerId);
 
     if (!lookup.found) {
@@ -196,14 +213,18 @@ function checkLlmProviders(): ProviderCheckResult[] {
         continue;
       }
 
-      const envVar = info?.envVar ?? `${providerId.toUpperCase()}_API_KEY`;
+      const envVar = providerId === "anthropic-vertex"
+        ? "ANTHROPIC_VERTEX_PROJECT_ID"
+        : info?.envVar ?? `${providerId.toUpperCase()}_API_KEY`;
       results.push({
         name: providerId,
         label,
         category: "llm",
         status: "error",
-        message: `${label} — no API key found`,
-        detail: info?.hasOAuth
+        message: `${label} — not configured`,
+        detail: providerId === "anthropic-vertex"
+          ? "Set ANTHROPIC_VERTEX_PROJECT_ID and authenticate with Google ADC"
+          : info?.hasOAuth
           ? `Run /gsd keys to authenticate`
           : `Set ${envVar} or run /gsd keys`,
         required: true,

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

@@ -53,7 +53,20 @@ export type DoctorIssueCode =
   | "stranded_lock_directory"
   // Git / worktree integrity checks
   | "integration_branch_missing"
-  | "worktree_directory_orphaned";
+  | "worktree_directory_orphaned"
+  // GSD state structural checks
+  | "circular_slice_dependency"
+  | "orphaned_slice_directory"
+  | "duplicate_task_id"
+  | "task_file_not_in_plan"
+  | "stale_replan_file"
+  | "future_timestamp"
+  // Runtime data integrity
+  | "metrics_ledger_corrupt"
+  | "large_planning_file"
+  // Slow environment checks (opt-in via --build / --test flags)
+  | "env_build"
+  | "env_test";
 
 /**
  * Issue codes that represent expected completion-transition states.
@@ -83,6 +96,8 @@ export interface DoctorReport {
   basePath: string;
   issues: DoctorIssue[];
   fixesApplied: string[];
+  /** Per-domain check durations in milliseconds. Present on explicit /gsd doctor runs. */
+  timing?: { git: number; runtime: number; environment: number; gsdState: number };
 }
 
 export interface DoctorSummary {