@opengsd/gsd-pi 1.0.2-dev.e70300c → 1.0.2-dev.fb7ddf1

package/src/resources/extensions/gsd/commands-usage.ts

@@ -4,10 +4,12 @@
  * Shows current LLM context window usage and session token totals.
  */
 
-import type { ExtensionCommandContext, ContextUsage, SessionEntry } from "@gsd/pi-coding-agent";
+import type { ExtensionCommandContext, ContextUsage, SessionEntry, Theme } from "@gsd/pi-coding-agent";
+import { Key, matchesKey } from "@gsd/pi-tui";
 
 import { formatCost, formatPercent, formatTokenCount } from "./metrics.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 
 export interface SessionTokenTotals {
   input: number;
@@ -160,6 +162,101 @@ export function formatUsageReport(options: {
   return lines.join("\n");
 }
 
+async function showUsageDialog(
+  ctx: ExtensionCommandContext,
+  reportText: string,
+): Promise<boolean | undefined> {
+  return ctx.ui.custom<boolean>((tui, theme: Theme, _kb, done) => {
+    let cachedLines: string[] | undefined;
+    let cachedWidth: number | undefined;
+    let cachedRows: number | undefined;
+    let cachedScrollOffset: number | undefined;
+    let scrollOffset = 0;
+    let lastMaxScroll = 0;
+    let lastVisibleRows = 1;
+
+    function render(width: number): string[] {
+      const terminalRows = process.stdout.rows || 0;
+      if (
+        cachedLines &&
+        cachedWidth === width &&
+        cachedRows === terminalRows &&
+        cachedScrollOffset === scrollOffset
+      ) {
+        return cachedLines;
+      }
+
+      const contentWidth = Math.max(1, width - 4);
+      const body = reportText.split("\n");
+      if (body[0] === "Context Usage") body.shift();
+      while (body[0] === "") body.shift();
+      const maxOverlayRows = terminalRows > 0 ? Math.max(5, Math.floor(terminalRows * 0.8)) : 24;
+      const frameRows = 4;
+      const visibleRows = Math.max(1, maxOverlayRows - frameRows);
+      const maxScroll = Math.max(0, body.length - visibleRows);
+      scrollOffset = Math.min(Math.max(scrollOffset, 0), maxScroll);
+      lastMaxScroll = maxScroll;
+      lastVisibleRows = visibleRows;
+      const visible = body.slice(scrollOffset, scrollOffset + visibleRows);
+      const scrollable = body.length > visibleRows;
+
+      cachedLines = renderDialogFrame(theme, "Context Usage", visible, width, {
+        footer: renderKeyHints(theme, scrollable ? ["↑↓ scroll", "any key close"] : ["any key close"], contentWidth),
+        scroll: { offset: scrollOffset, visibleRows, totalRows: body.length },
+      });
+      cachedWidth = width;
+      cachedRows = terminalRows;
+      cachedScrollOffset = scrollOffset;
+      return cachedLines;
+    }
+
+    function scrollBy(delta: number): boolean {
+      if (lastMaxScroll <= 0) return false;
+      const nextOffset = Math.min(Math.max(scrollOffset + delta, 0), lastMaxScroll);
+      if (nextOffset !== scrollOffset) {
+        scrollOffset = nextOffset;
+        cachedLines = undefined;
+        cachedScrollOffset = undefined;
+        tui.requestRender();
+      }
+      return true;
+    }
+
+    return {
+      render,
+      invalidate: () => {
+        cachedLines = undefined;
+        cachedWidth = undefined;
+        cachedRows = undefined;
+        cachedScrollOffset = undefined;
+      },
+      handleInput: (data: string) => {
+        if (matchesKey(data, Key.down) || matchesKey(data, "j")) {
+          if (scrollBy(1)) return;
+        }
+        if (matchesKey(data, Key.up) || matchesKey(data, "k")) {
+          if (scrollBy(-1)) return;
+        }
+        if (matchesKey(data, Key.pageDown)) {
+          if (scrollBy(lastVisibleRows)) return;
+        }
+        if (matchesKey(data, Key.pageUp)) {
+          if (scrollBy(-lastVisibleRows)) return;
+        }
+        done(true);
+      },
+    };
+  }, {
+    overlay: true,
+    overlayOptions: {
+      width: "70%",
+      minWidth: 64,
+      maxHeight: "80%",
+      anchor: "center",
+    },
+  });
+}
+
 export async function handleUsage(args: string, ctx: ExtensionCommandContext): Promise<void> {
   const contextUsage = ctx.getContextUsage?.();
   const sessionTotals = scanSessionTokenTotals(ctx.sessionManager.getEntries());
@@ -187,8 +284,16 @@ export async function handleUsage(args: string, ctx: ExtensionCommandContext): P
     return;
   }
 
-  ctx.ui.notify(
-    formatUsageReport({ modelLabel, contextUsage, sessionTotals }),
-    "info",
-  );
+  const reportText = formatUsageReport({ modelLabel, contextUsage, sessionTotals });
+
+  if (ctx.hasUI) {
+    try {
+      const result = await showUsageDialog(ctx, reportText);
+      if (result !== undefined) return;
+    } catch {
+      // Fall back to text notify below when custom overlays are unavailable.
+    }
+  }
+
+  ctx.ui.notify(reportText, "info");
 }

package/src/resources/extensions/gsd/config-overlay.ts

@@ -10,6 +10,7 @@
 import type { Theme } from "@gsd/pi-coding-agent";
 import { matchesKey, Key, truncateToWidth } from "@gsd/pi-tui";
 
+import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 import {
   loadEffectiveGSDPreferences,
   loadGlobalGSDPreferences,
@@ -231,6 +232,7 @@ export class GSDConfigOverlay {
   private onClose: () => void;
   private sections: ConfigSection[];
   private cachedLines?: string[];
+  private cachedWidth?: number;
   private scrollOffset = 0;
   private disposed = false;
 
@@ -247,6 +249,7 @@ export class GSDConfigOverlay {
 
   invalidate(): void {
     this.cachedLines = undefined;
+    this.cachedWidth = undefined;
   }
 
   dispose(): void {
@@ -286,16 +289,13 @@ export class GSDConfigOverlay {
   }
 
   render(width: number): string[] {
-    if (this.cachedLines) return this.cachedLines;
+    if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
 
     const t = this.theme;
-    const w = Math.max(width, 50);
+    const w = Math.max(1, width);
+    const contentWidth = Math.max(1, w - 4);
     const allLines: string[] = [];
 
-    // Header
-    allLines.push(t.bold(t.fg("accent", " GSD Configuration ")));
-    allLines.push(t.fg("muted", "\u2500".repeat(w)));
-
     // Find max label width for alignment
     let maxLabel = 0;
     for (const section of this.sections) {
@@ -306,26 +306,29 @@ export class GSDConfigOverlay {
     const labelPad = Math.min(maxLabel + 2, 24);
 
     for (const section of this.sections) {
-      allLines.push("");
+      if (allLines.length > 0) allLines.push("");
       allLines.push(t.bold(t.fg("accent", `  ${section.title}`)));
 
       for (const row of section.rows) {
         const label = t.fg("muted", `    ${row.label.padEnd(labelPad)}`);
         const value = row.accent ? t.bold(row.value) : row.value;
-        allLines.push(truncateToWidth(`${label}${value}`, w));
+        allLines.push(truncateToWidth(`${label}${value}`, contentWidth));
       }
     }
 
-    allLines.push("");
-    allLines.push(t.fg("muted", `  ${"\u2500".repeat(w - 4)}`));
-    allLines.push(t.fg("muted", "  esc/q close  \u2502  \u2191\u2193/jk scroll  \u2502  /gsd prefs to edit"));
-
     // Apply scroll
-    const maxScroll = Math.max(0, allLines.length - 20);
+    const terminalRows = process.stdout.rows || 32;
+    const maxBodyRows = Math.max(1, Math.min(allLines.length, terminalRows - 12));
+    const maxScroll = Math.max(0, allLines.length - maxBodyRows);
     this.scrollOffset = Math.min(this.scrollOffset, maxScroll);
-    const visible = allLines.slice(this.scrollOffset);
+    const visible = allLines.slice(this.scrollOffset, this.scrollOffset + maxBodyRows);
+    const footer = renderKeyHints(t, ["esc/q close", "\u2191\u2193/jk scroll", "/gsd prefs to edit"], contentWidth);
 
-    this.cachedLines = visible;
-    return visible;
+    this.cachedLines = renderDialogFrame(t, "GSD Configuration", visible, w, {
+      footer,
+      scroll: { offset: this.scrollOffset, visibleRows: maxBodyRows, totalRows: allLines.length },
+    });
+    this.cachedWidth = width;
+    return this.cachedLines;
   }
 }

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

@@ -3,11 +3,11 @@
  */
 
 import type { Theme, ThemeColor } from "@gsd/pi-coding-agent";
-import { matchesKey, Key, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
+import { matchesKey, Key, truncateToWidth } from "@gsd/pi-tui";
 
 import type { ContextBreakdownReport, ContextSectionBreakdown } from "./commands-context.js";
 import { formatTokenCount } from "./metrics.js";
-import { renderProgressBar, rightAlign } from "./tui/render-kit.js";
+import { renderDialogFrame, renderKeyHints, renderProgressBar, rightAlign } from "./tui/render-kit.js";
 
 const SECTION_COLORS: ThemeColor[] = ["accent", "success", "warning", "borderAccent", "text"];
 
@@ -70,6 +70,7 @@ export class GSDContextOverlay {
   private onClose: () => void;
   private report: ContextBreakdownReport;
   private cachedLines?: string[];
+  private cachedWidth?: number;
   private scrollOffset = 0;
   private disposed = false;
 
@@ -87,6 +88,7 @@ export class GSDContextOverlay {
 
   invalidate(): void {
     this.cachedLines = undefined;
+    this.cachedWidth = undefined;
   }
 
   dispose(): void {
@@ -125,24 +127,22 @@ export class GSDContextOverlay {
   }
 
   render(width: number): string[] {
-    if (this.cachedLines) return this.cachedLines;
+    if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
 
     const theme = this.theme;
-    const w = Math.max(width, 60);
+    const w = Math.max(1, width);
+    const contentWidth = Math.max(1, w - 4);
     const totals = getContextChartTotals(this.report);
     const chartTotal = Math.max(totals.inContext, totals.estimated, 1);
     const lines: string[] = [];
 
-    lines.push(theme.bold(theme.fg("accent", " Context Breakdown ")));
-    lines.push(theme.fg("muted", "─".repeat(w)));
-
     if (this.report.modelLabel) {
-      lines.push(rightAlign(theme.fg("muted", "Model"), theme.fg("text", this.report.modelLabel), w));
+      lines.push(rightAlign(theme.fg("muted", "Model"), theme.fg("text", this.report.modelLabel), contentWidth));
     }
 
     lines.push("");
     if (totals.window != null) {
-      const usageBarWidth = Math.max(20, w - 28);
+      const usageBarWidth = Math.max(8, contentWidth - 28);
       const usageBar = renderProgressBar(theme, totals.inContext, totals.window, usageBarWidth, {
         filledColor: totals.inContext / totals.window > 0.85 ? "warning" : "accent",
       });
@@ -151,7 +151,7 @@ export class GSDContextOverlay {
       lines.push(`  ${theme.fg("muted", "Estimated")} ${theme.fg("text", formatTokenCount(chartTotal))}`);
     }
 
-    const splitWidth = Math.max(16, Math.floor((w - 8) / 2));
+    const splitWidth = Math.max(8, Math.floor((contentWidth - 8) / 2));
     const systemBar = renderProgressBar(theme, totals.systemTokens, chartTotal, splitWidth, { filledColor: "accent" });
     const convBar = renderProgressBar(theme, totals.conversationTokens, chartTotal, splitWidth, { filledColor: "success" });
     lines.push("");
@@ -160,11 +160,11 @@ export class GSDContextOverlay {
 
     lines.push("");
     lines.push(theme.bold(theme.fg("accent", "  System prompt")));
-    lines.push(...renderSectionBars(theme, this.report.systemSections, chartTotal, w, 22));
+    lines.push(...renderSectionBars(theme, this.report.systemSections, chartTotal, contentWidth, 22));
 
     lines.push("");
     lines.push(theme.bold(theme.fg("accent", "  Conversation")));
-    lines.push(...renderSectionBars(theme, this.report.conversationSections, chartTotal, w, 22));
+    lines.push(...renderSectionBars(theme, this.report.conversationSections, chartTotal, contentWidth, 22));
 
     lines.push("");
     lines.push(theme.bold(theme.fg("accent", "  Skills")));
@@ -172,7 +172,7 @@ export class GSDContextOverlay {
     if (skills.available.length > 0) {
       lines.push(`    ${theme.fg("muted", "Available")} ${theme.fg("text", `${skills.available.length}`)}`);
       const preview = skills.available.slice(0, 8).join(", ");
-      lines.push(truncateToWidth(`      ${preview}${skills.available.length > 8 ? "…" : ""}`, w));
+      lines.push(truncateToWidth(`      ${preview}${skills.available.length > 8 ? "…" : ""}`, contentWidth));
     } else {
       lines.push(theme.fg("dim", "    none in prompt"));
     }
@@ -187,13 +187,18 @@ export class GSDContextOverlay {
     lines.push(theme.bold(theme.fg("accent", "  Agents")));
     lines.push(`    ${theme.fg("muted", "Subagent spawns")} ${theme.fg("text", String(this.report.subagentSpawns))}`);
 
-    lines.push("");
-    lines.push(theme.fg("muted", `  ${"─".repeat(Math.max(0, w - 4))}`));
-    lines.push(theme.fg("muted", "  esc/q close  │  ↑↓ scroll  │  /gsd context --open for browser chart"));
-
-    const maxScroll = Math.max(0, lines.length - 24);
+    const terminalRows = process.stdout.rows || 32;
+    const maxBodyRows = Math.max(1, Math.min(lines.length, terminalRows - 12));
+    const maxScroll = Math.max(0, lines.length - maxBodyRows);
     this.scrollOffset = Math.min(this.scrollOffset, maxScroll);
-    this.cachedLines = lines.slice(this.scrollOffset);
+    const visible = lines.slice(this.scrollOffset, this.scrollOffset + maxBodyRows);
+    const footer = renderKeyHints(theme, ["esc/q close", "↑↓ scroll", "/gsd context --open"], contentWidth);
+
+    this.cachedLines = renderDialogFrame(theme, "Context Breakdown", visible, w, {
+      footer,
+      scroll: { offset: this.scrollOffset, visibleRows: maxBodyRows, totalRows: lines.length },
+    });
+    this.cachedWidth = width;
     return this.cachedLines;
   }
 }

package/src/resources/extensions/gsd/dashboard-overlay.ts

@@ -8,7 +8,7 @@
  */
 
 import type { Theme } from "@gsd/pi-coding-agent";
-import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
+import { truncateToWidth, matchesKey, Key } from "@gsd/pi-tui";
 import { deriveState } from "./state.js";
 import { loadFile } from "./files.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
@@ -29,6 +29,7 @@ import { estimateTimeRemaining } from "./auto-dashboard.js";
 import { computeProgressScore, formatProgressLine } from "./progress-score.js";
 import { runEnvironmentChecks, type EnvironmentCheckResult } from "./doctor-environment.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
+import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 
 export function unitLabel(type: string): string {
   switch (type) {
@@ -258,35 +259,26 @@ export class GSDDashboardOverlay {
 
     const content = this.buildContentLines(width);
     const viewportHeight = Math.max(5, process.stdout.rows ? process.stdout.rows - 8 : 24);
-    const chromeHeight = 2;
-    const visibleContentRows = Math.max(1, viewportHeight - chromeHeight);
+    const visibleContentRows = Math.max(1, viewportHeight - 4);
     const maxScroll = Math.max(0, content.length - visibleContentRows);
     this.scrollOffset = Math.min(this.scrollOffset, maxScroll);
     const visibleContent = content.slice(this.scrollOffset, this.scrollOffset + visibleContentRows);
-
-    const lines = this.wrapInBox(visibleContent, width);
+    const contentWidth = Math.max(1, width - 4);
+    const footer = renderKeyHints(
+      this.theme,
+      ["↑↓ scroll", "g/G top/end", `Esc/${formattedShortcutPair("dashboard")} close`],
+      contentWidth,
+    );
+    const lines = renderDialogFrame(this.theme, "GSD Dashboard", visibleContent, width, {
+      footer,
+      scroll: { offset: this.scrollOffset, visibleRows: visibleContentRows, totalRows: content.length },
+    });
 
     this.cachedWidth = width;
     this.cachedLines = lines;
     return lines;
   }
 
-  private wrapInBox(inner: string[], width: number): string[] {
-    const th = this.theme;
-    const border = (s: string) => th.fg("borderAccent", s);
-    const innerWidth = width - 4;
-    const lines: string[] = [];
-
-    lines.push(border("╭" + "─".repeat(width - 2) + "╮"));
-    for (const line of inner) {
-      const truncated = truncateToWidth(line, innerWidth);
-      const padWidth = Math.max(0, innerWidth - visibleWidth(truncated));
-      lines.push(border("│") + " " + truncated + " ".repeat(padWidth) + " " + border("│"));
-    }
-    lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
-    return lines;
-  }
-
   private buildContentLines(width: number): string[] {
     const th = this.theme;
     const shellWidth = width - 4;
@@ -303,7 +295,6 @@ export class GSDDashboardOverlay {
     const hr = () => row(th.fg("dim", "─".repeat(contentWidth)));
     const centered = (content: string) => row(centerLine(content, contentWidth));
 
-    const title = th.fg("accent", th.bold("GSD Dashboard"));
     const isRemote = !!this.dashData.remoteSession;
     const status = this.dashData.active
       ? `${Date.now() % 2000 < 1000 ? th.fg("success", "●") : th.fg("dim", "○")} ${th.fg("success", "AUTO")}`
@@ -328,7 +319,7 @@ export class GSDDashboardOverlay {
     } else if (isRemote) {
       elapsedParts = th.fg("dim", `since ${this.dashData.remoteSession!.startedAt.replace("T", " ").slice(0, 19)}`);
     }
-    lines.push(row(joinColumns(`${title}  ${status}${worktreeTag}`, elapsedParts, contentWidth)));
+    lines.push(row(joinColumns(`${status}${worktreeTag}`, elapsedParts, contentWidth)));
 
     // Progress score — traffic light indicator (#1221)
     if (this.dashData.active || this.dashData.paused) {
@@ -610,10 +601,6 @@ export class GSDDashboardOverlay {
       }
     }
 
-    lines.push(blank());
-    lines.push(hr());
-    lines.push(centered(th.fg("dim", `↑↓ scroll · g/G top/end · Esc/${formattedShortcutPair("dashboard")} close`)));
-
     return lines;
   }
 

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

@@ -3,6 +3,7 @@ import { join } from "node:path";
 
 import type { DoctorIssue } from "./doctor-types.js";
 import { isDbAvailable, _getAdapter } from "./gsd-db.js";
+import { isAfter, latestExplicitReopenAt } from "./milestone-reopen-events.js";
 import { resolveGsdPathContract, resolveMilestoneFile } from "./paths.js";
 import { deriveState } from "./state.js";
 import { readEvents } from "./workflow-events.js";
@@ -151,6 +152,104 @@ export async function checkEngineHealth(
       } catch {
         // Non-fatal — duplicate ID check failed
       }
+
+      // e. Completed milestone dispatch history but DB reopened without an explicit reopen event.
+      try {
+        const reopened = adapter
+          .prepare(
+            `SELECT m.id, m.status, ud.started_at, ud.ended_at
+             FROM milestones m
+             JOIN unit_dispatches ud ON ud.milestone_id = m.id
+             WHERE m.status NOT IN ('complete', 'done', 'skipped', 'closed')
+               AND ud.unit_type = 'complete-milestone'
+               AND ud.unit_id = m.id
+               AND ud.status = 'completed'
+               AND ud.id = (
+                 SELECT latest.id
+                 FROM unit_dispatches latest
+                 WHERE latest.milestone_id = m.id
+                   AND latest.unit_type = 'complete-milestone'
+                   AND latest.unit_id = m.id
+                   AND latest.status = 'completed'
+                 ORDER BY COALESCE(latest.ended_at, latest.started_at) DESC, latest.id DESC
+                 LIMIT 1
+               )
+             ORDER BY m.id`,
+          )
+          .all() as Array<{ id: string; status: string; started_at: string | null; ended_at: string | null }>;
+
+        for (const row of reopened) {
+          const completedAt = row.ended_at ?? row.started_at ?? null;
+          const reopenAt = latestExplicitReopenAt(basePath, row.id);
+          if (reopenAt && (!completedAt || Date.parse(reopenAt) > Date.parse(completedAt))) continue;
+          issues.push({
+            severity: "error",
+            code: "completed_milestone_reopened",
+            scope: "milestone",
+            unitId: row.id,
+            message: `Milestone ${row.id} has completed complete-milestone dispatch history but DB status is ${row.status}. Explicitly reopen or recover before planning it again.`,
+            fixable: false,
+          });
+        }
+      } catch {
+        // Non-fatal — completed-milestone reopen check failed
+      }
+
+      // f. Completion artifacts disagree with open DB hierarchy rows.
+      try {
+        const rows = adapter
+          .prepare(
+            `SELECT a.path, a.artifact_type, a.milestone_id, a.slice_id, a.task_id, a.imported_at,
+                    m.status AS milestone_status,
+                    s.status AS slice_status,
+                    t.status AS task_status,
+                    (SELECT COUNT(*) FROM tasks tt WHERE tt.milestone_id = a.milestone_id AND tt.slice_id = a.slice_id) AS task_count
+             FROM artifacts a
+             JOIN milestones m ON m.id = a.milestone_id
+             LEFT JOIN slices s ON s.milestone_id = a.milestone_id AND s.id = a.slice_id
+             LEFT JOIN tasks t ON t.milestone_id = a.milestone_id AND t.slice_id = a.slice_id AND t.id = a.task_id
+             WHERE a.artifact_type = 'SUMMARY'
+               AND m.status NOT IN ('complete', 'done', 'skipped', 'closed')`,
+          )
+          .all() as Array<{
+            path: string;
+            milestone_id: string;
+            slice_id: string | null;
+            task_id: string | null;
+            imported_at: string | null;
+            slice_status: string | null;
+            task_status: string | null;
+            task_count: number;
+          }>;
+
+        const seen = new Set<string>();
+        for (const row of rows) {
+          const reopenAt = latestExplicitReopenAt(basePath, row.milestone_id);
+          if (!isAfter(row.imported_at, reopenAt)) continue;
+          const isSliceSummary = row.slice_id && !row.task_id && row.slice_status && !["complete", "done", "skipped", "closed"].includes(row.slice_status);
+          const isTaskSummary = row.slice_id && row.task_id && (!row.task_status || !["complete", "done", "skipped", "closed"].includes(row.task_status));
+          const isTaskArtifactWithoutDbTasks = row.slice_id && row.task_id && Number(row.task_count) === 0;
+          if (!isSliceSummary && !isTaskSummary && !isTaskArtifactWithoutDbTasks) continue;
+
+          const unitId = row.task_id
+            ? `${row.milestone_id}/${row.slice_id}/${row.task_id}`
+            : row.slice_id
+              ? `${row.milestone_id}/${row.slice_id}`
+              : row.milestone_id;
+          if (seen.has(unitId)) continue;
+          seen.add(unitId);
+          issues.push({
+            severity: "error",
+            code: "artifact_db_status_divergence",
+            scope: row.task_id ? "task" : row.slice_id ? "slice" : "milestone",
+            unitId,
+            message: `Completion artifact ${row.path} exists while DB state for ${unitId} is still open or missing. Runtime will not import it silently; run explicit recovery/repair after review.`,
+            fixable: false,
+          });
+        }
+      } catch {
+        // Non-fatal — artifact/DB status drift check failed
+      }
     }
   } catch {
     // Non-fatal — DB constraint checks failed entirely

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

@@ -1,7 +1,7 @@
 // gsd-pi doctor git health checks
 import { spawnSync } from "node:child_process";
-import { existsSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { cpSync, existsSync, mkdirSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
 
 import type { DoctorIssue, DoctorIssueCode } from "./doctor-types.js";
 import { loadFile } from "./files.js";
@@ -56,11 +56,47 @@ function isSameOrNestedPath(candidate: string, container: string): boolean {
     normalizedCandidate.startsWith(`${normalizedContainer}/`);
 }
 
-function hasProjectContentOnDisk(dirPath: string): boolean {
+function normalizeGitPath(path: string): string {
+  return path.replaceAll("\\", "/").replace(/^\.\//, "");
+}
+
+function isProjectContentPath(path: string): boolean {
+  const normalized = normalizeGitPath(path);
+  if (!normalized || normalized.endsWith("/")) return false;
+  if (normalized === ".gitignore" || normalized === ".gitattributes") return false;
+  if (normalized.endsWith(".DS_Store")) return false;
+  const parts = normalized.split("/");
+  return !parts.some(part => part === ".git" || part === ".gsd");
+}
+
+function gitLines(basePath: string, args: string[]): string[] {
+  const result = spawnSync("git", args, {
+    cwd: basePath,
+    encoding: "utf-8",
+  });
+  if (result.status !== 0) return [];
+  return result.stdout
+    .split("\n")
+    .map(line => normalizeGitPath(line.trim()))
+    .filter(isProjectContentPath);
+}
+
+function listProjectContentFiles(basePath: string): string[] {
+  return [...new Set([
+    ...gitLines(basePath, ["ls-files"]),
+    ...gitLines(basePath, ["ls-files", "--others", "--exclude-standard"]),
+  ])];
+}
+
+function hasMaterializedProjectContentFallback(dirPath: string): boolean {
   try {
     for (const entry of readdirSync(dirPath, { withFileTypes: true })) {
-      if (entry.name === ".git" || entry.name === ".gsd") continue;
+      if (!isProjectContentPath(entry.name)) continue;
       if (entry.name === ".DS_Store") continue;
+      if (entry.isDirectory()) {
+        if (hasMaterializedProjectContentFallback(join(dirPath, entry.name))) return true;
+        continue;
+      }
       return true;
     }
   } catch {
@@ -69,6 +105,27 @@ function hasProjectContentOnDisk(dirPath: string): boolean {
   return false;
 }
 
+function hasProjectContentOnDisk(dirPath: string): boolean {
+  const gitProjectFiles = listProjectContentFiles(dirPath);
+  if (gitProjectFiles.length > 0) {
+    return gitProjectFiles.some(file => existsSync(join(dirPath, file)));
+  }
+  return hasMaterializedProjectContentFallback(dirPath);
+}
+
+function copyProjectRootContentIntoWorktree(projectRoot: string, worktreeRoot: string): number {
+  let copied = 0;
+  for (const relPath of listProjectContentFiles(projectRoot)) {
+    const src = join(projectRoot, relPath);
+    if (!existsSync(src)) continue;
+    const dst = join(worktreeRoot, relPath);
+    mkdirSync(dirname(dst), { recursive: true });
+    cpSync(src, dst, { recursive: true, force: true });
+    copied++;
+  }
+  return copied;
+}
+
 function getSnapshotDiffCheckFailure(basePath: string): string | null {
   const failures: string[] = [];
 
@@ -176,7 +233,17 @@ export async function checkGitHealth(
             if (reset.status !== 0) {
               throw new Error(reset.stderr || reset.error?.message || "git reset --hard failed");
             }
-            fixesApplied.push(`recreated empty worktree ${wt.path}`);
+            const copied = !hasProjectContentOnDisk(recreated.path) && hasProjectContentOnDisk(basePath)
+              ? copyProjectRootContentIntoWorktree(basePath, recreated.path)
+              : 0;
+            if (!hasProjectContentOnDisk(recreated.path) && hasProjectContentOnDisk(basePath)) {
+              throw new Error("recreated worktree still has no project content");
+            }
+            fixesApplied.push(
+              copied > 0
+                ? `recreated empty worktree ${wt.path} and copied ${copied} project file${copied === 1 ? "" : "s"} from project root`
+                : `recreated empty worktree ${wt.path}`,
+            );
           } catch {
             fixesApplied.push(`failed to recreate empty worktree ${wt.path}`);
           }