gsd-pi 2.26.1-next.1 → 2.28.0-dev.346ee62

package/src/resources/extensions/gsd/constants.ts

@@ -0,0 +1,21 @@
+/**
+ * GSD Extension — Shared Constants
+ *
+ * Centralized timeout and cache-size constants used across the GSD extension.
+ */
+
+// ─── Timeouts ─────────────────────────────────────────────────────────────────
+
+/** Default timeout for verification-gate commands (ms). */
+export const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
+
+/** Default timeout for the dynamic bash tool (seconds). */
+export const DEFAULT_BASH_TIMEOUT_SECS = 120;
+
+// ─── Cache Sizes ──────────────────────────────────────────────────────────────
+
+/** Max directory-listing cache entries before eviction (#611). */
+export const DIR_CACHE_MAX = 200;
+
+/** Max parse-cache entries before eviction. */
+export const CACHE_MAX = 50;

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

@@ -8,6 +8,9 @@
  * @see D001 (module location), D002 (200K fallback), D003 (section-boundary truncation)
  */
 
+import { type TokenProvider, getCharsPerToken } from "./token-counter.js";
+import { compressToTarget } from "./prompt-compressor.js";
+
 // ─── Budget ratio constants ──────────────────────────────────────────────────
 // Percentages of total context window allocated to each budget category.
 // These are applied after tokens→chars conversion.
