gsd-pi 2.37.1 → 2.38.0-dev.29edcdc

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

@@ -12,6 +12,7 @@
  */
 import { existsSync } from "node:fs";
 import { AuthStorage } from "@gsd/pi-coding-agent";
+import { getEnvApiKey } from "@gsd/pi-ai";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { getAuthPath, PROVIDER_REGISTRY } from "./key-manager.js";
 // ── Model → Provider ID mapping ───────────────────────────────────────────────
@@ -27,12 +28,15 @@ 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",
         };
         if (prefixMap[prefix])
             return prefixMap[prefix];
@@ -65,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);
@@ -108,31 +120,69 @@ function resolveKey(providerId) {
             // auth.json malformed — fall through to env check
         }
     }
-    // Check environment variable
+    // Check environment variable using the authoritative env var resolution
+    // (handles multi-var lookups like ANTHROPIC_OAUTH_TOKEN || ANTHROPIC_API_KEY,
+    //  COPILOT_GITHUB_TOKEN || GH_TOKEN || GITHUB_TOKEN, Vertex ADC, Bedrock, etc.)
+    if (getEnvApiKey(providerId)) {
+        return { found: true, source: "env", backedOff: false };
+    }
+    // Fall back to PROVIDER_REGISTRY env var for providers not covered by getEnvApiKey
+    // (e.g., search providers like Brave, Tavily; tool providers like Jina, Context7)
     if (info?.envVar && process.env[info.envVar]) {
         return { found: true, source: "env", backedOff: false };
     }
     return { found: false, source: "none", backedOff: false };
 }
 // ── Individual check groups ────────────────────────────────────────────────────
+/**
+ * Providers that can serve models normally associated with another provider.
+ * Key = the provider whose models can be served, Value = alternative providers to check.
+ * e.g. GitHub Copilot subscriptions can access Claude and GPT models.
+ */
+const PROVIDER_ROUTES = {
+    anthropic: ["github-copilot"],
+    openai: ["github-copilot"],
+};
 function checkLlmProviders() {
     const required = collectConfiguredModelProviders();
     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) {
-            const envVar = info?.envVar ?? `${providerId.toUpperCase()}_API_KEY`;
+            // Check if a cross-provider can serve this provider's models
+            const routes = PROVIDER_ROUTES[providerId];
+            const routeProvider = routes?.find(routeId => resolveKey(routeId).found);
+            if (routeProvider) {
+                const routeInfo = PROVIDER_REGISTRY.find(p => p.id === routeProvider);
+                const routeLabel = routeInfo?.label ?? routeProvider;
+                results.push({
+                    name: providerId,
+                    label,
+                    category: "llm",
+                    status: "ok",
+                    message: `${label} — available via ${routeLabel}`,
+                    required: true,
+                });
+                continue;
+            }
+            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,
             });
         }

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

@@ -1,7 +1,7 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, lstatSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadFile, parsePlan, parseRoadmap, parseSummary, saveFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
-import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, milestonesDir, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile } from "./paths.js";
+import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, milestonesDir, gsdRoot, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile, relMilestonePath } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -9,7 +9,7 @@ import { COMPLETION_TRANSITION_CODES } from "./doctor-types.js";
 import { checkGitHealth, checkRuntimeHealth } from "./doctor-checks.js";
 import { checkEnvironmentHealth } from "./doctor-environment.js";
 import { runProviderChecks } from "./doctor-providers.js";
