@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/compat/compat-marker.ts

@@ -0,0 +1,210 @@
+// Project/App: gsd-pi
+// File Purpose: gsd-core ↔ gsd-pi compatibility marker (`.gsd/.compat.json`).
+//
+// Records per-projection content hashes so the ADR-017 reconcile pipeline can
+// distinguish gsd-pi's own writes (expected) from external edits made by gsd-core
+// (drift to import). gsd-core is oblivious to this file and ignores it.
+
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+/** Current marker schema version. Bump on breaking format changes + migrate. */
+export const COMPAT_MARKER_SCHEMA = 2;
+
+/**
+ * Which `.planning/` layout a project uses. Captured on first read so the
+ * round-trip writer recreates the same structure gsd-core wrote. Priority
+ * matches migrate/transformer.ts transformToGSD.
+ */
+export type PlanningLayout = "flat-phases" | "multi-milestone" | "legacy-milestone-dir";
+
+/**
+ * `.planning/` projection tracking. `projections` are modeled files (roadmap,
+ * plans, summaries, state) that get re-imported on drift; `passthrough` are
+ * un-modeled docs (DISCUSSION-LOG, PATTERNS, REVIEWS, codebase/) that get sha-
+ * refreshed only — content never re-rendered.
+ */
+export interface PlanningMarker {
+  active: boolean;
+  layout: PlanningLayout | null;
+  projections: Record<string, ProjectionEntry>;
+  passthrough: Record<string, ProjectionEntry>;
+}
+
+/**
+ * Per-file projection entry. `sha` is a normalized-content SHA-256; `entities`
+ * is the list of DB entity ids (milestone/slice/task) that the file projects,
+ * so repair can scope re-import rather than re-importing the whole tree.
+ */
+export interface ProjectionEntry {
+  sha: string;
+  entities: string[];
+}
+
+export interface CompatMarker {
+  schema: number;
+  lastWriter: "gsd-pi";
+  lastProjectedAt: string;
+  projections: Record<string, ProjectionEntry>;
+  /** Optional: `.planning/` layout tracking for gsd-core parity. */
+  planning?: PlanningMarker;
+  piVersion: string;
+}
+
+/** Marker returned when no marker exists yet (fresh project, first gsd-pi run). */
+export const EMPTY_MARKER: CompatMarker = {
+  schema: COMPAT_MARKER_SCHEMA,
+  lastWriter: "gsd-pi",
+  lastProjectedAt: "",
+  projections: {},
+  planning: { active: false, layout: null, projections: {}, passthrough: {} },
+  piVersion: "",
+};
+
+export function compatMarkerPath(basePath: string): string {
+  return join(basePath, ".gsd", ".compat.json");
+}
+
+/**
+ * Normalize markdown content before hashing so cosmetic differences (trailing
+ * whitespace, CRLF) don't produce false-positive drift. Conservative: only
+ * transforms that are provably round-trippable through gsd-pi's projection.
+ */
+export function normalizeForHash(content: string): string {
+  return content.replace(/\r\n/g, "\n").replace(/[ \t]+\n/g, "\n");
+}
+
+export function computeProjectionSha(content: string): string {
+  return createHash("sha256").update(normalizeForHash(content)).digest("hex").slice(0, 16);
+}
+
+/**
+ * Read & validate the marker. A missing marker → EMPTY_MARKER (treat every
+ * projection as external on next reconcile). A malformed marker is quarantined
+ * to `.compat.json.bad-<ts>` (never overwrite without backup) then returns
+ * EMPTY_MARKER. A schema-mismatch returns EMPTY_MARKER (forward-compat: refuse
+ * to act on a future format we don't understand).
+ */
+export function readCompatMarker(basePath: string): CompatMarker {
+  const path = compatMarkerPath(basePath);
+  if (!existsSync(path)) return emptyMarker();
+
+  let raw: string;
+  try {
+    raw = readFileSync(path, "utf-8");
+  } catch {
+    return emptyMarker();
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    quarantine(basePath, raw);
+    return emptyMarker();
+  }
+
+  if (!isValidMarker(parsed)) {
+    quarantine(basePath, raw);
+    return emptyMarker();
+  }
+  // Promote older markers by defaulting absent fields. Schema 1 → 2 only adds
+  // the optional `planning` field; treat its absence as planning-inactive so
+  // existing PR #802 users upgrade transparently. (A future schema 3 would
+  // need an explicit migration here; for now anything that passes isValidMarker
+  // is safe to read.)
+  if (!parsed.planning) {
+    parsed.planning = { active: false, layout: null, projections: {}, passthrough: {} };
+  }
+  return parsed;
+}
+
+/**
+ * Fresh deep copy of EMPTY_MARKER. Callers mutate the returned `projections`
+ * object (e.g. repair refreshes an entry), so a shallow copy would share the
+ * reference and pollute the module constant across calls. Always deep-copy.
+ */
+function emptyMarker(): CompatMarker {
+  return {
+    schema: EMPTY_MARKER.schema,
+    lastWriter: EMPTY_MARKER.lastWriter,
+    lastProjectedAt: EMPTY_MARKER.lastProjectedAt,
+    projections: {},
+    planning: { active: false, layout: null, projections: {}, passthrough: {} },
+    piVersion: EMPTY_MARKER.piVersion,
+  };
+}
+
+/**
+ * Write the marker atomically (write-temp then rename) so a crash mid-write
+ * can't leave a half-written file that next startup would quarantine.
+ */
+export function writeCompatMarker(basePath: string, marker: CompatMarker): void {
+  const path = compatMarkerPath(basePath);
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.tmp-${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(marker, null, 2), "utf-8");
+  renameSync(tmp, path);
+}
+
+function quarantine(basePath: string, raw: string): void {
+  const path = compatMarkerPath(basePath);
+  const badPath = `${path}.bad-${Date.now()}`;
+  try {
+    mkdirSync(dirname(badPath), { recursive: true });
+    try {
+      renameSync(path, badPath);
+    } catch {
+      writeFileSync(badPath, raw, "utf-8");
+      unlinkSync(path);
+    }
+  } catch {
+    // Best-effort: if we can't quarantine, leave the original in place — next
+    // read will quarantine. Never throw out of marker I/O.
+  }
+}
+
+function isValidProjectionEntry(x: unknown): x is ProjectionEntry {
+  if (typeof x !== "object" || x === null) return false;
+  const e = x as Record<string, unknown>;
+  if (typeof e.sha !== "string") return false;
+  if (!Array.isArray(e.entities) || !e.entities.every((s) => typeof s === "string")) return false;
+  return true;
+}
+
+function isValidProjectionMap(x: unknown): boolean {
+  if (typeof x !== "object" || x === null) return false;
+  for (const v of Object.values(x as Record<string, unknown>)) {
+    if (!isValidProjectionEntry(v)) return false;
+  }
+  return true;
+}
+
+function isValidPlanningMarker(x: unknown): x is PlanningMarker {
+  if (typeof x !== "object" || x === null) return false;
+  const p = x as Record<string, unknown>;
+  if (typeof p.active !== "boolean") return false;
+  if (
+    p.layout !== null &&
+    !["flat-phases", "multi-milestone", "legacy-milestone-dir"].includes(p.layout as string)
+  ) {
+    return false;
+  }
+  if (!isValidProjectionMap(p.projections)) return false;
+  if (!isValidProjectionMap(p.passthrough)) return false;
+  return true;
+}
+
+function isValidMarker(x: unknown): x is CompatMarker {
+  if (typeof x !== "object" || x === null) return false;
+  const m = x as Record<string, unknown>;
+  if (m.lastWriter !== "gsd-pi") return false;
+  if (typeof m.schema !== "number") return false;
+  if (typeof m.lastProjectedAt !== "string") return false;
+  if (typeof m.piVersion !== "string") return false;
+  if (!isValidProjectionMap(m.projections)) return false;
+  // planning is optional; when present, must validate.
+  if (m.planning !== undefined && !isValidPlanningMarker(m.planning)) return false;
+  return true;
+}

