gsd-pi 2.39.0 → 2.40.0-dev.4a93031

package/src/resources/extensions/gsd/progress-score.ts

@@ -14,6 +14,8 @@ import {
   getHealthTrend,
   getConsecutiveErrorUnits,
   getHealthHistory,
+  getLatestHealthIssues,
+  getLatestHealthFixes,
   type HealthSnapshot,
 } from "./doctor-proactive.js";
 
@@ -77,6 +79,27 @@ export function computeProgressScore(): ProgressScore {
     signals.push({ kind: "neutral", label: "No health data yet" });
   }
 
+  // Surface actual doctor issue details when degraded
+  if (level !== "green") {
+    const latestIssues = getLatestHealthIssues();
+    // Show up to 5 most relevant issues (errors first, then warnings)
+    const sorted = [...latestIssues].sort((a, b) => {
+      const rank = { error: 0, warning: 1, info: 2 };
+      return rank[a.severity] - rank[b.severity];
+    });
+    for (const issue of sorted.slice(0, 5)) {
+      signals.push({
+        kind: issue.severity === "error" ? "negative" : "neutral",
+        label: issue.message,
+      });
+    }
+
+    const latestFixes = getLatestHealthFixes();
+    for (const fix of latestFixes.slice(0, 3)) {
+      signals.push({ kind: "positive", label: `Fixed: ${fix}` });
+    }
+  }
+
   const summary = level === "green"
     ? "Progressing well"
     : level === "yellow"

package/src/resources/extensions/gsd/prompts/forensics.md

@@ -1,4 +1,4 @@
-You are investigating a GSD auto-mode failure. The user has described their problem and a structured forensic report has been gathered automatically.
+You are debugging GSD itself. The user is donating their tokens to help find bugs in GSD's source code. Your job is to trace from symptom to root cause in the actual source and produce a filing-ready GitHub issue with specific file:line references and a concrete fix suggestion.
 
 ## User's Problem
 
@@ -10,62 +10,137 @@ You are investigating a GSD auto-mode failure. The user has described their prob
 
 ## GSD Source Location
 
-GSD extension source code is at: {{gsdSourceDir}}
-Key files for understanding failures:
-- auto.ts — unit dispatch loop, stuck detection, timeout recovery
-- session-forensics.ts — trace extraction from activity logs
-- auto-recovery.ts — artifact verification, skip logic
-- crash-recovery.ts — crash lock lifecycle
-- doctor.ts — state integrity checks
+GSD extension source code is at: `{{gsdSourceDir}}`
 
-You may read these files to identify the specific code path that caused the failure.
+### Source Map by Domain
 
-## Your Task
+| Domain | Files |
+|--------|-------|
+| **Auto-mode engine** | `auto.ts` `auto-loop.ts` `auto-dispatch.ts` `auto-start.ts` `auto-supervisor.ts` `auto-timers.ts` `auto-timeout-recovery.ts` `auto-unit-closeout.ts` `auto-post-unit.ts` `auto-verification.ts` `auto-recovery.ts` `auto-worktree.ts` `auto-worktree-sync.ts` `auto-model-selection.ts` `auto-budget.ts` `dispatch-guard.ts` |
+| **State & persistence** | `state.ts` `types.ts` `files.ts` `paths.ts` `json-persistence.ts` `atomic-write.ts` |
+| **Forensics & recovery** | `forensics.ts` `session-forensics.ts` `crash-recovery.ts` `session-lock.ts` |
+| **Metrics & telemetry** | `metrics.ts` `skill-telemetry.ts` `token-counter.ts` |
+| **Health & diagnostics** | `doctor.ts` `doctor-types.ts` `doctor-checks.ts` `doctor-format.ts` `doctor-environment.ts` |
+| **Prompts & context** | `prompt-loader.ts` `prompt-cache-optimizer.ts` `context-budget.ts` |
+| **Git & worktrees** | `git-service.ts` `worktree.ts` `worktree-manager.ts` `git-self-heal.ts` |
+| **Commands** | `commands.ts` `commands-inspect.ts` `commands-maintenance.ts` |
 
-1. **Analyze** the forensic report. Identify the root cause of the user's problem.
+### Runtime Path Reference
 