-export { summarizeDoctorIssues, filterDoctorIssues, formatDoctorReport, formatDoctorIssuesForPrompt } from "./doctor-format.js";
+export { summarizeDoctorIssues, filterDoctorIssues, formatDoctorReport, formatDoctorIssuesForPrompt, formatDoctorReportJson } from "./doctor-format.js";
 export { runEnvironmentChecks, runFullEnvironmentChecks, formatEnvironmentReport } from "./doctor-environment.js";
 export { computeProgressScore, computeProgressScoreWithContext, formatProgressLine, formatProgressReport } from "./progress-score.js";
 /**
@@ -257,10 +257,23 @@ async function markSliceDoneInRoadmap(basePath, milestoneId, sliceId, fixesAppli
         fixesApplied.push(`marked ${sliceId} done in ${roadmapPath}`);
     }
 }
+async function markSliceUndoneInRoadmap(basePath, milestoneId, sliceId, fixesApplied) {
+    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    if (!roadmapPath)
+        return;
+    const content = await loadFile(roadmapPath);
+    if (!content)
+        return;
+    const updated = content.replace(new RegExp(`^(\\s*-\\s+)\\[x\\]\\s+\\*\\*${sliceId}:`, "m"), `$1[ ] **${sliceId}:`);
+    if (updated !== content) {
+        await saveFile(roadmapPath, updated);
+        fixesApplied.push(`unmarked ${sliceId} in ${roadmapPath} (premature completion)`);
+    }
+}
 function matchesScope(unitId, scope) {
     if (!scope)
         return true;
-    return unitId === scope || unitId.startsWith(`${scope}/`) || unitId.startsWith(`${scope}`);
+    return unitId === scope || unitId.startsWith(`${scope}/`);
 }
 function auditRequirements(content) {
     if (!content)
@@ -324,10 +337,68 @@ export async function selectDoctorScope(basePath, requestedScope) {
     }
     return state.registry[0]?.id;
 }
+// ── Helper: circular dependency detection ──────────────────────────────────
+function detectCircularDependencies(slices) {
+    const known = new Set(slices.map(s => s.id));
+    const adj = new Map();
+    for (const s of slices)
+        adj.set(s.id, s.depends.filter(d => known.has(d)));
+    const state = new Map();
+    for (const s of slices)
+        state.set(s.id, "unvisited");
+    const cycles = [];
+    function dfs(id, path) {
+        const st = state.get(id);
+        if (st === "done")
+            return;
+        if (st === "visiting") {
+            cycles.push([...path.slice(path.indexOf(id)), id]);
+            return;
+        }
+        state.set(id, "visiting");
+        for (const dep of adj.get(id) ?? [])
+            dfs(dep, [...path, id]);
+        state.set(id, "done");
+    }
+    for (const s of slices)
+        if (state.get(s.id) === "unvisited")
+            dfs(s.id, []);
+    return cycles;
+}
+async function appendDoctorHistory(basePath, report) {
+    try {
+        const historyPath = join(gsdRoot(basePath), "doctor-history.jsonl");
+        const entry = JSON.stringify({
+            ts: new Date().toISOString(),
+            ok: report.ok,
+            errors: report.issues.filter(i => i.severity === "error").length,
+            warnings: report.issues.filter(i => i.severity === "warning").length,
+            fixes: report.fixesApplied.length,
+            codes: [...new Set(report.issues.map(i => i.code))],
+        });
+        const existing = existsSync(historyPath) ? readFileSync(historyPath, "utf-8") : "";
+        await saveFile(historyPath, existing + entry + "\n");
+    }
+    catch { /* non-fatal */ }
+}
+/** Read the last N doctor history entries. Returns most-recent-first. */
+export async function readDoctorHistory(basePath, lastN = 50) {
+    try {
+        const historyPath = join(gsdRoot(basePath), "doctor-history.jsonl");
+        if (!existsSync(historyPath))
+            return [];
+        const lines = readFileSync(historyPath, "utf-8").split("\n").filter(l => l.trim());
+        return lines.slice(-lastN).reverse().map(l => JSON.parse(l));
+    }
+    catch {
+        return [];
+    }
+}
 export async function runGSDDoctor(basePath, options) {
     const issues = [];
     const fixesApplied = [];
     const fix = options?.fix === true;
+    const dryRun = options?.dryRun === true;
     const fixLevel = options?.fixLevel ?? "all";
     // Issue codes that represent completion state transitions — creating summary
     // stubs, marking slices/milestones done in the roadmap. These belong to the
@@ -336,12 +407,18 @@ export async function runGSDDoctor(basePath, options) {
     // detected and reported but never auto-fixed.
     /** Whether a given issue code should be auto-fixed at the current fixLevel. */
     const shouldFix = (code) => {
-        if (!fix)
+        if (!fix || dryRun)
             return false;
         if (fixLevel === "task" && COMPLETION_TRANSITION_CODES.has(code))
             return false;
         return true;
     };
+    /** Log a dry-run "would fix" entry when fix=true but dryRun=true. */
+    const dryRunCanFix = (code, message) => {
+        if (dryRun && fix && !(fixLevel === "task" && COMPLETION_TRANSITION_CODES.has(code))) {
+            fixesApplied.push(`[dry-run] would fix: ${message}`);
+        }
+    };
     const prefs = loadEffectiveGSDPreferences();
     if (prefs) {
         const prefIssues = validatePreferenceShape(prefs.preferences);
@@ -357,18 +434,30 @@ export async function runGSDDoctor(basePath, options) {
             });
         }
     }
