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

package/dist/resources/extensions/gsd/context-budget.js

@@ -8,7 +8,6 @@
  * @see D001 (module location), D002 (200K fallback), D003 (section-boundary truncation)
  */
 import { getCharsPerToken } from "./token-counter.js";
-import { compressToTarget } from "./prompt-compressor.js";
 // ─── Budget ratio constants ──────────────────────────────────────────────────
 // Percentages of total context window allocated to each budget category.
 // These are applied after tokens→chars conversion.
@@ -132,20 +131,13 @@ export function resolveExecutorContextWindow(registry, preferences, sessionConte
     return DEFAULT_CONTEXT_WINDOW;
 }
 /**
- * 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, budgetChars) {
     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/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -282,6 +282,15 @@ 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());
         if (this.dashData.currentUnit) {

package/dist/resources/extensions/gsd/detection.js

@@ -9,6 +9,7 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { gsdRoot } from "./paths.js";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 // ─── Project File Markers ───────────────────────────────────────────────────────
 const PROJECT_FILES = [
     "package.json",
@@ -309,7 +310,6 @@ function detectVerificationCommands(basePath, detectedFiles, packageManager) {
  * Check if global GSD setup exists (has ~/.gsd/ with preferences).
  */
 export function hasGlobalSetup() {
-    const gsdHome = join(homedir(), ".gsd");
     return (existsSync(join(gsdHome, "preferences.md")) ||
         existsSync(join(gsdHome, "PREFERENCES.md")));
 }
@@ -318,7 +318,6 @@ export function hasGlobalSetup() {
  * Returns true if ~/.gsd/ doesn't exist or has no preferences or auth.
  */
 export function isFirstEverLaunch() {
-    const gsdHome = join(homedir(), ".gsd");
     if (!existsSync(gsdHome))
         return true;
     // If we have preferences, not first launch

package/dist/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/dist/resources/extensions/gsd/doctor-checks.js

@@ -618,6 +618,88 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
     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 = [];
+            function scanForLargeFiles(dir, depth = 0) {
+                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
+    }
 }
 /**
  * Build STATE.md markdown content from derived state.

package/dist/resources/extensions/gsd/doctor-environment.js

@@ -355,6 +355,63 @@ function checkGitRemote(basePath) {
     }
     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) {
+    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) {
+    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 ─────────────────────────────────────────────────────────────
 /**
  * Run all environment health checks. Returns structured results for
@@ -394,6 +451,24 @@ export function runFullEnvironmentChecks(basePath) {
         results.push(remoteCheck);
     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, options) {
+    const results = [];
+    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.
  */
@@ -417,6 +492,9 @@ export async function checkEnvironmentHealth(basePath, issues, options) {
     const results = options?.includeRemote
         ? runFullEnvironmentChecks(basePath)
         : runEnvironmentChecks(basePath);
+    if (options?.includeBuild || options?.includeTests) {
+        results.push(...runSlowEnvironmentChecks(basePath, options));
+    }
     issues.push(...environmentResultsToDoctorIssues(results));
 }
 /**

package/dist/resources/extensions/gsd/doctor-format.js

@@ -69,3 +69,18 @@ export function formatDoctorIssuesForPrompt(issues) {
         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) {
+    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/dist/resources/extensions/gsd/doctor-proactive.js

@@ -28,11 +28,23 @@ let healthHistory = [];
 let consecutiveErrorUnits = 0;
 /** Unit index counter for health tracking. */
 let healthUnitIndex = 0;
+/** Previous progress level for state transition detection. */
+let previousProgressLevel = "green";
+/** Callback for state transition notifications. Set by auto-mode. */
+let onLevelChange = 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) {
+    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, warnings, fixesApplied) {
+export function recordHealthSnapshot(errors, warnings, fixesApplied, issues, fixes, scope) {
     healthUnitIndex++;
     healthHistory.push({
         timestamp: Date.now(),
@@ -40,6 +52,9 @@ export function recordHealthSnapshot(errors, warnings, fixesApplied) {
         warnings,
         fixesApplied,
         unitIndex: healthUnitIndex,
+        issues: issues ?? [],
+        fixes: fixes ?? [],
+        scope,
     });
     // Keep only the last 50 snapshots to bound memory
     if (healthHistory.length > 50) {
@@ -51,6 +66,18 @@ export function recordHealthSnapshot(errors, warnings, fixesApplied) {
     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;
+        }
+    }
 }
 /**
  * Get the current health trend.
@@ -84,6 +111,27 @@ export function getConsecutiveErrorUnits() {
 export function getHealthHistory() {
     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() {
+    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() {
+    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.
  */
@@ -91,6 +139,7 @@ export function resetHealthTracking() {
     healthHistory = [];
     consecutiveErrorUnits = 0;
     healthUnitIndex = 0;
+    previousProgressLevel = "green";
 }
 /**
  * Lightweight pre-dispatch health check. Runs fast checks that should
@@ -234,23 +283,44 @@ export function resetEscalation() {
 }
 /**
  * Format a health summary for display in the auto-mode dashboard.
+ * Human-readable with full words, not abbreviations.
  */
 export function formatHealthSummary() {
     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 = [];
+    // Error/warning summary
+    if (latest.errors === 0 && latest.warnings === 0) {
+        parts.push("No issues");
+    }
+    else {
+        const counts = [];
+        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(" · ");
 }
 /**
  * Reset all proactive healing state. Called on auto-mode start/stop.

package/dist/resources/extensions/gsd/doctor-providers.js

@@ -28,10 +28,12 @@ function modelToProviderId(model) {
         const prefix = model.split("/")[0].toLowerCase();
         // Map known prefixes to registry IDs
         const prefixMap = {
+            "anthropic-vertex": "anthropic-vertex",
             openrouter: "openrouter",
             groq: "groq",
             mistral: "mistral",
             google: "google",
+            "google-vertex": "google-vertex",
             anthropic: "anthropic",
             openai: "openai",
             "github-copilot": "github-copilot",
@@ -67,11 +69,19 @@ function collectConfiguredModelProviders() {
         }
         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.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.provider : undefined;
+                if (typeof configuredProvider === "string" && configuredProvider.trim().length > 0) {
+                    providers.add(configuredProvider);
+                    continue;
+                }
+                const modelId = String(entry.model);
                 const pid = modelToProviderId(modelId);
                 if (pid)
                     providers.add(pid);
@@ -88,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)) {
@@ -138,7 +151,9 @@ function checkLlmProviders() {
     const results = [];
     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) {
             // Check if a cross-provider can serve this provider's models
@@ -157,16 +172,20 @@ function checkLlmProviders() {
                 });
                 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
-                    ? `Run /gsd keys to authenticate`
-                    : `Set ${envVar} or run /gsd keys`,
+                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,
             });
         }