gsd-pi 2.37.1-dev.d3ace49 → 2.38.0-dev.63ad7e5

package/dist/resources/extensions/gsd/auto-worktree-sync.js

@@ -13,6 +13,7 @@ import { existsSync, readFileSync, unlinkSync, readdirSync, } from "node:fs";
 import { join, sep as pathSep } from "node:path";
 import { homedir } from "node:os";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 // ─── Project Root → Worktree Sync ─────────────────────────────────────────
 /**
  * Sync milestone artifacts from project root INTO worktree before deriveState.
@@ -75,7 +76,7 @@ export function syncStateToProjectRoot(worktreePath, projectRoot, milestoneId) {
  * doesn't falsely trigger staleness (#804).
  */
 export function readResourceVersion() {
-    const agentDir = process.env.GSD_CODING_AGENT_DIR || join(homedir(), ".gsd", "agent");
+    const agentDir = process.env.GSD_CODING_AGENT_DIR || join(gsdHome, "agent");
     const manifestPath = join(agentDir, "managed-resources.json");
     try {
         const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
@@ -115,10 +116,17 @@ export function checkResourcesStale(versionOnStart) {
  * Returns the corrected base path.
  */
 export function escapeStaleWorktree(base) {
-    const marker = `${pathSep}.gsd${pathSep}worktrees${pathSep}`;
-    const idx = base.indexOf(marker);
-    if (idx === -1)
-        return base;
+    // Direct layout: /.gsd/worktrees/
+    const directMarker = `${pathSep}.gsd${pathSep}worktrees${pathSep}`;
+    let idx = base.indexOf(directMarker);
+    if (idx === -1) {
+        // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/
+        const symlinkRe = new RegExp(`\\${pathSep}\\.gsd\\${pathSep}projects\\${pathSep}[a-f0-9]+\\${pathSep}worktrees\\${pathSep}`);
+        const match = base.match(symlinkRe);
+        if (!match || match.index === undefined)
+            return base;
+        idx = match.index;
+    }
     // base is inside .gsd/worktrees/<something> — extract the project root
     const projectRoot = base.slice(0, idx);
     try {

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

@@ -297,116 +297,163 @@ export async function stopAuto(ctx, pi, reason) {
         return;
     const loadedPreferences = loadEffectiveGSDPreferences()?.preferences;
     const reasonSuffix = reason ? ` — ${reason}` : "";
-    clearUnitTimeout();
-    if (lockBase())
-        clearLock(lockBase());
-    if (lockBase())
-        releaseSessionLock(lockBase());
-    clearSkillSnapshot();
-    resetSkillTelemetry();
-    // Remove SIGTERM handler registered at auto-mode start
-    deregisterSigtermHandler();
-    // ── Auto-worktree: exit worktree and reset s.basePath on stop ──
-    if (s.currentMilestoneId) {
-        const notifyCtx = ctx
-            ? { notify: ctx.ui.notify.bind(ctx.ui) }
-            : { notify: () => { } };
-        buildResolver().exitMilestone(s.currentMilestoneId, notifyCtx, {
-            preserveBranch: true,
-        });
-    }
-    // ── DB cleanup: close the SQLite connection ──
-    if (isDbAvailable()) {
+    try {
+        // ── Step 1: Timers and locks ──
         try {
-            const { closeDatabase } = await import("./gsd-db.js");
-            closeDatabase();
+            clearUnitTimeout();
+            if (lockBase())
+                clearLock(lockBase());
+            if (lockBase())
+                releaseSessionLock(lockBase());
         }
         catch (e) {
-            debugLog("db-close-failed", {
-                error: e instanceof Error ? e.message : String(e),
-            });
+            debugLog("stop-cleanup-locks", { error: e instanceof Error ? e.message : String(e) });
         }
-    }
-    if (s.originalBasePath) {
-        s.basePath = s.originalBasePath;
+        // ── Step 2: Skill state ──
         try {
-            process.chdir(s.basePath);
+            clearSkillSnapshot();
+            resetSkillTelemetry();
         }
-        catch {
-            /* best-effort */
+        catch (e) {
+            debugLog("stop-cleanup-skills", { error: e instanceof Error ? e.message : String(e) });
         }
-    }
-    const ledger = getLedger();
-    if (ledger && ledger.units.length > 0) {
-        const totals = getProjectTotals(ledger.units);
-        ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}. Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${ledger.units.length} units`, "info");
-    }
-    else {
-        ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}.`, "info");
-    }
-    if (s.basePath) {
+        // ── Step 3: SIGTERM handler ──
         try {
-            await rebuildState(s.basePath);
+            deregisterSigtermHandler();
         }
         catch (e) {
-            debugLog("stop-rebuild-state-failed", {
-                error: e instanceof Error ? e.message : String(e),
-            });
+            debugLog("stop-cleanup-sigterm", { error: e instanceof Error ? e.message : String(e) });
         }
-    }
-    clearCmuxSidebar(loadedPreferences);
-    logCmuxEvent(loadedPreferences, `Auto-mode stopped${reasonSuffix || ""}.`, reason?.startsWith("Blocked:") ? "warning" : "info");
-    if (isDebugEnabled()) {
-        const logPath = writeDebugSummary();
-        if (logPath) {
-            ctx?.ui.notify(`Debug log written → ${logPath}`, "info");
+        // ── Step 4: Auto-worktree exit ──
+        try {
+            if (s.currentMilestoneId) {
+                const notifyCtx = ctx
+                    ? { notify: ctx.ui.notify.bind(ctx.ui) }
+                    : { notify: () => { } };
+                buildResolver().exitMilestone(s.currentMilestoneId, notifyCtx, {
+                    preserveBranch: true,
+                });
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-worktree", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 5: DB cleanup ──
+        if (isDbAvailable()) {
+            try {
+                const { closeDatabase } = await import("./gsd-db.js");
+                closeDatabase();
+            }
+            catch (e) {
+                debugLog("db-close-failed", {
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        // ── Step 6: Restore basePath and chdir ──
+        try {
+            if (s.originalBasePath) {
+                s.basePath = s.originalBasePath;
+                try {
+                    process.chdir(s.basePath);
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-basepath", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 7: Ledger notification ──
+        try {
+            const ledger = getLedger();
+            if (ledger && ledger.units.length > 0) {
+                const totals = getProjectTotals(ledger.units);
+                ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}. Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${ledger.units.length} units`, "info");
+            }
+            else {
+                ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}.`, "info");
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-ledger", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 8: Rebuild state ──
+        if (s.basePath) {
+            try {
+                await rebuildState(s.basePath);
+            }
+            catch (e) {
+                debugLog("stop-rebuild-state-failed", {
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        // ── Step 9: Cmux sidebar / event log ──
+        try {
+            clearCmuxSidebar(loadedPreferences);
+            logCmuxEvent(loadedPreferences, `Auto-mode stopped${reasonSuffix || ""}.`, reason?.startsWith("Blocked:") ? "warning" : "info");
+        }
+        catch (e) {
+            debugLog("stop-cleanup-cmux", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 10: Debug summary ──
+        try {
+            if (isDebugEnabled()) {
+                const logPath = writeDebugSummary();
+                if (logPath) {
+                    ctx?.ui.notify(`Debug log written → ${logPath}`, "info");
+                }
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-debug", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 11: Reset metrics, routing, hooks ──
+        try {
+            resetMetrics();
+            resetRoutingHistory();
+            resetHookState();
+            if (s.basePath)
+                clearPersistedHookState(s.basePath);
+        }
+        catch (e) {
+            debugLog("stop-cleanup-metrics", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 12: Remove paused-session metadata (#1383) ──
+        try {
+            const pausedPath = join(gsdRoot(s.originalBasePath || s.basePath), "runtime", "paused-session.json");
+            if (existsSync(pausedPath))
+                unlinkSync(pausedPath);
+        }
+        catch { /* non-fatal */ }
+        // ── Step 13: Restore original model (before reset clears IDs) ──
+        try {
+            if (pi && ctx && s.originalModelId && s.originalModelProvider) {
+                const original = ctx.modelRegistry.find(s.originalModelProvider, s.originalModelId);
+                if (original)
+                    await pi.setModel(original);
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-model", { error: e instanceof Error ? e.message : String(e) });
         }
     }
-    resetMetrics();
-    resetRoutingHistory();
-    resetHookState();
-    if (s.basePath)
-        clearPersistedHookState(s.basePath);
-    // Remove paused-session metadata if present (#1383)
-    try {
-        const pausedPath = join(gsdRoot(s.originalBasePath || s.basePath), "runtime", "paused-session.json");
-        if (existsSync(pausedPath))
-            unlinkSync(pausedPath);
-    }
-    catch { /* non-fatal */ }
-    s.active = false;
-    s.paused = false;
-    s.stepMode = false;
-    s.unitDispatchCount.clear();
-    s.unitRecoveryCount.clear();
-    clearInFlightTools();
-    s.lastBudgetAlertLevel = 0;
-    s.lastStateRebuildAt = 0;
-    s.unitLifetimeDispatches.clear();
-    s.currentUnit = null;
-    s.autoModeStartModel = null;
-    s.currentMilestoneId = null;
-    s.originalBasePath = "";
-    s.completedUnits = [];
-    s.pendingQuickTasks = [];
-    clearSliceProgressCache();
-    clearActivityLogState();
-    resetProactiveHealing();
-    s.pendingCrashRecovery = null;
-    s.pendingVerificationRetry = null;
-    s.verificationRetryCount.clear();
-    s.pausedSessionFile = null;
-    ctx?.ui.setStatus("gsd-auto", undefined);
-    ctx?.ui.setWidget("gsd-progress", undefined);
-    ctx?.ui.setFooter(undefined);
-    if (pi && ctx && s.originalModelId && s.originalModelProvider) {
-        const original = ctx.modelRegistry.find(s.originalModelProvider, s.originalModelId);
-        if (original)
-            await pi.setModel(original);
-        s.originalModelId = null;
-        s.originalModelProvider = null;
+    finally {
+        // ── Critical invariants: these MUST execute regardless of errors ──
+        // External cleanup (not covered by session reset)
+        clearInFlightTools();
+        clearSliceProgressCache();
+        clearActivityLogState();
+        resetProactiveHealing();
+        // UI cleanup
+        ctx?.ui.setStatus("gsd-auto", undefined);
+        ctx?.ui.setWidget("gsd-progress", undefined);
+        ctx?.ui.setFooter(undefined);
+        // Reset all session state in one call
+        s.reset();
     }
-    s.cmdCtx = null;
 }
 /**
  * Pause auto-mode without destroying state. Context is preserved.

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

@@ -30,8 +30,16 @@ const VALID_CLASSIFICATIONS = [
  */
 export function resolveCapturesPath(basePath) {
     const resolved = resolve(basePath);
+    // Direct layout: /.gsd/worktrees/
     const worktreeMarker = `${sep}.gsd${sep}worktrees${sep}`;
-    const idx = resolved.indexOf(worktreeMarker);
+    let idx = resolved.indexOf(worktreeMarker);
+    if (idx === -1) {
+        // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/
+        const symlinkRe = new RegExp(`\\${sep}\\.gsd\\${sep}projects\\${sep}[a-f0-9]+\\${sep}worktrees\\${sep}`);
+        const match = resolved.match(symlinkRe);
+        if (match && match.index !== undefined)
+            idx = match.index;
+    }
     if (idx !== -1) {
         // basePath is inside a worktree — resolve to project root
         const projectRoot = resolved.slice(0, idx);

package/dist/resources/extensions/gsd/commands-extensions.js

@@ -8,12 +8,13 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 // ─── Registry I/O ───────────────────────────────────────────────────────────
 function getRegistryPath() {
-    return join(homedir(), ".gsd", "extensions", "registry.json");
+    return join(gsdHome, "extensions", "registry.json");
 }
 function getAgentExtensionsDir() {
-    return join(homedir(), ".gsd", "agent", "extensions");
+    return join(gsdHome, "agent", "extensions");
 }
 function loadRegistry() {
     const filePath = getRegistryPath();

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -10,7 +10,7 @@ import { deriveState } from "./state.js";
 import { gsdRoot } from "./paths.js";
 import { appendCapture, hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { appendOverride, appendKnowledge } from "./files.js";
-import { formatDoctorIssuesForPrompt, formatDoctorReport, runGSDDoctor, selectDoctorScope, filterDoctorIssues, } from "./doctor.js";
+import { formatDoctorIssuesForPrompt, formatDoctorReport, formatDoctorReportJson, runGSDDoctor, selectDoctorScope, filterDoctorIssues, } from "./doctor.js";
 import { isAutoActive } from "./auto.js";
 import { projectRoot } from "./commands.js";
 import { loadPrompt } from "./prompt-loader.js";
@@ -28,15 +28,28 @@ export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
 }
 export async function handleDoctor(args, ctx, pi) {
     const trimmed = args.trim();
-    const parts = trimmed ? trimmed.split(/\s+/) : [];
+    // Extract flags before positional parsing
+    const jsonMode = trimmed.includes("--json");
+    const dryRun = trimmed.includes("--dry-run");
+    const includeBuild = trimmed.includes("--build");
+    const includeTests = trimmed.includes("--test");
+    const stripped = trimmed.replace(/--json|--dry-run|--build|--test/g, "").trim();
+    const parts = stripped ? stripped.split(/\s+/) : [];
     const mode = parts[0] === "fix" || parts[0] === "heal" || parts[0] === "audit" ? parts[0] : "doctor";
     const requestedScope = mode === "doctor" ? parts[0] : parts[1];
     const scope = await selectDoctorScope(projectRoot(), requestedScope);
     const effectiveScope = mode === "audit" ? requestedScope : scope;
     const report = await runGSDDoctor(projectRoot(), {
-        fix: mode === "fix" || mode === "heal",
+        fix: mode === "fix" || mode === "heal" || dryRun,
+        dryRun,
         scope: effectiveScope,
+        includeBuild,
+        includeTests,
     });
+    if (jsonMode) {
+        ctx.ui.notify(formatDoctorReportJson(report), "info");
+        return;
+    }
     const reportText = formatDoctorReport(report, {
         scope: effectiveScope,
         includeWarnings: mode === "audit",

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -631,7 +631,7 @@ export function serializePreferencesToFrontmatter(prefs) {
         "dynamic_routing", "token_profile", "phases", "parallel",
         "auto_visualize", "auto_report",
         "verification_commands", "verification_auto_fix", "verification_max_retries",
-        "search_provider", "compression_strategy", "context_selection",
+        "search_provider", "context_selection",
     ];
     const seen = new Set();
     for (const key of orderedKeys) {

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

@@ -7,6 +7,7 @@ import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 import { enableDebug } from "./debug-logger.js";
 import { deriveState } from "./state.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
@@ -135,7 +136,7 @@ async function guardRemoteSession(ctx, pi) {
 }
 export function registerGSDCommand(pi) {
     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|cmux|update",
+        description: "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|capture|triage|dispatch|history|undo|rate|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update",
         getArgumentCompletions: (prefix) => {
             const subcommands = [
                 { cmd: "help", desc: "Categorized command reference with descriptions" },
@@ -186,7 +187,11 @@ export function registerGSDCommand(pi) {
                 { cmd: "templates", desc: "List available workflow templates" },
                 { cmd: "extensions", desc: "Manage extensions (list, enable, disable, info)" },
             ];
+            const hasTrailingSpace = prefix.endsWith(" ");
             const parts = prefix.trim().split(/\s+/);
+            if (hasTrailingSpace && parts.length >= 1) {
+                parts.push("");
+            }
             if (parts.length <= 1) {
                 return subcommands
                     .filter((item) => item.cmd.startsWith(parts[0] ?? ""))
@@ -433,7 +438,7 @@ export function registerGSDCommand(pi) {
                 if (parts.length === 3 && ["enable", "disable", "info"].includes(parts[1])) {
                     const idPrefix = parts[2] ?? "";
                     try {
-                        const extDir = join(homedir(), ".gsd", "agent", "extensions");
+                        const extDir = join(gsdHome, "agent", "extensions");
                         const ids = [];
                         for (const entry of readdirSync(extDir, { withFileTypes: true })) {
                             if (!entry.isDirectory())
@@ -468,6 +473,10 @@ export function registerGSDCommand(pi) {
                     { cmd: "fix", desc: "Auto-fix detected issues" },
                     { cmd: "heal", desc: "AI-driven deep healing" },
                     { cmd: "audit", desc: "Run health audit without fixing" },
+                    { cmd: "--dry-run", desc: "Show what --fix would change without applying" },
+                    { cmd: "--json", desc: "Output report as JSON (CI/tooling friendly)" },
+                    { cmd: "--build", desc: "Include slow build health check (npm run build)" },
+                    { cmd: "--test", desc: "Include slow test health check (npm test)" },
                 ];
                 if (parts.length <= 2) {
                     return modes
@@ -491,6 +500,17 @@ export function registerGSDCommand(pi) {
                     .filter((p) => p.cmd.startsWith(phasePrefix))
                     .map((p) => ({ value: `dispatch ${p.cmd}`, label: p.cmd, description: p.desc }));
             }
+            if (parts[0] === "rate" && parts.length <= 2) {
+                const tierPrefix = parts[1] ?? "";
+                const tiers = [
+                    { cmd: "over", desc: "Model was overqualified for this task" },
+                    { cmd: "ok", desc: "Model was appropriate for this task" },
+                    { cmd: "under", desc: "Model was underqualified for this task" },
+                ];
+                return tiers
+                    .filter((t) => t.cmd.startsWith(tierPrefix))
+                    .map((t) => ({ value: `rate ${t.cmd}`, label: t.cmd, description: t.desc }));
+            }
             return [];
         },
         async handler(args, ctx) {

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