package/src/resources/extensions/gsd/compat/index.ts

@@ -0,0 +1,12 @@
+// Project/App: gsd-pi
+// File Purpose: Public exports for the gsd-core compat module.
+export {
+  COMPAT_MARKER_SCHEMA,
+  EMPTY_MARKER,
+  compatMarkerPath,
+  computeProjectionSha,
+  normalizeForHash,
+  readCompatMarker,
+  writeCompatMarker,
+} from "./compat-marker.js";
+export type { CompatMarker, PlanningLayout, PlanningMarker, ProjectionEntry } from "./compat-marker.js";

package/src/resources/extensions/gsd/compat/planning-compat.ts

@@ -0,0 +1,168 @@
+// Project/App: gsd-pi
+// File Purpose: `.planning/` compat helpers — layout capture and projection sha
+// recording. Parallel to the .gsd/ write-time flush in markdown-renderer.ts.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+import {
+  computeProjectionSha,
+  readCompatMarker,
+  writeCompatMarker,
+  type PlanningLayout,
+} from "./compat-marker.js";
+import { logWarning } from "../workflow-logger.js";
+
+export interface PlanningProjectionWrite {
+  relPath: string;
+  entities: string[];
+  passthrough?: boolean;
+}
+
+export function isPlanningPassthroughRelPath(relPath: string): boolean {
+  if (relPath.startsWith("codebase/") || relPath.startsWith("research/")) return true;
+  if (relPath === "config.json") return true;
+  const name = relPath.split("/").pop() ?? relPath;
+  if (name === "PATTERNS.md" || name === "REVIEWS.md") return true;
+  if (name.endsWith("-DISCUSSION-LOG.md")) return true;
+  if (name.endsWith("-RESEARCH.md") && !name.endsWith("-PLAN.md")) return true;
+  return false;
+}
+
+// Files that gsd-pi creates in .gsd/ at startup and that do not constitute
+// markdown content written by gsd-core. Excluded from the content check so a
+// .planning/-only project that already has a gsd.db (but no milestone markdown)
+// is not mistakenly treated as a coexistence project.
+const KNOWN_NON_CONTENT_FILES = new Set([
+  "gsd.db",
+  "gsd.db-wal",
+  "gsd.db-shm",
+  "completed-units.json",
+]);
+
+export function gsdTreeHasContent(basePath: string): boolean {
+  const gsdDir = join(basePath, ".gsd");
+  return (
+    existsSync(gsdDir) &&
+    readdirSync(gsdDir).some(
+      (name) => !name.startsWith(".") && !KNOWN_NON_CONTENT_FILES.has(name),
+    )
+  );
+}
+
+export function walkPlanningRelPaths(planningDir: string, prefix = ""): string[] {
+  const paths: string[] = [];
+  let entries;
+  try {
+    entries = readdirSync(join(planningDir, prefix), { withFileTypes: true });
+  } catch {
+    return paths;
+  }
+  for (const entry of entries) {
+    const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) {
+      if (entry.name === "workstreams") continue;
+      paths.push(...walkPlanningRelPaths(planningDir, rel));
+    } else {
+      paths.push(rel);
+    }
+  }
+  return paths;
+}
+
+/**
+ * Record freshly written `.planning/` projection files in the compat marker.
+ */
+export function applyPlanningProjectionWrites(
+  basePath: string,
+  writes: PlanningProjectionWrite[],
+): void {
+  if (writes.length === 0) return;
+  const marker = readCompatMarker(basePath);
+  if (!marker.planning) {
+    marker.planning = { active: true, layout: null, projections: {}, passthrough: {} };
+  }
+  marker.planning.active = true;
+  for (const write of writes) {
+    const abs = join(basePath, ".planning", write.relPath);
+    if (!existsSync(abs)) continue;
+    const entry = {
+      sha: computeProjectionSha(readFileSync(abs, "utf-8")),
+      entities: write.entities,
+    };
+    const map = write.passthrough ? marker.planning.passthrough : marker.planning.projections;
+    map[write.relPath] = entry;
+  }
+  marker.lastWriter = "gsd-pi";
+  marker.lastProjectedAt = new Date().toISOString();
+  writeCompatMarker(basePath, marker);
+}
+
+export interface CapturePlanningCompatOptions {
+  dryRun?: boolean;
+}
+
+/**
+ * Capture-on-first-read: infer `.planning/` layout from disk, import content
+ * into the DB so gsd-pi's projection reflects gsd-core's tree instead of
+ * overwriting it, then activate the compat marker. Projection shas are seeded
+ * by drift repair / write-time hooks — not from raw disk here.
+ *
+ * Must only be called when !dryRun — it writes both the DB and the marker.
+ */
+export async function capturePlanningCompatIfNeeded(
+  basePath: string,
+  options?: CapturePlanningCompatOptions,
+): Promise<void> {
+  if (options?.dryRun) return;
+
+  const planningDir = join(basePath, ".planning");
+  if (!existsSync(planningDir)) return;
+
+  const marker = readCompatMarker(basePath);
+  if (marker.planning?.active && marker.planning.layout) return;
+
+  // First encounter: parse layout, import content into the DB, then activate the
+  // marker. When `.gsd/` already exists (coexistence), import from disk via
+  // migrateHierarchyToDb and do not call writeGSDDirectory — reconcile runs
+  // external-markdown-edit before external-planning-edit and must not destroy
+  // gsd-core `.gsd/` edits before that pipeline can see them. Planning-only
+  // projects materialize `.gsd/` from the parsed tree first, then import.
+  const { parsePlanningDirectory } = await import("../migrate/parser.js");
+  const { detectPlanningLayout } = await import("../migrate/layout-detect.js");
+  const parsed = await parsePlanningDirectory(planningDir);
+  const layout: PlanningLayout | null = detectPlanningLayout(parsed);
+  if (!layout) return;
+
+  // Import into the DB. Dynamic imports break the module-init cycle
+  // (planning-compat ← reconcile ← state ← md-importer). Matches the import
+  // pattern in repairExternalPlanningEdit.
+  try {
+    const { migrateHierarchyToDb } = await import("../md-importer.js");
+    const { invalidateStateCache } = await import("../state.js");
+    if (!gsdTreeHasContent(basePath)) {
+      const { transformToGSD } = await import("../migrate/transformer.js");
+      const { writeGSDDirectory } = await import("../migrate/writer.js");
+      const gsdProject = transformToGSD(parsed);
+      await writeGSDDirectory(gsdProject, basePath);
+    }
+    migrateHierarchyToDb(basePath);
+    invalidateStateCache();
+  } catch (e) {
+    logWarning(
+      "reconcile",
+      `planning DB import failed on initial capture — reconcile may overwrite gsd-core content: ${(e as Error).message}`,
+    );
+  }
+
+  // Activate the marker. Leave projections/passthrough empty: the next
+  // writePlanningDirectory → applyPlanningProjectionWrites call will seed
+  // accurate SHAs from the normalized output rather than the raw gsd-core files.
+  const freshMarker = readCompatMarker(basePath);
+  if (!freshMarker.planning) {
+    freshMarker.planning = { active: false, layout: null, projections: {}, passthrough: {} };
+  }
+  freshMarker.planning.active = true;
+  freshMarker.planning.layout = layout;
+  writeCompatMarker(basePath, freshMarker);
+}

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