-    // Git health checks (orphaned worktrees, stale branches, corrupt merge state, tracked runtime files)
+    // Git health checks — timed
+    const t0git = Date.now();
     const isolationMode = options?.isolationMode ??
         (prefs?.preferences?.git?.isolation === "none" ? "none" :
             prefs?.preferences?.git?.isolation === "branch" ? "branch" : "worktree");
     await checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode);
-    // Runtime health checks (crash locks, completed-units, hook state, activity logs, STATE.md, gitignore)
+    const gitMs = Date.now() - t0git;
+    // Runtime health checks — timed
+    const t0runtime = Date.now();
     await checkRuntimeHealth(basePath, issues, fixesApplied, shouldFix);
-    // Environment health checks (#1221: missing tools, port conflicts, stale deps, disk space)
-    await checkEnvironmentHealth(basePath, issues, { includeRemote: !options?.scope });
+    const runtimeMs = Date.now() - t0runtime;
+    // Environment health checks — timed
+    const t0env = Date.now();
+    await checkEnvironmentHealth(basePath, issues, {
+        includeRemote: !options?.scope,
+        includeBuild: options?.includeBuild,
+        includeTests: options?.includeTests,
+    });
+    const envMs = Date.now() - t0env;
     const milestonesPath = milestonesDir(basePath);
     if (!existsSync(milestonesPath)) {
-        return { ok: issues.every(issue => issue.severity !== "error"), basePath, issues, fixesApplied };
+        const report = { ok: issues.every(i => i.severity !== "error"), basePath, issues, fixesApplied, timing: { git: gitMs, runtime: runtimeMs, environment: envMs, gsdState: 0 } };
+        await appendDoctorHistory(basePath, report);
+        return report;
     }
     const requirementsPath = resolveGsdRootFile(basePath, "REQUIREMENTS");
     const requirementsContent = await loadFile(requirementsPath);
