@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.75048e7

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

@@ -1,11 +1,14 @@
 /**
  * GSD Maintenance — cleanup, skip, dry-run, and recover handlers.
  *
- * Contains: handleCleanupBranches, handleCleanupSnapshots, handleCleanupWorktrees, handleSkip, handleDryRun, handleRecover
+ * Contains: handleCleanupBranches, handleCleanupSnapshots, handleCleanupWorktrees, handleSkip, handleDryRun, handleRecover, handleRebuild
  */
 
 import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
 import { deriveState } from "./state.js";
+import { gsdProjectionRoot, gsdRoot } from "./paths.js";
 import { nativeBranchList, nativeDetectMainBranch, nativeBranchListMerged, nativeBranchDelete, nativeForEachRef, nativeUpdateRef } from "./native-git-bridge.js";
 import { logWarning } from "./workflow-logger.js";
 
@@ -478,6 +481,39 @@ export async function handleCleanupProjects(args: string, ctx: ExtensionCommandC
   ctx.ui.notify(lines.join("\n"), "info");
 }
 
+function recoverConfirmed(args: string): boolean {
+  return args
+    .split(/\s+/)
+    .map((part) => part.trim().toLowerCase())
+    .some((part) => part === "--confirm" || part === "--yes" || part === "confirm");
+}
+
+async function confirmRecover(ctx: ExtensionCommandContext, args: string): Promise<boolean> {
+  if (recoverConfirmed(args)) return true;
+
+  const warning = [
+    "gsd recover imports markdown into the database.",
+    "It clears and reconstructs milestone, slice, and task hierarchy rows from rendered markdown.",
+    "Use /gsd rebuild markdown for normal DB-to-markdown realignment.",
+  ].join("\n");
+
+  if (typeof ctx.ui.confirm === "function") {
+    const confirmed = await ctx.ui.confirm(
+      "Import markdown into the DB?",
+      `${warning}\n\nContinue only if the DB is lost or corrupt and markdown is the source you intend to import.`,
+    );
+    if (confirmed) return true;
+    ctx.ui.notify("gsd recover cancelled. No database changes made.", "info");
+    return false;
+  }
+
+  ctx.ui.notify(
+    `${warning}\n\nNo database changes made. Re-run /gsd recover --confirm to proceed.`,
+    "warning",
+  );
+  return false;
+}
+
 /**
  * `gsd recover` — Reconstruct DB hierarchy state from rendered markdown on disk.
  *
@@ -487,7 +523,7 @@ export async function handleCleanupProjects(args: string, ctx: ExtensionCommandC
  *
  * Prints counts of recovered items and the resulting project phase.
  */