@@ -93,9 +96,10 @@ export interface MinimalPreferences {
  * Returns deterministic output for any given input. Invalid inputs (≤ 0)
  * silently default to 200K (D002).
  */
-export function computeBudgets(contextWindow: number): BudgetAllocation {
+export function computeBudgets(contextWindow: number, provider?: TokenProvider): BudgetAllocation {
   const effectiveWindow = contextWindow > 0 ? contextWindow : DEFAULT_CONTEXT_WINDOW;
-  const totalChars = effectiveWindow * CHARS_PER_TOKEN;
+  const charsPerToken = provider ? getCharsPerToken(provider) : CHARS_PER_TOKEN;
+  const totalChars = effectiveWindow * charsPerToken;
 
   return {
     summaryBudgetChars: Math.floor(totalChars * SUMMARY_RATIO),
@@ -197,6 +201,25 @@ export function resolveExecutorContextWindow(
   return DEFAULT_CONTEXT_WINDOW;
 }
 
+/**
+ * Smart context reduction: compress first, then truncate if still over budget.
+ * Returns the content within budget with maximum information preservation.
+ */
+export function reduceToFit(content: string, budgetChars: number): TruncationResult {
+  if (!content || content.length <= budgetChars) {
+    return { content, droppedSections: 0 };
+  }
+
+  // Step 1: Try compression
+  const compressed = compressToTarget(content, budgetChars);
+  if (compressed.compressedChars <= budgetChars) {
+    return { content: compressed.content, droppedSections: 0 };
+  }
+
+  // Step 2: Truncate the compressed content at section boundaries
+  return truncateAtSectionBoundary(compressed.content, budgetChars);
+}
+
 // ─── Internal helpers ────────────────────────────────────────────────────────
 
 /**

package/src/resources/extensions/gsd/crash-recovery.ts

@@ -10,9 +10,10 @@
  * so the file on disk reflects every tool call up to the crash point).
  */
 
-import { writeFileSync, readFileSync, unlinkSync, existsSync } from "node:fs";
+import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
+import { atomicWriteSync } from "./atomic-write.js";
 
 const LOCK_FILE = "auto.lock";
 
@@ -49,7 +50,8 @@ export function writeLock(
       completedUnits,
       sessionFile,
     };
-    writeFileSync(lockPath(basePath), JSON.stringify(data, null, 2), "utf-8");
+    const lp = lockPath(basePath);
+    atomicWriteSync(lp, JSON.stringify(data, null, 2));
   } catch (e) { /* non-fatal: lock write failure */ void e; }
 }
 

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

@@ -14,23 +14,14 @@ import { resolveMilestoneFile, resolveSliceFile } from "./paths.js";
 import { getAutoDashboardData, type AutoDashboardData } from "./auto.js";
 import {
   getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice,
-  aggregateByModel, formatCost, formatTokenCount, formatCostProjection,
+  aggregateByModel, aggregateCacheHitRate, formatCost, formatTokenCount, formatCostProjection,
   type UnitMetrics,
 } from "./metrics.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { getActiveWorktreeName } from "./worktree-command.js";
 import { getWorkerBatches, hasActiveWorkers, type WorkerEntry } from "../subagent/worker-registry.js";
-
-function formatDuration(ms: number): string {
-  const s = Math.floor(ms / 1000);
-  if (s < 60) return `${s}s`;
-  const m = Math.floor(s / 60);
-  const rs = s % 60;
-  if (m < 60) return `${m}m ${rs}s`;
-  const h = Math.floor(m / 60);
-  const rm = m % 60;
-  return `${h}h ${rm}m`;
-}
+import { formatDuration, padRight, joinColumns, centerLine, fitColumns, STATUS_GLYPH, STATUS_COLOR } from "../shared/mod.js";
+import { estimateTimeRemaining } from "./auto-dashboard.js";
 
 function unitLabel(type: string): string {
   switch (type) {
@@ -48,38 +39,6 @@ function unitLabel(type: string): string {
   }
 }
 
-function centerLine(content: string, width: number): string {
-  const vis = visibleWidth(content);
-  if (vis >= width) return truncateToWidth(content, width);
-  const leftPad = Math.floor((width - vis) / 2);
-  return " ".repeat(leftPad) + content;
-}
-
-function padRight(content: string, width: number): string {
-  const vis = visibleWidth(content);
-  return content + " ".repeat(Math.max(0, width - vis));
-}
-
-function joinColumns(left: string, right: string, width: number): string {
-  const leftW = visibleWidth(left);
-  const rightW = visibleWidth(right);
-  if (leftW + rightW + 2 > width) {
-    return truncateToWidth(`${left}  ${right}`, width);
-  }
-  return left + " ".repeat(width - leftW - rightW) + right;
-}
-
-function fitColumns(parts: string[], width: number, separator = "  "): string {
-  const filtered = parts.filter(Boolean);
-  if (filtered.length === 0) return "";
-  let result = filtered[0];
-  for (let i = 1; i < filtered.length; i++) {
-    const candidate = `${result}${separator}${filtered[i]}`;
-    if (visibleWidth(candidate) > width) break;
-    result = candidate;
-  }
-  return truncateToWidth(result, width);
-}
 
 export class GSDDashboardOverlay {
   private tui: { requestRender: () => void };
@@ -95,6 +54,7 @@ export class GSDDashboardOverlay {
   private loadedDashboardIdentity?: string;
   private refreshInFlight: Promise<void> | null = null;
   private disposed = false;
+  private resizeHandler: (() => void) | null = null;
 
   constructor(
     tui: { requestRender: () => void },
@@ -106,6 +66,14 @@ export class GSDDashboardOverlay {
     this.onClose = onClose;
     this.dashData = getAutoDashboardData();
 
+    // Invalidate cache on terminal resize
+    this.resizeHandler = () => {
+      if (this.disposed) return;
+      this.invalidate();
+      this.tui.requestRender();
+    };
+    process.stdout.on("resize", this.resizeHandler);
+
     this.scheduleRefresh(true);
 
     this.refreshTimer = setInterval(() => {
@@ -233,7 +201,7 @@ export class GSDDashboardOverlay {
 
   handleInput(data: string): void {
     if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.ctrlAlt("g"))) {
-      clearInterval(this.refreshTimer);
+      this.dispose();
       this.onClose();
       return;
     }
@@ -332,12 +300,15 @@ export class GSDDashboardOverlay {
     const worktreeTag = worktreeName
       ? `  ${th.fg("warning", `⎇ ${worktreeName}`)}`
       : "";
-    const elapsed = this.dashData.active || this.dashData.paused
-      ? th.fg("dim", formatDuration(this.dashData.elapsed))
-      : isRemote
-        ? th.fg("dim", `since ${this.dashData.remoteSession!.startedAt.replace("T", " ").slice(0, 19)}`)
-        : "";
-    lines.push(row(joinColumns(`${title}  ${status}${worktreeTag}`, elapsed, contentWidth)));
+    let elapsedParts = "";
+    if (this.dashData.active || this.dashData.paused) {
+      elapsedParts = th.fg("dim", formatDuration(this.dashData.elapsed));
+      const eta = estimateTimeRemaining();
+      if (eta) elapsedParts += th.fg("dim", `  ·  ${eta}`);
+    } 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(blank());
 
     if (this.dashData.currentUnit) {
@@ -435,23 +406,19 @@ export class GSDDashboardOverlay {
       lines.push(blank());
 
       for (const s of mv.slices) {
-        const icon = s.done ? th.fg("success", "✓")
-          : s.active ? th.fg("accent", "▸")
-          : th.fg("dim", "○");
-        const titleText = s.active ? th.fg("accent", `${s.id}: ${s.title}`)
-          : s.done ? th.fg("muted", `${s.id}: ${s.title}`)
-          : th.fg("dim", `${s.id}: ${s.title}`);
+        const sliceStatus = s.done ? "done" : s.active ? "active" : "pending";
+        const icon = th.fg(STATUS_COLOR[sliceStatus], STATUS_GLYPH[sliceStatus]);
+        const titleColor = s.active ? "accent" : s.done ? "muted" : "dim";
+        const titleText = th.fg(titleColor, `${s.id}: ${s.title}`);
         const risk = th.fg("dim", s.risk);
         lines.push(row(joinColumns(`  ${icon} ${titleText}`, risk, contentWidth)));
 
         if (s.active && s.tasks.length > 0) {
           for (const t of s.tasks) {
-            const tIcon = t.done ? th.fg("success", "✓")
-              : t.active ? th.fg("warning", "▸")
-              : th.fg("dim", "·");
-            const tTitle = t.active ? th.fg("warning", `${t.id}: ${t.title}`)
-              : t.done ? th.fg("muted", `${t.id}: ${t.title}`)
-              : th.fg("dim", `${t.id}: ${t.title}`);
+            const taskStatus = t.done ? "done" : t.active ? "active" : "pending";
+            const tIcon = th.fg(STATUS_COLOR[taskStatus], STATUS_GLYPH[taskStatus]);
+            const tColor = t.active ? "warning" : t.done ? "muted" : "dim";
+            const tTitle = th.fg(tColor, `${t.id}: ${t.title}`);
             lines.push(row(`      ${tIcon} ${truncateToWidth(tTitle, contentWidth - 6)}`));
           }
         }
@@ -477,18 +444,21 @@ export class GSDDashboardOverlay {
 
       const recent = [...this.dashData.completedUnits].reverse().slice(0, 10);
       for (const u of recent) {
-        const left = `  ${th.fg("success", "✓")} ${th.fg("muted", unitLabel(u.type))} ${th.fg("muted", u.id)}`;
-
-        // Budget indicators from ledger
+        // Budget indicators from ledger — use warning glyph for pressured units
         const ledgerEntry = ledgerLookup.get(`${u.type}:${u.id}`);
+        const hadPressure = ledgerEntry?.continueHereFired === true;
+        const hadTruncation = (ledgerEntry?.truncationSections ?? 0) > 0;
+        const unitGlyph = hadPressure
+          ? th.fg(STATUS_COLOR.warning, STATUS_GLYPH.warning)
+          : th.fg(STATUS_COLOR.done, STATUS_GLYPH.done);
+        const left = `  ${unitGlyph} ${th.fg("muted", unitLabel(u.type))} ${th.fg("muted", u.id)}`;
+
         let budgetMarkers = "";
-        if (ledgerEntry) {
-          if (ledgerEntry.truncationSections && ledgerEntry.truncationSections > 0) {
-            budgetMarkers += th.fg("warning", ` ▼${ledgerEntry.truncationSections}`);
-          }
-          if (ledgerEntry.continueHereFired === true) {
-            budgetMarkers += th.fg("error", " → wrap-up");
-          }
+        if (hadTruncation) {
+          budgetMarkers += th.fg("warning", ` ▼${ledgerEntry!.truncationSections}`);
+        }
+        if (hadPressure) {
+          budgetMarkers += th.fg("error", " → wrap-up");
         }
 
         const right = th.fg("dim", formatDuration(u.finishedAt - u.startedAt));
@@ -509,8 +479,12 @@ export class GSDDashboardOverlay {
       lines.push(row(th.fg("text", th.bold("Cost & Usage"))));
       lines.push(blank());
 
+      // Show cost or request count (for copilot/subscription users where cost is 0)
+      const costOrReqs = totals.cost > 0
+        ? `${th.fg("warning", formatCost(totals.cost))} total`
+        : `${th.fg("text", String(totals.apiRequests))} requests`;
       lines.push(row(fitColumns([
-        `${th.fg("warning", formatCost(totals.cost))} total`,
+        costOrReqs,
         `${th.fg("text", formatTokenCount(totals.tokens.total))} tokens`,
         `${th.fg("text", String(totals.toolCalls))} tools`,
         `${th.fg("text", String(totals.units))} units`,
@@ -596,6 +570,12 @@ export class GSDDashboardOverlay {
 
       lines.push(blank());
       lines.push(row(`${th.fg("dim", "avg/unit:")} ${th.fg("text", formatCost(totals.cost / totals.units))}  ${th.fg("dim", "·")}  ${th.fg("text", formatTokenCount(Math.round(totals.tokens.total / totals.units)))} tokens`));
+
+      // Cache hit rate
+      const cacheRate = aggregateCacheHitRate();
+      if (cacheRate > 0) {
+        lines.push(row(`${th.fg("dim", "cache hit rate:")} ${th.fg("text", `${cacheRate}%`)}`));
+      }
     }
 
     lines.push(blank());
@@ -634,6 +614,10 @@ export class GSDDashboardOverlay {
   dispose(): void {
     this.disposed = true;
     clearInterval(this.refreshTimer);
+    if (this.resizeHandler) {
+      process.stdout.removeListener("resize", this.resizeHandler);
+      this.resizeHandler = null;
+    }
   }
 }
 

package/src/resources/extensions/gsd/db-writer.ts

@@ -12,6 +12,10 @@ import { join, resolve } from 'node:path';
 import type { Decision, Requirement } from './types.js';
 import { resolveGsdRootFile } from './paths.js';
 import { saveFile } from './files.js';
+import { GSDError, GSD_STALE_STATE, GSD_IO_ERROR } from './errors.js';
+import { invalidateStateCache } from './state.js';
+import { clearPathCache } from './paths.js';
+import { clearParseCache } from './files.js';
 
 // ─── Markdown Generators ──────────────────────────────────────────────────
 
@@ -225,6 +229,11 @@ export async function saveDecisionToDb(
     const md = generateDecisionsMd(allDecisions);
     const filePath = resolveGsdRootFile(basePath, 'DECISIONS');
     await saveFile(filePath, md);
+    // Invalidate file-read caches so deriveState() sees the updated markdown.
+    // Do NOT clear the artifacts table — we just wrote to it intentionally.
+    invalidateStateCache();
+    clearPathCache();
+    clearParseCache();
 
     return { id };
   } catch (err) {
@@ -249,7 +258,7 @@ export async function updateRequirementInDb(
 
     const existing = db.getRequirementById(id);
     if (!existing) {
-      throw new Error(`Requirement ${id} not found`);
+      throw new GSDError(GSD_STALE_STATE, `Requirement ${id} not found`);
     }
 
     // Merge updates into existing
@@ -289,6 +298,11 @@ export async function updateRequirementInDb(
     const md = generateRequirementsMd(nonSuperseded);
     const filePath = resolveGsdRootFile(basePath, 'REQUIREMENTS');
     await saveFile(filePath, md);
+    // Invalidate file-read caches so deriveState() sees the updated markdown.
+    // Do NOT clear the artifacts table — we just wrote to it intentionally.
+    invalidateStateCache();
+    clearPathCache();
+    clearParseCache();
   } catch (err) {
     process.stderr.write(`gsd-db: updateRequirementInDb failed: ${(err as Error).message}\n`);
     throw err;
@@ -331,9 +345,14 @@ export async function saveArtifactToDb(
     const gsdDir = resolve(basePath, '.gsd');
     const fullPath = resolve(basePath, '.gsd', opts.path);
     if (!fullPath.startsWith(gsdDir)) {
-      throw new Error(`saveArtifactToDb: path escapes .gsd/ directory: ${opts.path}`);
+      throw new GSDError(GSD_IO_ERROR, `saveArtifactToDb: path escapes .gsd/ directory: ${opts.path}`);
     }
     await saveFile(fullPath, opts.content);
+    // Invalidate file-read caches so deriveState() sees the updated markdown.
+    // Do NOT clear the artifacts table — we just wrote to it intentionally.
+    invalidateStateCache();
+    clearPathCache();
+    clearParseCache();
   } catch (err) {
     process.stderr.write(`gsd-db: saveArtifactToDb failed: ${(err as Error).message}\n`);
     throw err;