@@ -432,6 +521,46 @@ export async function runGSDDoctor(basePath, options) {
         if (!roadmapContent)
             continue;
         const roadmap = parseRoadmap(roadmapContent);
+        // ── Circular dependency detection ──────────────────────────────────────
+        for (const cycle of detectCircularDependencies(roadmap.slices)) {
+            issues.push({
+                severity: "error",
+                code: "circular_slice_dependency",
+                scope: "milestone",
+                unitId: milestoneId,
+                message: `Circular dependency detected: ${cycle.join(" → ")}`,
+                file: relMilestoneFile(basePath, milestoneId, "ROADMAP"),
+                fixable: false,
+            });
+        }
+        // ── Orphaned slice directories ─────────────────────────────────────────
+        try {
+            const slicesDir = join(milestonePath, "slices");
+            if (existsSync(slicesDir)) {
+                const knownSliceIds = new Set(roadmap.slices.map(s => s.id));
+                for (const entry of readdirSync(slicesDir)) {
+                    try {
+                        if (!lstatSync(join(slicesDir, entry)).isDirectory())
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!knownSliceIds.has(entry)) {
+                        issues.push({
+                            severity: "warning",
+                            code: "orphaned_slice_directory",
+                            scope: "milestone",
+                            unitId: milestoneId,
+                            message: `Directory "${entry}" exists in ${milestoneId}/slices/ but is not referenced in the roadmap`,
+                            file: `${relMilestonePath(basePath, milestoneId)}/slices/${entry}`,
+                            fixable: false,
+                        });
+                    }
+                }
+            }
+        }
+        catch { /* non-fatal */ }
         for (const slice of roadmap.slices) {
             const unitId = `${milestoneId}/${slice.id}`;
             if (options?.scope && !matchesScope(unitId, options.scope) && options.scope !== milestoneId)
@@ -502,6 +631,34 @@ export async function runGSDDoctor(basePath, options) {
                 }
                 continue;
             }
+            // ── Duplicate task IDs ───────────────────────────────────────────────
+            const taskIdCounts = new Map();
+            for (const task of plan.tasks)
+                taskIdCounts.set(task.id, (taskIdCounts.get(task.id) ?? 0) + 1);
+            for (const [taskId, count] of taskIdCounts) {
+                if (count > 1) {
+                    issues.push({ severity: "error", code: "duplicate_task_id", scope: "slice", unitId,
+                        message: `Task ID "${taskId}" appears ${count} times in ${slice.id}-PLAN.md — duplicate IDs cause dispatch failures`,
+                        file: relSliceFile(basePath, milestoneId, slice.id, "PLAN"), fixable: false });
+                }
+            }
+            // ── Task files on disk not in plan ────────────────────────────────────
+            try {
+                if (tasksDir) {
+                    const planTaskIds = new Set(plan.tasks.map(t => t.id));
+                    for (const f of readdirSync(tasksDir)) {
+                        if (!f.endsWith("-SUMMARY.md"))
+                            continue;
+                        const diskTaskId = f.replace(/-SUMMARY\.md$/, "");
+                        if (!planTaskIds.has(diskTaskId)) {
+                            issues.push({ severity: "info", code: "task_file_not_in_plan", scope: "slice", unitId,
+                                message: `Task summary "${f}" exists on disk but "${diskTaskId}" is not in ${slice.id}-PLAN.md`,
+                                file: relTaskFile(basePath, milestoneId, slice.id, diskTaskId, "SUMMARY"), fixable: false });
+                        }
+                    }
+                }
+            }
+            catch { /* non-fatal */ }
             let allTasksDone = plan.tasks.length > 0;
             for (const task of plan.tasks) {
                 const taskUnitId = `${unitId}/${task.id}`;
@@ -517,6 +674,7 @@ export async function runGSDDoctor(basePath, options) {
                         file: relTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY"),
                         fixable: true,
                     });
+                    dryRunCanFix("task_done_missing_summary", `create stub summary for ${taskUnitId}`);
                     if (shouldFix("task_done_missing_summary")) {
                         const stubPath = join(basePath, ".gsd", "milestones", milestoneId, "slices", slice.id, "tasks", `${task.id}-SUMMARY.md`);
                         const stubContent = [
@@ -575,6 +733,22 @@ export async function runGSDDoctor(basePath, options) {
                         }
                     }
                 }
+                // ── Future timestamp check ─────────────────────────────────────
+                if (task.done && hasSummary && summaryPath) {
+                    try {
+                        const rawSummary = await loadFile(summaryPath);
+                        const m = rawSummary?.match(/^completed_at:\s*(.+)$/m);
+                        if (m) {
+                            const ts = new Date(m[1].trim());
+                            if (!isNaN(ts.getTime()) && ts.getTime() > Date.now() + 24 * 60 * 60 * 1000) {
+                                issues.push({ severity: "warning", code: "future_timestamp", scope: "task", unitId: taskUnitId,
+                                    message: `Task ${task.id} has completed_at "${m[1].trim()}" which is more than 24h in the future`,
+                                    file: relTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY"), fixable: false });
+                            }
+                        }
+                    }
+                    catch { /* non-fatal */ }
+                }
                 allTasksDone = allTasksDone && task.done;
             }
             // Blocker-without-replan detection
@@ -604,6 +778,12 @@ export async function runGSDDoctor(basePath, options) {
                     }
                 }
             }
+            // ── Stale REPLAN: exists but all tasks done ────────────────────────
+            if (replanPath && allTasksDone) {
+                issues.push({ severity: "info", code: "stale_replan_file", scope: "slice", unitId,
+                    message: `${slice.id} has a REPLAN.md but all tasks are done — REPLAN.md may be stale`,
+                    file: relSliceFile(basePath, milestoneId, slice.id, "REPLAN"), fixable: false });
+            }
             const sliceSummaryPath = resolveSliceFile(basePath, milestoneId, slice.id, "SUMMARY");
             const sliceUatPath = join(slicePath, `${slice.id}-UAT.md`);
             const hasSliceSummary = !!(sliceSummaryPath && await loadFile(sliceSummaryPath));