-export async function handleRecover(ctx: ExtensionCommandContext, basePath: string): Promise<void> {
+export async function handleRecover(ctx: ExtensionCommandContext, basePath: string, args = ""): Promise<void> {
   const { isDbAvailable: dbAvailable, clearEngineHierarchy, transaction: dbTransaction } = await import("./gsd-db.js");
   const { migrateHierarchyToDb } = await import("./md-importer.js");
   const { invalidateStateCache } = await import("./state.js");
@@ -497,6 +533,8 @@ export async function handleRecover(ctx: ExtensionCommandContext, basePath: stri
     return;
   }
 
+  if (!(await confirmRecover(ctx, args))) return;
+
   try {
     // 1. Delete + re-populate inside a single transaction for atomicity.
     //    clearEngineHierarchy() uses transaction() internally but transaction()
@@ -542,3 +580,160 @@ export async function handleRecover(ctx: ExtensionCommandContext, basePath: stri
     ctx.ui.notify(`gsd recover failed: ${msg}`, "error");
   }
 }
+
+function normalizeArtifactPath(value: string): string {
+  return value.replace(/\\/g, "/");
+}
+
+function pathWithin(root: string, candidate: string): boolean {
+  const rel = relative(root, candidate);
+  return rel.length === 0 || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+
+function artifactPathForDb(basePath: string, absPath: string): string {
+  const projectionRoot = gsdProjectionRoot(basePath);
+  const root = pathWithin(projectionRoot, absPath) ? projectionRoot : gsdRoot(basePath);
+  return normalizeArtifactPath(relative(root, absPath));
+}
+
+function quarantineRelativePath(basePath: string, absPath: string): string {
+  for (const root of [gsdProjectionRoot(basePath), gsdRoot(basePath)]) {
+    if (pathWithin(root, absPath)) {
+      return normalizeArtifactPath(relative(root, absPath));
+    }
+  }
+  return normalizeArtifactPath(absPath.replace(/^[/\\]+/, ""));
+}
+
+function uniquePath(path: string): string {
+  if (!existsSync(path)) return path;
+  let idx = 2;
+  while (existsSync(`${path}.${idx}`)) idx++;
+  return `${path}.${idx}`;
+}
+
+function resolveDiskArtifactPath(basePath: string, artifactPath: string): string {
+  if (isAbsolute(artifactPath)) return artifactPath;
+  const candidates = [
+    join(gsdProjectionRoot(basePath), artifactPath),
+    join(gsdRoot(basePath), artifactPath),
+  ];
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0]!;
+}
+
+function quarantineProjectionFile(basePath: string, absPath: string, stamp: string): string {
+  const rel = quarantineRelativePath(basePath, absPath);
+  const target = uniquePath(join(gsdProjectionRoot(basePath), "quarantine", "projections", stamp, rel));
+  mkdirSync(dirname(target), { recursive: true });
+  renameSync(absPath, target);
+  return target;
+}
+
+type RebuildTarget = "markdown" | "database" | "usage";
+
+function parseRebuildTarget(args: string): RebuildTarget {
+  const trimmed = args.trim().toLowerCase();
+  if (!trimmed || trimmed === "markdown") return "markdown";
+  if (trimmed === "database" || trimmed === "db") return "database";
+  return "usage";
+}
+
+/**
+ * `gsd rebuild markdown` — Re-render markdown projections from the authoritative DB.
+ *
+ * This is the DB-first realignment command. It does not import markdown into
+ * the DB. Completion SUMMARY files that contradict open DB rows are preserved
+ * under `.gsd/quarantine/projections/` before DB projections are rendered.
+ */
+export async function handleRebuild(ctx: ExtensionCommandContext, basePath: string, args = ""): Promise<void> {
+  const { isDbAvailable: dbAvailable, deleteArtifactByPath } = await import("./gsd-db.js");
+  const { detectArtifactDbDrift } = await import("./state-reconciliation/drift/artifact-db.js");
+  const { renderAllFromDb } = await import("./markdown-renderer.js");
+  const { invalidateStateCache } = await import("./state.js");
+
+  const target = parseRebuildTarget(args);
+  if (target === "usage") {
+    ctx.ui.notify(
+      [
+        "Usage:",
+        "  /gsd rebuild markdown   Rebuild markdown projections from the canonical DB",
+        "  /gsd rebuild database   Reserved for DB-native rebuilds; does not import markdown",
+      ].join("\n"),
+      "warning",
+    );
+    return;
+  }
+
+  if (target === "database") {
+    ctx.ui.notify(
+      [
+        "gsd rebuild database is reserved for DB-native rebuilds.",
+        "It will not import markdown projections into the DB.",
+        "For normal realignment, run /gsd rebuild markdown.",
+        "If the DB is lost or corrupt and markdown is the source to import, run /gsd recover --confirm.",
+      ].join("\n"),
+      "warning",
+    );
+    return;
+  }
+
+  if (!dbAvailable()) {
+    ctx.ui.notify("gsd rebuild markdown: No database open. Run a GSD command first to initialize the DB.", "error");
+    return;
+  }
+
+  try {
+    invalidateStateCache();
+    const state = await deriveState(basePath);
+    const drifts = detectArtifactDbDrift(state, { basePath, state });
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const quarantined: string[] = [];
+    const seen = new Set<string>();
+
+    for (const drift of drifts) {
+      if (drift.kind !== "artifact-db-status-divergence") continue;
+      if (drift.artifactType !== "SUMMARY" || !drift.artifactPath) continue;
+      const absPath = resolveDiskArtifactPath(basePath, drift.artifactPath);
+      if (seen.has(absPath) || !existsSync(absPath)) continue;
+      seen.add(absPath);
+      const artifactDbPath = artifactPathForDb(basePath, absPath);
+      const target = quarantineProjectionFile(basePath, absPath, stamp);
+      deleteArtifactByPath(artifactDbPath);
+      quarantined.push(target);
+    }
+
+    const rendered = await renderAllFromDb(basePath);
+    invalidateStateCache();
+
+    const lines = [
+      "gsd rebuild markdown: rebuilt markdown projections from the canonical DB",
+      `  Rendered:    ${rendered.rendered}`,
+      `  Skipped:     ${rendered.skipped}`,
+      `  Quarantined: ${quarantined.length}`,
+    ];
+    if (rendered.errors.length > 0) {
+      lines.push(`  Errors:      ${rendered.errors.length}`);
+      for (const err of rendered.errors.slice(0, 5)) {
+        lines.push(`    - ${err}`);
+      }
+      if (rendered.errors.length > 5) {
+        lines.push(`    - ${rendered.errors.length - 5} more`);
+      }
+    }
+    if (quarantined.length > 0) {
+      lines.push("", "  Quarantine:");
+      for (const target of quarantined.slice(0, 5)) {
+        lines.push(`    - ${target}`);
+      }
+      if (quarantined.length > 5) {
+        lines.push(`    - ${quarantined.length - 5} more`);
+      }
+    }
+
+    ctx.ui.notify(lines.join("\n"), rendered.errors.length > 0 ? "warning" : "success");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logWarning("command", `rebuild failed: ${msg}`);
+    ctx.ui.notify(`gsd rebuild failed: ${msg}`, "error");
+  }
+}

package/src/resources/extensions/gsd/commands-mcp-status.ts

@@ -7,6 +7,7 @@
  *   /gsd mcp             — Overview of all servers (alias: /gsd mcp status)
  *   /gsd mcp status      — Same as bare /gsd mcp
  *   /gsd mcp check <srv> — Detailed status for a specific server
+ *   /gsd mcp discover [srv] — Connect and list tools for a server
  *   /gsd mcp test <srv>  — Test handshake + tools/list for a server
  *   /gsd mcp enable <srv> / disable <srv> — Toggle local server exposure
  *   /gsd mcp import <srv> [as <name>] — Copy a discovered server into local config
@@ -34,6 +35,7 @@ export interface McpServerStatus {
   name: string;
   transport: ManagedMcpTransport;
   connected: boolean;
+  available?: boolean;
   toolCount: number;
   error: string | undefined;
   disabled?: boolean;
@@ -45,6 +47,8 @@ export interface McpServerDetail extends McpServerStatus {
   tools: string[];
 }
 
+const MCP_STATUS_PROBE_TIMEOUT_MS = 10_000;
+
 export function hasHostMcpTool(systemPrompt: string, serverName: string): boolean {
   const marker = `mcp__${serverName}__`;
   return systemPrompt.includes(marker);
@@ -68,7 +72,8 @@ export function formatMcpInitResult(
     `Project: ${targetPath}`,
     `Config:   ${configPath}`,
     "",
-    "MCP-capable clients can now load the GSD workflow MCP server from this folder.",
+    "MCP-capable clients can now load the GSD workflow and gsd-browser MCP servers from this folder.",
+    "Pi Providers use the managed gsd-browser engine directly; this project config is for External MCP Clients.",
     "Restart or reconnect any client that already has this project open.",
   ].join("\n");
 }
@@ -89,13 +94,15 @@ export function formatMcpStatusReport(servers: McpServerStatus[]): string {
   const lines: string[] = [`MCP Server Status — ${servers.length} server(s)\n`];
 
   for (const s of servers) {
-    const icon = s.disabled ? "⊘" : s.error ? "✗" : s.connected ? "✓" : "○";
+    const icon = s.disabled ? "⊘" : s.error ? "✗" : s.connected || s.available ? "✓" : "○";
     const status = s.disabled
       ? "disabled"
       : s.error
       ? `error: ${s.error}`
       : s.connected
         ? `connected — ${s.toolCount} tools`
+        : s.available
+          ? `available — ${s.toolCount} tools`
         : "disconnected";
     const warningText = s.envWarnings?.length ? ` — ${s.envWarnings.length} warning(s)` : "";
     lines.push(`  ${icon} ${s.name} (${s.transport}) — ${status}${warningText}`);
@@ -103,8 +110,8 @@ export function formatMcpStatusReport(servers: McpServerStatus[]): string {
 
   lines.push("");
   lines.push("Use /gsd mcp check <server> for details on a specific server.");
+  lines.push("Use /gsd mcp discover <server> to connect and list tools.");
   lines.push("Use /gsd mcp test <server> to verify handshake and tool discovery.");
-  lines.push("Use mcp_discover to connect and list tools for a server.");
 
   return lines.join("\n");
 }
@@ -120,8 +127,8 @@ export function formatMcpServerDetail(server: McpServerDetail): string {
   } else if (server.error) {
     lines.push(`  Status:    error`);
     lines.push(`  Error:     ${server.error}`);
-  } else if (server.connected) {
-    lines.push(`  Status:    connected`);
+  } else if (server.connected || server.available) {
+    lines.push(`  Status:    ${server.connected ? "connected" : "available"}`);
     lines.push(`  Tools:     ${server.toolCount}`);
     if (server.tools.length > 0) {
       lines.push("");
@@ -133,7 +140,7 @@ export function formatMcpServerDetail(server: McpServerDetail): string {
   } else {
     lines.push(`  Status:    disconnected`);
     lines.push("");
-    lines.push(`  Run mcp_discover("${server.name}") to connect and list tools.`);
+    lines.push(`  Run /gsd mcp discover ${server.name} to connect and list tools.`);
   }
 
   if (server.envWarnings?.length) {
@@ -167,10 +174,93 @@ export function formatMcpConnectionTestResult(result: ManagedMcpConnectionTestRe
   ].join("\n");
 }
 
+export function formatMcpDiscoveryResult(result: ManagedMcpConnectionTestResult): string {
+  if (result.ok) {
+    return [
+      `MCP discovery completed for ${result.server}.`,
+      "",
+      `Transport: ${result.transport}`,
+      `Tools:     ${result.toolCount}`,
+      ...(result.tools.length > 0 ? ["", "Discovered tools:", ...result.tools.map((tool) => `  - ${tool}`)] : []),
+      "",
+      `Call with: mcp_call(server="${result.server}", tool="<tool_name>", args={...})`,
+    ].join("\n");
+  }
+
+  return [
+    `MCP discovery failed for ${result.server}.`,
+    "",
+    `Transport: ${result.transport}`,
+    `Error:     ${result.error ?? "Unknown error"}`,
+    ...(result.warnings.length > 0 ? ["", "Warnings:", ...result.warnings.map((warning) => `  - ${warning}`)] : []),
+  ].join("\n");
+}
+
+async function readLiveConnectionStatus(serverName: string): Promise<{
+  connected: boolean;
+  tools: string[];
+  error?: string;
+}> {
+  try {
+    const mcpClient = await import("../mcp-client/index.js");
+    const mod = mcpClient as Record<string, unknown>;
+    if (typeof mod.getConnectionStatus === "function") {
+      return (mod.getConnectionStatus as (name: string) => { connected: boolean; tools: string[]; error?: string })(serverName);
+    }
+  } catch {
+    // mcp-client may not expose status helpers in some hosts.
+  }
+  return { connected: false, tools: [] };
+}
+
+function shouldProbeConfiguredServer(config: { disabled?: boolean; transport: ManagedMcpTransport; envWarnings?: string[] }): boolean {
+  return !config.disabled && config.transport === "stdio" && (config.envWarnings?.length ?? 0) === 0;
+}
+
+async function resolveMcpRuntimeStatus(
+  config: {
+    name: string;
+    transport: ManagedMcpTransport;
+    disabled?: boolean;
+    envWarnings?: string[];
+  },
+  systemPrompt: string,
+): Promise<{
+  connected: boolean;
+  available: boolean;
+  tools: string[];
+  error?: string;
+}> {
+  const live = await readLiveConnectionStatus(config.name);
+  let connected = live.connected;
+  let tools = live.tools;
+  let error = live.error;
+
+  if (!connected && !error && hasHostMcpTool(systemPrompt, config.name)) connected = true;
+
+  if (!connected && !error && shouldProbeConfiguredServer(config)) {
+    const probed = await testMcpServerConnection(config.name, { timeoutMs: MCP_STATUS_PROBE_TIMEOUT_MS });
+    if (probed.ok) {
+      return {
+        connected: false,
+        available: true,
+        tools: probed.tools,
+      };
+    }
+    error = probed.error;
+  }
+
+  return {
+    connected,
+    available: false,
+    tools,
+    error,
+  };
+}
 // ─── Command handler ────────────────────────────────────────────────────────
 
 /**
- * Handle `/gsd mcp [status|check <server>]`.
+ * Handle `/gsd mcp [status|check <server>|discover [server]|...]`.
  */
 export async function handleMcpStatus(
   args: string,
@@ -200,6 +290,28 @@ export async function handleMcpStatus(
     return;
   }
 
+  // /gsd mcp discover [server]
+  if (lowered === "discover" || lowered.startsWith("discover ")) {
+    const requestedServerName = trimmed.slice("discover".length).trim();
+    let serverName = requestedServerName;
+    if (!serverName) {
+      if (configs.length === 1) {
+        serverName = configs[0]!.name;
+      } else {
+        const available = configs.map((config) => config.name).join(", ") || "(none)";
+        ctx.ui.notify(
+          `Usage: /gsd mcp discover <server>\n\nAvailable: ${available}`,
+          "warning",
+        );
+        return;
+      }
+    }
+
+    const result = await testMcpServerConnection(serverName);
+    ctx.ui.notify(formatMcpDiscoveryResult(result), result.ok ? "info" : "warning");
+    return;
+  }
+
   // /gsd mcp test <server>
   if (lowered.startsWith("test ")) {
     const serverName = trimmed.slice("test ".length).trim();
@@ -304,33 +416,17 @@ export async function handleMcpStatus(
       return;
     }
 
-    // Try to get connection/tool info from the mcp-client module if available
-    let connected = false;
-    let toolNames: string[] = [];
-    let error: string | undefined;
-    try {
-      const mcpClient = await import("../mcp-client/index.js");
-      // Access the module's connection state if exported; fall back gracefully
-      const mod = mcpClient as Record<string, unknown>;
-      if (typeof mod.getConnectionStatus === "function") {
-        const status = (mod.getConnectionStatus as (name: string) => { connected: boolean; tools: string[]; error?: string })(serverName);
-        connected = status.connected;
-        toolNames = status.tools;
-        error = status.error;
-      }
-    } catch {
-      // mcp-client may not expose status helpers — that's fine
-    }
-    if (!connected && !error && hasHostMcpTool(systemPrompt, serverName)) connected = true;
+    const runtime = await resolveMcpRuntimeStatus(config, systemPrompt);
 
     ctx.ui.notify(
       formatMcpServerDetail({
         name: config.name,
         transport: config.transport,
-        connected,
-        toolCount: toolNames.length,
-        tools: toolNames,
-        error,
+        connected: runtime.connected,
+        available: runtime.available,
+        toolCount: runtime.tools.length,
+        tools: runtime.tools,
+        error: runtime.error,
         disabled: config.disabled,
         sourcePath: config.sourcePath,
         envWarnings: config.envWarnings,
@@ -342,39 +438,20 @@ export async function handleMcpStatus(
 
   // /gsd mcp or /gsd mcp status
   if (!lowered || lowered === "status") {
-    // Build status for each server
-    const statuses: McpServerStatus[] = [];
-
-    for (const config of configs) {
-      let connected = false;
-      let toolCount = 0;
-      let error: string | undefined;
-
-      try {
-        const mcpClient = await import("../mcp-client/index.js");
-        const mod = mcpClient as Record<string, unknown>;
-        if (typeof mod.getConnectionStatus === "function") {
-          const status = (mod.getConnectionStatus as (name: string) => { connected: boolean; tools: string[]; error?: string })(config.name);
-          connected = status.connected;
-          toolCount = status.tools.length;
-          error = status.error;
-        }
-      } catch {
-        // Fall back to unknown state
-      }
-      if (!connected && !error && hasHostMcpTool(systemPrompt, config.name)) connected = true;
-
-      statuses.push({
+    const statuses: McpServerStatus[] = await Promise.all(configs.map(async (config) => {
+      const runtime = await resolveMcpRuntimeStatus(config, systemPrompt);
+      return {
         name: config.name,
         transport: config.transport,
-        connected,
-        toolCount,
-        error,
+        connected: runtime.connected,
+        available: runtime.available,
+        toolCount: runtime.tools.length,
+        error: runtime.error,
         disabled: config.disabled,
         sourcePath: config.sourcePath,
         envWarnings: config.envWarnings,
-      });
-    }
+      };
+    }));
 
     const warningLines = [
       ...management.warnings,
@@ -389,9 +466,10 @@ export async function handleMcpStatus(
 
   // Unknown subcommand
   ctx.ui.notify(
-    "Usage: /gsd mcp [status|check <server>|test <server>|enable <server>|disable <server>|delete <server> --confirm|import <server> [as <name>]|init [dir]]\n\n" +
+    "Usage: /gsd mcp [status|check <server>|discover [server]|test <server>|enable <server>|disable <server>|delete <server> --confirm|import <server> [as <name>]|init [dir]]\n\n" +
     "  status           Show all MCP server statuses (default)\n" +
     "  check <server>   Detailed status for a specific server\n" +
+    "  discover [server] Connect and list tools for a server\n" +
     "  test <server>    Verify MCP handshake and tools/list\n" +
     "  enable <server>  Enable a local GSD-managed server\n" +
     "  disable <server> Disable a local GSD-managed server\n" +

package/src/resources/extensions/gsd/commands-prefs-wizard.ts

@@ -23,6 +23,9 @@ import {
 import { loadFile, saveFile, splitFrontmatter, parseFrontmatterMap } from "./files.js";
 import { runClaudeImportFlow } from "./claude-import.js";
 
+const DEFAULT_WIDGET_MODE = "small";
+const WIDGET_MODE_OPTIONS = [DEFAULT_WIDGET_MODE, "full", "min", "off"] as const;
+
 /** Extract body content after frontmatter closing delimiter, or null if none. */
 function extractBodyAfterFrontmatter(content: string): string | null {
   const closingIdx = content.indexOf("\n---", content.indexOf("---"));
@@ -1558,7 +1561,7 @@ async function configureAdvanced(ctx: ExtensionCommandContext, prefs: Record<str
     prefs.min_request_interval_ms = minRequestInterval;
   }
 
-  const widget = await promptEnum(ctx, "Auto-mode widget display", prefs.widget_mode, ["full", "small", "min", "off"], "full");
+  const widget = await promptEnum(ctx, "Auto-mode widget display", prefs.widget_mode, WIDGET_MODE_OPTIONS, DEFAULT_WIDGET_MODE);
   if (widget !== undefined) prefs.widget_mode = widget;
 
   const experimental = (prefs.experimental as Record<string, unknown> | undefined) ?? {};

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

@@ -238,7 +238,7 @@ export async function handleVerdict(
 
   if (effectiveVerdict === "needs-remediation") {
     ctx.ui.notify(
-      "Follow up with gsd_reassess_roadmap to add remediation slices, then re-run /gsd auto.",
+      "Follow up with /gsd dispatch reassess to add remediation slices, then re-run /gsd auto.",
       "info",
     );
   }

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

@@ -23,6 +23,8 @@ import {
   resolveAutoSupervisorConfig,
 } from "./preferences.js";
 
+const DEFAULT_WIDGET_MODE = "small";
+
 // ─── Data Collection ──────────────────────────────────────────────────────
 
 interface ConfigSection {
@@ -160,7 +162,7 @@ function collectConfigSections(): ConfigSection[] {
   if (prefs?.service_tier) toggleRows.push({ label: "service_tier", value: prefs.service_tier });
   if (prefs?.search_provider && prefs.search_provider !== "auto") toggleRows.push({ label: "search_provider", value: prefs.search_provider });
   if (prefs?.context_selection) toggleRows.push({ label: "context_selection", value: prefs.context_selection });
-  if (prefs?.widget_mode && prefs.widget_mode !== "full") toggleRows.push({ label: "widget_mode", value: prefs.widget_mode });
+  if (prefs?.widget_mode && prefs.widget_mode !== DEFAULT_WIDGET_MODE) toggleRows.push({ label: "widget_mode", value: prefs.widget_mode });
   if (prefs?.experimental?.rtk) toggleRows.push({ label: "experimental.rtk", value: "on" });
   if (toggleRows.length > 0) sections.push({ title: "Toggles", rows: toggleRows });
 

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

@@ -71,6 +71,14 @@ export class GSDDashboardOverlay {
   private refreshInFlight: Promise<void> | null = null;
   private disposed = false;
   private resizeHandler: (() => void) | null = null;
+  private cachedMetrics: {
+    totals: ReturnType<typeof getProjectTotals>;
+    promptStats: ReturnType<typeof getPromptSizeStats>;
+    phases: ReturnType<typeof aggregateByPhase>;
+    slices: ReturnType<typeof aggregateBySlice>;
+    models: ReturnType<typeof aggregateByModel>;
+  } | null = null;
+  private lastSeenUnitCount = -1;
 
   constructor(
     tui: { requestRender: () => void },
@@ -123,7 +131,8 @@ export class GSDDashboardOverlay {
     this.dashData = getAutoDashboardData();
     const nextIdentity = this.computeDashboardIdentity(this.dashData);
 
-    if (initial || nextIdentity !== this.loadedDashboardIdentity) {
+    const identityChanged = initial || nextIdentity !== this.loadedDashboardIdentity;
+    if (identityChanged) {
       const loaded = await this.loadData();
       if (this.disposed) return;
       if (loaded) {
@@ -135,7 +144,9 @@ export class GSDDashboardOverlay {
       this.loading = false;
     }
 
-    this.invalidate();
+    if (identityChanged) {
+      this.invalidate();
+    }
     this.tui.requestRender();
   }
 
@@ -459,7 +470,7 @@ export class GSDDashboardOverlay {
 
     const ledger = getLedger();
     if (ledger && ledger.units.length > 0) {
-      const totals = getProjectTotals(ledger.units);
+      const { totals, promptStats, phases, slices, models } = this.ensureMetricsCache(ledger.units);
 
       lines.push(blank());
       lines.push(hr());
@@ -496,7 +507,6 @@ export class GSDDashboardOverlay {
         lines.push(row(budgetParts.join(`  ${th.fg("dim", "·")}  `)));
       }
 
-      const promptStats = getPromptSizeStats(ledger.units);
       if (promptStats) {
         const promptParts = [
           `${th.fg("dim", "avg prompt:")} ${th.fg("text", formatCharCount(promptStats.averagePromptChars))}`,
@@ -508,7 +518,6 @@ export class GSDDashboardOverlay {
         lines.push(row(promptParts.join(`  ${th.fg("dim", "·")}  `)));
       }
 
-      const phases = aggregateByPhase(ledger.units);
       if (phases.length > 0) {
         lines.push(blank());
         lines.push(row(th.fg("dim", "By Phase")));
@@ -520,7 +529,6 @@ export class GSDDashboardOverlay {
         }
       }
 
-      const slices = aggregateBySlice(ledger.units);
       if (slices.length > 0) {
         lines.push(blank());
         lines.push(row(th.fg("dim", "By Slice")));
@@ -551,7 +559,6 @@ export class GSDDashboardOverlay {
         }
       }
 
-      const models = aggregateByModel(ledger.units);
       if (models.length >= 1) {
         lines.push(blank());
         lines.push(row(th.fg("dim", "By Model")));
@@ -625,6 +632,20 @@ export class GSDDashboardOverlay {
     return `${th.fg("dim", labelText)}${" ".repeat(gap)}${bar}${" ".repeat(gap)}${th.fg("dim", rightText)}`;
   }
 
+  private ensureMetricsCache(units: UnitMetrics[]) {
+    if (!this.cachedMetrics || units.length !== this.lastSeenUnitCount) {
+      this.cachedMetrics = {
+        totals: getProjectTotals(units),
+        promptStats: getPromptSizeStats(units),
+        phases: aggregateByPhase(units),
+        slices: aggregateBySlice(units),
+        models: aggregateByModel(units),
+      };
+      this.lastSeenUnitCount = units.length;
+    }
+    return this.cachedMetrics!;
+  }
+
   invalidate(): void {
     this.cachedWidth = undefined;
     this.cachedLines = undefined;