-2. **Clarify** if needed. Use ask_user_questions (max 2 questions) to narrow down ambiguity. Only ask if the report is genuinely insufficient — do not ask questions you can answer from the data.
+```
+.gsd/
+├── PROJECT.md, DECISIONS.md, QUEUE.md, STATE.md, REQUIREMENTS.md, OVERRIDES.md, KNOWLEDGE.md, RUNTIME.md
+├── auto.lock                    — crash lock (JSON: pid, unitType, unitId, sessionFile)
+├── metrics.json                 — token/cost ledger (units array with cost, tokens, duration)
+├── completed-units.json         — array of "type/id" strings
+├── doctor-history.jsonl         — doctor check history
+├── activity/                    — session activity logs (JSONL per unit)
+│   └── {seq}-{unitType}-{unitId}.jsonl
+├── runtime/
+│   ├── paused-session.json      — serialized session when auto pauses
+│   └── headless-context.md      — headless resume context
+├── debug/                       — debug logs
+├── forensics/                   — saved forensic reports
+├── milestones/{ID}/             — milestone artifacts
+│   ├── {ID}-ROADMAP.md, {ID}-RESEARCH.md, {ID}-CONTEXT.md, {ID}-SUMMARY.md
+│   └── slices/{SID}/            — slice artifacts
+│       ├── {SID}-PLAN.md, {SID}-RESEARCH.md, {SID}-UAT-RESULT.md, {SID}-SUMMARY.md
+│       └── tasks/{TID}-PLAN.md, {TID}-SUMMARY.md
+└── worktrees/{milestoneId}/     — per-milestone worktree with replicated .gsd/
+```
 
-3. **Explain** your findings clearly:
-   - What happened (the failure sequence)
-   - Why it happened (root cause in GSD's logic)
-   - What the user can do to recover (immediate fix)
+### Activity Log Format
 
-4. **Offer GitHub issue creation.** Ask the user:
-   "Would you like me to create a GitHub issue for this on gsd-build/gsd-2?"
+- **Filename**: `{3-digit-seq}-{unitType}-{unitId}.jsonl`
+- Each line is a JSON object with `type: "message"` and a `message` field
+- `message.role: "assistant"` — contains `content[]` array:
+  - `type: "text"` entries hold the agent's reasoning
+  - `type: "toolCall"` entries hold tool invocations (`name`, `id`, `arguments`)
+- `message.role: "toolResult"` — contains `toolCallId`, `toolName`, `isError`, `content`
+- `usage` field on assistant messages: `input`, `output`, `cacheRead`, `cacheWrite`, `totalTokens`, `cost`
+- **To trace a failure**: find the last activity log, search for `isError: true` tool results, then read the agent's reasoning text preceding that error
 
-   If yes, create the issue using bash with `gh issue create`:
-   - Repository: gsd-build/gsd-2
-   - Labels: bug, auto-generated
-   - Title: concise description of the failure
-   - Body format:
-     ```
-     ## Problem
-     [1-2 sentence summary]
+### Crash Lock Format (`auto.lock`)
 
-     ## Environment
-     - GSD version: [from report]
-     - Model: [from report]
-     - Unit: [type/id that failed]
+JSON with fields: `pid`, `startedAt`, `unitType`, `unitId`, `unitStartedAt`, `completedUnits`, `sessionFile`
 
-     ## Reproduction Context
-     [What was happening when it failed — phase, milestone, slice]
+A stale lock (PID is dead) means the previous auto-mode session crashed mid-unit.
 
-     ## Forensic Findings
-     [Key anomalies detected, error traces, relevant tool call sequences]
+### Metrics Ledger Format (`metrics.json`)
 
-     ## Suggested Fix Area
-     [File:line references in GSD source if identified]
+```
+{ version: 1, projectStartedAt: <ms>, units: [{ type, id, model, startedAt, finishedAt, tokens: { input, output, cacheRead, cacheWrite, total }, cost, toolCalls, assistantMessages, ... }] }
+```
 
-     ---
-     *Auto-generated by `/gsd forensics`*
-     ```
+A unit dispatched more than once (`type/id` appears multiple times) indicates a stuck loop — the unit completed but artifact verification failed.
 
-   **CRITICAL REDACTION RULES** before creating the issue:
-   - Replace all absolute paths with relative paths
-   - Remove any API keys, tokens, or credentials
-   - Remove any environment variable values
-   - Do not include file content (code written by the user)
-   - Only include GSD structural information (tool names, file names, error messages)
+## Investigation Protocol
 
-5. **Report saved.** Remind the user that the full forensic report was saved locally (the path will be in the notification).
+1. **Start with the pre-parsed forensic report** above. The anomaly section contains automated findings — treat these as leads, not conclusions.
+
+2. **Form hypotheses** about which module and code path is responsible. Use the source map to identify candidate files.
+
+3. **Read the actual GSD source code** at `{{gsdSourceDir}}` to confirm or deny each hypothesis. Do not guess what code does — read it.
+
+4. **Trace the code path** from the entry point (usually `auto-loop.ts` dispatch or `auto-dispatch.ts`) through to the failure point. Follow function calls across files.
+
+5. **Identify the specific file and line** where the bug lives. Determine what kind of defect it is:
+   - Missing edge case / unhandled condition
+   - Wrong boolean logic or comparison
+   - Race condition or ordering issue
+   - State corruption (e.g. completed-units.json out of sync with artifacts)
+   - Timeout / recovery logic not triggering correctly
+
+6. **Clarify if needed.** Use ask_user_questions (max 2 questions) only if the report is genuinely insufficient. Do not ask questions you can answer from the data or source code.
+
+## Output
+
+Explain your findings:
+- **What happened** — the failure sequence reconstructed from activity logs and anomalies
+- **Why it happened** — root cause traced to specific code in GSD source, with `file:line` references
+- **Code snippet** — the problematic code and what it should do instead
+- **Recovery** — what the user can do right now to get unstuck
+
+Then **offer GitHub issue creation**: "Would you like me to create a GitHub issue for this on gsd-build/gsd-2?"
+
+If yes, create using `gh issue create` with this format:
+
+```
+## Problem
+[1-2 sentence summary]
+
+## Root Cause
+[Specific file:line in GSD source, with code snippet showing the bug]
+
+## Expected Behavior
+[What the code should do instead — concrete fix suggestion]
+
+## Environment
+- GSD version: [from report]
+- Model: [from report]
+- Unit: [type/id that failed]
+
+## Reproduction Context
+[Phase, milestone, slice, what was happening when it failed]
+
+## Forensic Evidence
+[Key anomalies, error traces, relevant tool call sequences from the report]
+
+---
+*Auto-generated by `/gsd forensics`*
+```
+
+**Repository:** gsd-build/gsd-2
+**Labels:** bug, auto-generated
+
+### Redaction Rules (CRITICAL)
+
+Before creating the issue, you MUST:
+- Replace all absolute paths with relative paths
+- Remove any API keys, tokens, or credentials
+- Remove any environment variable values
+- Do not include user's project code — only GSD structural information (tool names, file names, error messages)
+
+## Report Saved
+
+Remind the user that the full forensic report was saved locally (the path will be in the notification).

package/src/resources/extensions/gsd/tests/auto-loop.test.ts

@@ -962,21 +962,25 @@ test("auto.ts startAuto calls autoLoop (not dispatchNextUnit as first dispatch)"
   );
 });
 