@@ -618,6 +798,7 @@ export async function runGSDDoctor(basePath, options) {
                     file: relSliceFile(basePath, milestoneId, slice.id, "SUMMARY"),
                     fixable: true,
                 });
+                dryRunCanFix("all_tasks_done_missing_slice_summary", `create placeholder summary for ${unitId}`);
                 if (shouldFix("all_tasks_done_missing_slice_summary"))
                     await ensureSliceSummaryStub(basePath, milestoneId, slice.id, fixesApplied);
             }
@@ -631,6 +812,7 @@ export async function runGSDDoctor(basePath, options) {
                     file: `${relSlicePath(basePath, milestoneId, slice.id)}/${slice.id}-UAT.md`,
                     fixable: true,
                 });
+                dryRunCanFix("all_tasks_done_missing_slice_uat", `create placeholder UAT for ${unitId}`);
                 if (shouldFix("all_tasks_done_missing_slice_uat"))
                     await ensureSliceUatStub(basePath, milestoneId, slice.id, fixesApplied);
             }
@@ -644,6 +826,7 @@ export async function runGSDDoctor(basePath, options) {
                     file: relMilestoneFile(basePath, milestoneId, "ROADMAP"),
                     fixable: true,
                 });
+                dryRunCanFix("all_tasks_done_roadmap_not_checked", `mark ${slice.id} done in roadmap`);
                 if (shouldFix("all_tasks_done_roadmap_not_checked") && (hasSliceSummary || issues.some(issue => issue.code === "all_tasks_done_missing_slice_summary" && issue.unitId === unitId))) {
                     await markSliceDoneInRoadmap(basePath, milestoneId, slice.id, fixesApplied);
                 }
@@ -658,6 +841,12 @@ export async function runGSDDoctor(basePath, options) {
                     file: relSliceFile(basePath, milestoneId, slice.id, "SUMMARY"),
                     fixable: true,
                 });
+                if (!allTasksDone) {
+                    dryRunCanFix("slice_checked_missing_summary", `uncheck ${slice.id} in roadmap (tasks incomplete)`);
+                    if (shouldFix("slice_checked_missing_summary")) {
+                        await markSliceUndoneInRoadmap(basePath, milestoneId, slice.id, fixesApplied);
+                    }
+                }
             }
             if (slice.done && !hasSliceUat) {
                 issues.push({
@@ -696,13 +885,16 @@ export async function runGSDDoctor(basePath, options) {
             });
         }
     }
-    if (fix && fixesApplied.length > 0) {
+    if (fix && !dryRun && fixesApplied.length > 0) {
         await updateStateFile(basePath, fixesApplied);
     }
-    return {
+    const report = {
         ok: issues.every(issue => issue.severity !== "error"),
         basePath,
         issues,
         fixesApplied,
+        timing: { git: gitMs, runtime: runtimeMs, environment: envMs, gsdState: Math.max(0, Date.now() - t0env - envMs) },
     };
+    await appendDoctorHistory(basePath, report);
+    return report;
 }

package/dist/resources/extensions/gsd/exit-command.js

@@ -1,9 +1,10 @@
+import { importExtensionModule } from "@gsd/pi-coding-agent";
 export function registerExitCommand(pi, deps = {}) {
     pi.registerCommand("exit", {
         description: "Exit GSD gracefully",
         handler: async (_args, ctx) => {
             // Stop auto-mode first so locks and activity state are cleaned up before shutdown.
-            const stopAuto = deps.stopAuto ?? (await import("./auto.js")).stopAuto;
+            const stopAuto = deps.stopAuto ?? (await importExtensionModule(import.meta.url, "./auto.js")).stopAuto;
             await stopAuto(ctx, pi, "Graceful exit");
             ctx.shutdown();
         },

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

@@ -5,7 +5,7 @@ import { join, basename } from "node:path";
 import { exec } from "node:child_process";
 import { getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk, } from "./metrics.js";
 import { gsdRoot } from "./paths.js";
-import { formatDuration, fileLink } from "../shared/mod.js";
+import { formatDuration, fileLink } from "../shared/format-utils.js";
 import { getErrorMessage } from "./error-utils.js";
 /**
  * Open a file in the user's default browser.