@@ -35,6 +35,7 @@ interface ConfigSection {
 export interface CollectConfigOptions {
   basePath?: string;
   availableModelIds?: string[];
+  preferredModelId?: string;
 }
 
 function collectConfigSections(options?: CollectConfigOptions): ConfigSection[] {
@@ -43,7 +44,7 @@ function collectConfigSections(options?: CollectConfigOptions): ConfigSection[]
   const globalPrefs = loadGlobalGSDPreferences();
   const projectPrefs = loadProjectGSDPreferences(options?.basePath);
   const loadOpts = options?.availableModelIds
-    ? { availableModelIds: options.availableModelIds }
+    ? { availableModelIds: options.availableModelIds, preferredModelId: options.preferredModelId }
     : undefined;
   const effective = loadEffectiveGSDPreferences(options?.basePath, loadOpts);
   const prefs = effective?.preferences;
@@ -81,6 +82,7 @@ function collectConfigSections(options?: CollectConfigOptions): ConfigSection[]
       unitType,
       options?.basePath,
       options?.availableModelIds,
+      options?.preferredModelId,
     );
     if (resolved) {
       let val = resolved.primary;

package/src/resources/extensions/gsd/consent-question.ts

@@ -44,7 +44,7 @@ export type GateSubKind = "depth-verification" | "approval" | "destructive-confi
 
 export type FailPolicy = "closed" | "open";
 
-export type AnswerOutcome = "waiting" | "answered" | "verified" | "declined" | "cancelled";
+export type AnswerOutcome = "waiting" | "answered" | "verified" | "declined" | "cancelled" | "timeout";
 
 export interface ClassifiedQuestion {
   kind: QuestionKind;
@@ -234,6 +234,9 @@ export type ConsentAnswerDetails = VerdictAnswerDetails;
 /**
  * THE single policy point for whether a question's answer counts as answered.
  *
+ * - timed_out rounds → "timeout" for every kind (host elicitation expired
+ *   before the user answered; fail-closed, but the caller pauses-and-waits
+ *   instead of re-asking into the same timeout loop, #852).
  * - cancelled rounds → "cancelled" for every kind.
  * - gate: delegates to evaluateGateAnswer in the consent-verdict leaf — the
  *   same verdict engine write-gate's applyAskUserQuestionsGateResult consumes;
@@ -248,6 +251,7 @@ export function evaluateAnswer(options: {
   details: ConsentAnswerDetails;
 }): AnswerOutcome {
   const { question, details } = options;
+  if (details.timed_out) return "timeout";
   if (details.cancelled) return "cancelled";
 
   const { kind } = classifyQuestion({ id: question.id, options: question.options });
@@ -271,6 +275,7 @@ export function evaluateAnswer(options: {
 
 const OUTCOME_PRECEDENCE: AnswerOutcome[] = [
   "cancelled",
+  "timeout",
   "waiting",
   "declined",
   "verified",
@@ -289,6 +294,11 @@ export function evaluateAskUserQuestionsRound(
   questions: ConsentQuestionShape[],
   details: ConsentAnswerDetails,
 ): AnswerOutcome {
+  // timed_out is checked before cancelled: a host elicitation timeout is a
+  // more specific signal than the deliberate-dismissal cancelled it is also
+  // marked with, and callers must pause-and-wait instead of treating it as a
+  // re-ask-able cancel (#852).
+  if (details.timed_out) return "timeout";
   if (details.cancelled) return "cancelled";
   let worst: AnswerOutcome = "answered";
   for (const question of questions) {

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

@@ -9,7 +9,20 @@
  * cycle. It must not import from either module (ADR-039).
  */
 
-export type GateAnswerVerdict = "waiting" | "verified" | "declined" | "cancelled";
+/**
+ * Per-question verdict for a gate answer.
+ *
+ *   - "verified" — the confirmation option was selected (depth unlocked).
+ *   - "declined" — a real but non-confirming selection (gate stays pending,
+ *     model should not treat as approval).
+ *   - "cancelled" — the round was cancelled by the user (deliberate dismissal).
+ *   - "waiting" — no answer (fail-closed; not an answer).
+ *   - "timeout" — the host elicitation timed out before the user answered.
+ *     Distinct from "waiting" so callers can pause-and-wait instead of letting
+ *     the model re-ask into the same timeout loop (#852). Still fail-closed:
+ *     the gate stays pending — a timeout is never approval.
+ */
+export type GateAnswerVerdict = "waiting" | "verified" | "declined" | "cancelled" | "timeout";
 
 export interface VerdictQuestionShape {
   id?: unknown;
@@ -19,6 +32,13 @@ export interface VerdictQuestionShape {
 export interface VerdictAnswerDetails {
   cancelled?: boolean;
   interrupted?: boolean;
+  /**
+   * True when the host elicitation channel timed out before the user answered.
+   * Distinct from `cancelled` (deliberate dismissal): a timeout must not be
+   * laundered into a re-ask loop. Gate verdicts map this to "timeout" so the
+   * caller pauses-and-waits instead of looping on the blocked call (#852).
+   */
+  timed_out?: boolean;
   response?: {
     answers?: Record<string, { selected?: unknown; notes?: unknown } | undefined>;
   } | null;
@@ -67,16 +87,25 @@ export function hasNotesValue(notes: unknown): boolean {
 /**
  * THE per-question verdict for gate questions (fail-closed):
  *
+ * - timed_out rounds → "timeout" (host elicitation expired before the user
+ *   answered; fail-closed — the gate stays pending — but the caller pauses
+ *   instead of re-asking into the same timeout loop, #852).
  * - cancelled rounds → "cancelled".
  * - the confirmation option (structural match) → "verified".
  * - any other real selection → "declined".
  * - empty/missing selection → "waiting" — an empty answer is NEVER an answer,
  *   so notes can never satisfy a gate either.
+ *
+ * `timed_out` is checked first: the handler marks a timed-out round with both
+ * `cancelled: true` and `timed_out: true` (see
+ * `askUserQuestionsHandler`), so the timeout must win to avoid the cancelled
+ * branch's re-ask semantics.
  */
 export function evaluateGateAnswer(
   question: VerdictQuestionShape,
   details: VerdictAnswerDetails,
 ): GateAnswerVerdict {
+  if (details.timed_out) return "timeout";
   if (details.cancelled) return "cancelled";
   const questionId = typeof question.id === "string" ? question.id : "";
   const answer = details.response?.answers?.[questionId];

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

@@ -15,6 +15,7 @@ import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { resolveMilestoneFile, resolveSliceFile } from "./paths.js";
 import { getAutoDashboardData } from "./auto.js";
 import type { AutoDashboardData } from "./auto-dashboard.js";
+import { getAutoRuntimeSnapshot } from "./auto-runtime-state.js";
 import {
   getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice,
   aggregateByModel, aggregateCacheHitRate, formatCost, formatTokenCount, formatCostProjection,
@@ -22,12 +23,13 @@ import {
   type UnitMetrics,
 } from "./metrics.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { countPendingCaptures } from "./captures.js";
 import { getActiveWorktreeName } from "./worktree-session-state.js";
 import { getWorkerBatches, hasActiveWorkers, type WorkerEntry } from "../subagent/worker-registry.js";
 import { formatDuration, padRight, joinColumns, centerLine, fitColumns, STATUS_GLYPH, STATUS_COLOR } from "../shared/mod.js";
 import { estimateTimeRemaining } from "./auto-dashboard.js";
 import { computeProgressScore, formatProgressLine } from "./progress-score.js";
-import { runEnvironmentChecks, type EnvironmentCheckResult } from "./doctor-environment.js";
+import { runEnvironmentChecksAsync, type EnvironmentCheckResult } from "./doctor-environment.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 
@@ -69,6 +71,9 @@ export class GSDDashboardOverlay {
   private loading = true;
   private loadedDashboardIdentity?: string;
   private refreshInFlight: Promise<void> | null = null;
+  private envRefreshInFlight: Promise<void> | null = null;
+  private cachedEnvBasePath?: string;
+  private cachedEnvIssues: EnvironmentCheckResult[] = [];
   private disposed = false;
   private resizeHandler: (() => void) | null = null;
   private cachedMetrics: {
@@ -113,7 +118,9 @@ export class GSDDashboardOverlay {
       });
   }
 
-  private computeDashboardIdentity(dashData: AutoDashboardData): string {
+  private computeDashboardIdentity(
+    dashData: Pick<AutoDashboardData, "active" | "paused" | "currentUnit" | "basePath">,
+  ): string {
     const base = dashData.basePath || process.cwd();
     const currentUnit = dashData.currentUnit
       ? `${dashData.currentUnit.type}:${dashData.currentUnit.id}:${dashData.currentUnit.startedAt}`
@@ -126,30 +133,90 @@ export class GSDDashboardOverlay {
     ].join("|");
   }
 
+  private refreshVolatileDashboardData(snapshot = getAutoRuntimeSnapshot()): void {
+    let pendingCaptureCount = this.dashData.pendingCaptureCount;
+    try {
+      if (snapshot.basePath) {
+        pendingCaptureCount = countPendingCaptures(snapshot.basePath);
+      }
+    } catch {
+      // Non-fatal — keep last known value
+    }
+    this.dashData = {
+      ...this.dashData,
+      active: snapshot.active,
+      paused: snapshot.paused,
+      currentUnit: snapshot.currentUnit
+        ? {
+            type: snapshot.currentUnit.type,
+            id: snapshot.currentUnit.id,
+            startedAt: snapshot.currentUnit.startedAt,
+          }
+        : null,
+      basePath: snapshot.basePath,
+      elapsed: snapshot.active || snapshot.paused
+        ? (this.dashData.startTime > 0 ? Date.now() - this.dashData.startTime : 0)
+        : 0,
+      toolSurface: snapshot.toolSurface,
+      pendingCaptureCount,
+    };
+  }
+
   private async refreshDashboard(initial = false): Promise<void> {
     if (this.disposed) return;
-    this.dashData = getAutoDashboardData();
-    const nextIdentity = this.computeDashboardIdentity(this.dashData);
+    const runtimeSnapshot = getAutoRuntimeSnapshot();
+    const nextIdentity = this.computeDashboardIdentity(runtimeSnapshot);
 
     const identityChanged = initial || nextIdentity !== this.loadedDashboardIdentity;
     if (identityChanged) {
+      this.dashData = getAutoDashboardData();
+      const loadedIdentity = this.computeDashboardIdentity(this.dashData);
       const loaded = await this.loadData();
       if (this.disposed) return;
       if (loaded) {
-        this.loadedDashboardIdentity = nextIdentity;
+        this.loadedDashboardIdentity = loadedIdentity;
       }
+    } else {
+      this.refreshVolatileDashboardData(runtimeSnapshot);
     }
 
     if (initial) {
       this.loading = false;
     }
 
+    this.scheduleEnvironmentRefresh(this.dashData.basePath || process.cwd());
+
     if (identityChanged) {
       this.invalidate();
     }
     this.tui.requestRender();
   }
 
+  private scheduleEnvironmentRefresh(basePath: string): void {
+    if (this.cachedEnvBasePath !== basePath) {
+      this.cachedEnvBasePath = basePath;
+      this.cachedEnvIssues = [];
+      this.invalidate();
+    }
+    if (this.envRefreshInFlight || this.disposed) return;
+    this.envRefreshInFlight = this.refreshEnvironmentHealth(basePath)
+      .finally(() => {
+        this.envRefreshInFlight = null;
+      });
+  }
+
+  private async refreshEnvironmentHealth(basePath: string): Promise<void> {
+    try {
+      const envResults = await runEnvironmentChecksAsync(basePath);
+      if (this.disposed || this.cachedEnvBasePath !== basePath) return;
+      this.cachedEnvIssues = envResults.filter(r => r.status !== "ok");
+      this.invalidate();
+      this.tui.requestRender();
+    } catch {
+      // Non-fatal — keep last known environment issues
+    }
+  }
+
   private async loadData(): Promise<boolean> {
     const base = this.dashData.basePath || process.cwd();
     try {
@@ -592,8 +659,7 @@ export class GSDDashboardOverlay {
     }
 
     // Environment health section (#1221) — only show issues
-    const envResults = runEnvironmentChecks(this.dashData.basePath || process.cwd());
-    const envIssues = envResults.filter(r => r.status !== "ok");
+    const envIssues = this.cachedEnvIssues;
     if (envIssues.length > 0) {
       lines.push(blank());
       lines.push(hr());