-test("index.ts agent_end handler calls resolveAgentEnd (not handleAgentEnd)", () => {
-  const src = readFileSync(
-    resolve(import.meta.dirname, "..", "index.ts"),
+test("agent_end handler calls resolveAgentEnd (not handleAgentEnd)", () => {
+  const hooksSrc = readFileSync(
+    resolve(import.meta.dirname, "..", "bootstrap", "register-hooks.ts"),
+    "utf-8",
+  );
+  // Verify the agent_end hook is registered
+  const handlerIdx = hooksSrc.indexOf('pi.on("agent_end"');
+  assert.ok(handlerIdx > -1, "register-hooks.ts must have an agent_end handler");
+
+  const recoverySrc = readFileSync(
+    resolve(import.meta.dirname, "..", "bootstrap", "agent-end-recovery.ts"),
     "utf-8",
   );
-  // Find the agent_end handler success path
-  const handlerIdx = src.indexOf('pi.on("agent_end"');
-  assert.ok(handlerIdx > -1, "index.ts must have an agent_end handler");
-  const handlerBlock = src.slice(handlerIdx, handlerIdx + 10000);
   assert.ok(
-    handlerBlock.includes("resolveAgentEnd(event)"),
+    recoverySrc.includes("resolveAgentEnd(event)"),
     "agent_end success path must call resolveAgentEnd(event) instead of handleAgentEnd(ctx, pi)",
   );
   assert.ok(
-    handlerBlock.includes("isSessionSwitchInFlight()"),
+    recoverySrc.includes("isSessionSwitchInFlight()"),
     "agent_end handler must ignore session-switch agent_end events from cmdCtx.newSession()",
   );
 });

package/src/resources/extensions/gsd/tests/doctor-proactive.test.ts

@@ -176,9 +176,9 @@ async function main(): Promise<void> {
 
       recordHealthSnapshot(2, 3, 1);
       const summary = formatHealthSummary();
-      assertTrue(summary.includes("2E/3W"), "summary includes error/warning counts");
-      assertTrue(summary.includes("fixes:1"), "summary includes fix count");
-      assertTrue(summary.includes("streak:1/5"), "summary includes error streak");
+      assertTrue(summary.includes("2 errors") && summary.includes("3 warnings"), "summary includes error/warning counts");
+      assertTrue(summary.includes("1 fix applied"), "summary includes fix count");
+      assertTrue(summary.includes("1 of 5 consecutive errors"), "summary includes error streak");
     }
 
     // ─── Pre-Dispatch Health Gate ─────────────────────────────────────

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -261,38 +261,38 @@ test("pauseAutoForProviderError falls back to indefinite pause when not rate lim
 
 // ── Escalating backoff for transient errors (#1166) ─────────────────────────
 
-test("index.ts tracks consecutive transient errors for escalating backoff", () => {
-  const indexSource = readFileSync(join(__dirname, "..", "index.ts"), "utf-8");
+test("agent-end-recovery.ts tracks consecutive transient errors for escalating backoff", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
 
   assert.ok(
-    indexSource.includes("consecutiveTransientErrors"),
-    "index.ts must track consecutiveTransientErrors for escalating backoff (#1166)",
+    src.includes("consecutiveTransientErrors"),
+    "agent-end-recovery.ts must track consecutiveTransientErrors for escalating backoff (#1166)",
   );
   assert.ok(
-    indexSource.includes("MAX_TRANSIENT_AUTO_RESUMES"),
-    "index.ts must define MAX_TRANSIENT_AUTO_RESUMES to cap infinite retries (#1166)",
+    src.includes("MAX_TRANSIENT_AUTO_RESUMES"),
+    "agent-end-recovery.ts must define MAX_TRANSIENT_AUTO_RESUMES to cap infinite retries (#1166)",
   );
 });
 
-test("index.ts resets consecutive transient error counter on success", () => {
-  const indexSource = readFileSync(join(__dirname, "..", "index.ts"), "utf-8");
+test("agent-end-recovery.ts resets consecutive transient error counter on success", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
 
-  // After successful unit completion, the counter must be reset.
+  // After successful agent_end (before resolveAgentEnd), the counter must be reset.
   // Use a regex across the success block so CRLF checkouts on Windows do not
   // push the reset line outside a fixed substring window.
   assert.ok(
-    /consecutiveTransientErrors\s*=\s*0\s*;[\s\S]{0,250}successful unit completion/.test(indexSource),
-    "consecutive transient error counter must be reset on successful unit completion (#1166)",
+    /consecutiveTransientErrors\s*=\s*0\s*;[\s\S]{0,250}resolveAgentEnd/.test(src),
+    "consecutive transient error counter must be reset before resolveAgentEnd on the success path (#1166)",
   );
 });
 
-test("index.ts applies escalating delay for repeated transient errors", () => {
-  const indexSource = readFileSync(join(__dirname, "..", "index.ts"), "utf-8");
+test("agent-end-recovery.ts applies escalating delay for repeated transient errors", () => {
+  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
 
-  // Must contain the exponential backoff formula
+  // Must contain the exponential backoff formula (may span multiple lines)
   assert.ok(
-    /retryAfterMs\s*[=*].*2\s*\*\*/.test(indexSource),
-    "index.ts must escalate retryAfterMs exponentially for consecutive transient errors (#1166)",
+    src.includes("2 ** Math.max(0, consecutiveTransientErrors"),
+    "agent-end-recovery.ts must escalate retryAfterMs exponentially for consecutive transient errors (#1166)",
   );
 });
 

package/src/resources/extensions/gsd/tests/skill-activation.test.ts

@@ -60,17 +60,17 @@ test("buildSkillActivationBlock matches installed skills from task context", ()
   }
 });
 
-test("buildSkillActivationBlock includes always_use_skills from preferences", () => {
+test("buildSkillActivationBlock includes always_use_skills from preferences using exact Skill tool format", () => {
   const base = makeTempBase();
   try {
-    writeSkill(base, "testing", "Use for test setup, assertions, and verification patterns.");
+    writeSkill(base, "swift-testing", "Use for Swift Testing assertions and verification patterns.");
     loadOnlyTestSkills(base);
 
     const result = buildBlock(base, { taskTitle: "Unrelated task title" }, {
-      always_use_skills: ["testing"],
+      always_use_skills: ["swift-testing"],
     });
 
-    assert.match(result, /Call Skill\('testing'\)/);
+    assert.equal(result, "<skill_activation>Call Skill('swift-testing').</skill_activation>");
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/visualizer-data.test.ts

@@ -422,25 +422,25 @@ assertTrue(
   "overlay has 10 tab labels",
 );
 
-// Verify commands.ts integration
-const commandsPath = join(__dirname, "..", "commands.ts");
-const commandsSrc = readFileSync(commandsPath, "utf-8");
+// Verify commands/handlers/core.ts integration
+const coreHandlerPath = join(__dirname, "..", "commands", "handlers", "core.ts");
+const coreHandlerSrc = readFileSync(coreHandlerPath, "utf-8");
 
-console.log("\n=== commands.ts integration ===");
+console.log("\n=== commands/handlers/core.ts integration ===");
 
 assertTrue(
-  commandsSrc.includes('"visualize"'),
-  "commands.ts has visualize in subcommands array",
+  coreHandlerSrc.includes('"visualize"'),
+  "core.ts has visualize in subcommands array",
 );
 
 assertTrue(
-  commandsSrc.includes("GSDVisualizerOverlay"),
-  "commands.ts imports GSDVisualizerOverlay",
+  coreHandlerSrc.includes("GSDVisualizerOverlay"),
+  "core.ts imports GSDVisualizerOverlay",
 );
 
 assertTrue(
-  commandsSrc.includes("handleVisualize"),
-  "commands.ts has handleVisualize handler",
+  coreHandlerSrc.includes("handleVisualize"),
+  "core.ts has handleVisualize handler",
 );
 
 report();

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

@@ -1,10 +1,11 @@
 // Data loader for workflow visualizer overlay — aggregates state + metrics.
 
 import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
 import { deriveState } from './state.js';
 import { parseRoadmap, parsePlan, parseSummary, loadFile } from './files.js';
 import { findMilestoneIds } from './milestone-ids.js';
-import { resolveMilestoneFile, resolveSliceFile, resolveGsdRootFile } from './paths.js';
+import { resolveMilestoneFile, resolveSliceFile, resolveGsdRootFile, gsdRoot } from './paths.js';
 import {
   getLedger,
   getProjectTotals,
@@ -21,6 +22,8 @@ import { loadEffectiveGSDPreferences } from './preferences.js';
 import { runProviderChecks, type ProviderCheckResult } from './doctor-providers.js';
 import { generateSkillHealthReport } from './skill-health.js';
 import { runEnvironmentChecks, type EnvironmentCheckResult } from './doctor-environment.js';
+import { computeProgressScore } from './progress-score.js';
+import { getHealthHistory } from './doctor-proactive.js';
 
 import type { Phase } from './types.js';
 import type { CaptureEntry } from './captures.js';
@@ -161,6 +164,27 @@ export interface SkillSummaryInfo {
   topIssue: string | null;
 }
 
+/** A single doctor history entry for visualizer display. */
+export interface VisualizerDoctorEntry {
+  ts: string;
+  ok: boolean;
+  errors: number;
+  warnings: number;
+  fixes: number;
+  codes: string[];
+  issues?: Array<{ severity: string; code: string; message: string; unitId: string }>;
+  fixDescriptions?: string[];
+  scope?: string;
+  summary?: string;
+}
+
+/** Current progress score snapshot for health display. */
+export interface VisualizerProgressScore {
+  level: "green" | "yellow" | "red";
+  summary: string;
+  signals: Array<{ kind: "positive" | "negative" | "neutral"; label: string }>;
+}
+
 export interface HealthInfo {
   budgetCeiling: number | undefined;
   tokenProfile: string;
@@ -174,6 +198,10 @@ export interface HealthInfo {
   providers: ProviderStatusSummary[];
   skillSummary: SkillSummaryInfo;
   environmentIssues: import("./doctor-environment.js").EnvironmentCheckResult[];
+  /** Persisted doctor run history (most recent first, up to 20 entries). */
+  doctorHistory?: VisualizerDoctorEntry[];
+  /** Current in-memory progress score (null if auto-mode not active). */
+  progressScore?: VisualizerProgressScore | null;
 }
 
 export interface VisualizerData {
@@ -608,6 +636,26 @@ function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null, basePath
     environmentIssues = runEnvironmentChecks(basePath).filter(r => r.status !== "ok");
   } catch { /* non-fatal */ }
 
+  // Doctor run history — persisted across sessions (sync read to keep loadHealth sync)
+  let doctorHistory: VisualizerDoctorEntry[] = [];
+  try {
+    const historyPath = join(gsdRoot(basePath), "doctor-history.jsonl");
+    if (existsSync(historyPath)) {
+      const lines = readFileSync(historyPath, "utf-8").split("\n").filter(l => l.trim());
+      doctorHistory = lines.slice(-20).reverse().map(l => JSON.parse(l) as VisualizerDoctorEntry);
+    }
+  } catch { /* non-fatal */ }
+
+  // Current progress score — only meaningful when auto-mode has health data
+  let progressScore: VisualizerProgressScore | null = null;
+  try {
+    const history = getHealthHistory();
+    if (history.length > 0) {
+      const score = computeProgressScore();
+      progressScore = { level: score.level, summary: score.summary, signals: score.signals };
+    }
+  } catch { /* non-fatal */ }
+
   return {
     budgetCeiling,
     tokenProfile,
@@ -621,6 +669,8 @@ function loadHealth(units: UnitMetrics[], totals: ProjectTotals | null, basePath
     providers,
     skillSummary,
     environmentIssues,
+    doctorHistory,
+    progressScore,
   };
 }
 

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

@@ -1150,6 +1150,64 @@ export function renderHealthView(
     }
   }
 
+  // Progress score section — current traffic light status
+  if (health.progressScore) {
+    lines.push("");
+    lines.push(th.fg("accent", th.bold("Progress Score")));
+    lines.push("");
+    const ps = health.progressScore;
+    const scoreColor = ps.level === "green" ? "success" : ps.level === "yellow" ? "warning" : "error";
+    const scoreIcon = ps.level === "green" ? "●" : ps.level === "yellow" ? "◐" : "○";
+    lines.push(`  ${th.fg(scoreColor, scoreIcon)} ${th.fg(scoreColor, ps.summary)}`);
+    for (const signal of ps.signals) {
+      const prefix = signal.kind === "positive" ? th.fg("success", "  ✓")
+        : signal.kind === "negative" ? th.fg("error", "  ✗")
+          : th.fg("dim", "  ·");
+      lines.push(`  ${prefix} ${th.fg("dim", signal.label)}`);
+    }
+  }
+
+  // Doctor history section — persisted across sessions
+  const doctorHistory = health.doctorHistory ?? [];
+  if (doctorHistory.length > 0) {
+    lines.push("");
+    lines.push(th.fg("accent", th.bold("Doctor History")));
+    lines.push("");
+
+    for (const entry of doctorHistory.slice(0, 10)) {
+      const icon = entry.ok ? th.fg("success", "✓") : th.fg("error", "✗");
+      const ts = entry.ts.replace("T", " ").slice(0, 19);
+      const scopeTag = entry.scope ? th.fg("accent", ` [${entry.scope}]`) : "";
+      // Prefer human-readable summary, fall back to counts
+      const detail = entry.summary
+        ? th.fg("text", entry.summary)
+        : th.fg("text", `${entry.errors} errors, ${entry.warnings} warnings, ${entry.fixes} fixes`);
+      lines.push(`  ${icon} ${th.fg("dim", ts)}${scopeTag}  ${detail}`);
+
+      // Show issue details if available
+      if (entry.issues && entry.issues.length > 0) {
+        for (const issue of entry.issues.slice(0, 3)) {
+          const issuePfx = issue.severity === "error" ? th.fg("error", "    ✗") : th.fg("warning", "    ⚠");
+          lines.push(`  ${issuePfx} ${th.fg("dim", truncateToWidth(issue.message, width - 12))}`);
+        }
+        if (entry.issues.length > 3) {
+          lines.push(`    ${th.fg("dim", `+${entry.issues.length - 3} more`)}`);
+        }
+      }
+
+      // Show fixes if available
+      if (entry.fixDescriptions && entry.fixDescriptions.length > 0) {
+        for (const fix of entry.fixDescriptions.slice(0, 2)) {
+          lines.push(`    ${th.fg("success", "↳")} ${th.fg("dim", truncateToWidth(fix, width - 12))}`);
+        }
+      }
+    }
+
+    if (doctorHistory.length > 10) {
+      lines.push(`  ${th.fg("dim", `...${doctorHistory.length - 10} older entries`)}`);
+    }
+  }
+
   // Skills section
   if (health.skillSummary?.total > 0) {
     lines.push("");