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

package/dist/resources/extensions/gsd/auto/session.ts

@@ -0,0 +1,236 @@
+/**
+ * AutoSession — encapsulates all mutable auto-mode state into a single instance.
+ *
+ * Replaces ~40 module-level variables scattered across auto.ts with typed
+ * properties on a class instance. Benefits:
+ *
+ * - reset() clears everything in one call (was 25+ manual resets in stopAuto)
+ * - toJSON() provides diagnostic snapshots
+ * - grep `s.` shows every state access
+ * - Constructable for testing
+ *
+ * MAINTENANCE RULE: All new mutable auto-mode state MUST be added here as a
+ * class property, not as a module-level variable in auto.ts. If the state
+ * needs clearing on stop, add it to reset(). Tests in
+ * auto-session-encapsulation.test.ts enforce that auto.ts has no module-level
+ * `let` or `var` declarations.
+ */
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import type { GitServiceImpl } from "../git-service.js";
+import type { CaptureEntry } from "../captures.js";
+import type { BudgetAlertLevel } from "../auto-budget.js";
+
+// ─── Exported Types ──────────────────────────────────────────────────────────
+
+export interface CompletedUnit {
+  type: string;
+  id: string;
+  startedAt: number;
+  finishedAt: number;
+}
+
+export interface CurrentUnit {
+  type: string;
+  id: string;
+  startedAt: number;
+}
+
+export interface UnitRouting {
+  tier: string;
+  modelDowngraded: boolean;
+}
+
+export interface StartModel {
+  provider: string;
+  id: string;
+}
+
+export interface PendingVerificationRetry {
+  unitId: string;
+  failureContext: string;
+  attempt: number;
+}
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+export const MAX_UNIT_DISPATCHES = 3;
+export const STUB_RECOVERY_THRESHOLD = 2;
+export const MAX_LIFETIME_DISPATCHES = 6;
+export const MAX_CONSECUTIVE_SKIPS = 3;
+export const DISPATCH_GAP_TIMEOUT_MS = 5_000;
+export const MAX_SKIP_DEPTH = 20;
+export const NEW_SESSION_TIMEOUT_MS = 30_000;
+export const DISPATCH_HANG_TIMEOUT_MS = 60_000;
+
+// ─── AutoSession ─────────────────────────────────────────────────────────────
+
+export class AutoSession {
+  // ── Lifecycle ────────────────────────────────────────────────────────────
+  active = false;
+  paused = false;
+  pausedForSecrets = false;
+  stepMode = false;
+  verbose = false;
+  cmdCtx: ExtensionCommandContext | null = null;
+
+  // ── Paths ────────────────────────────────────────────────────────────────
+  basePath = "";
+  originalBasePath = "";
+  gitService: GitServiceImpl | null = null;
+
+  // ── Dispatch counters ────────────────────────────────────────────────────
+  readonly unitDispatchCount = new Map<string, number>();
+  readonly unitLifetimeDispatches = new Map<string, number>();
+  readonly unitRecoveryCount = new Map<string, number>();
+  readonly unitConsecutiveSkips = new Map<string, number>();
+  readonly completedKeySet = new Set<string>();
+
+  // ── Timers ───────────────────────────────────────────────────────────────
+  unitTimeoutHandle: ReturnType<typeof setTimeout> | null = null;
+  wrapupWarningHandle: ReturnType<typeof setTimeout> | null = null;
+  idleWatchdogHandle: ReturnType<typeof setInterval> | null = null;
+  continueHereHandle: ReturnType<typeof setInterval> | null = null;
+  dispatchGapHandle: ReturnType<typeof setTimeout> | null = null;
+
+  // ── Current unit ─────────────────────────────────────────────────────────
+  currentUnit: CurrentUnit | null = null;
+  currentUnitRouting: UnitRouting | null = null;
+  completedUnits: CompletedUnit[] = [];
+  currentMilestoneId: string | null = null;
+
+  // ── Model state ──────────────────────────────────────────────────────────
+  autoModeStartModel: StartModel | null = null;
+  originalModelId: string | null = null;
+  originalModelProvider: string | null = null;
+  lastBudgetAlertLevel: BudgetAlertLevel = 0;
+
+  // ── Recovery ─────────────────────────────────────────────────────────────
+  pendingCrashRecovery: string | null = null;
+  pendingVerificationRetry: PendingVerificationRetry | null = null;
+  readonly verificationRetryCount = new Map<string, number>();
+  pausedSessionFile: string | null = null;
+  resourceVersionOnStart: string | null = null;
+  lastStateRebuildAt = 0;
+
+  // ── Guards ───────────────────────────────────────────────────────────────
+  handlingAgentEnd = false;
+  pendingAgentEndRetry = false;
+  dispatching = false;
+  skipDepth = 0;
+  readonly recentlyEvictedKeys = new Set<string>();
+
+  // ── Metrics ──────────────────────────────────────────────────────────────
+  autoStartTime = 0;
+  lastPromptCharCount: number | undefined;
+  lastBaselineCharCount: number | undefined;
+  pendingQuickTasks: CaptureEntry[] = [];
+
+  // ── Signal handler ───────────────────────────────────────────────────────
+  sigtermHandler: (() => void) | null = null;
+
+  // ── Methods ──────────────────────────────────────────────────────────────
+
+  clearTimers(): void {
+    if (this.unitTimeoutHandle) { clearTimeout(this.unitTimeoutHandle); this.unitTimeoutHandle = null; }
+    if (this.wrapupWarningHandle) { clearTimeout(this.wrapupWarningHandle); this.wrapupWarningHandle = null; }
+    if (this.idleWatchdogHandle) { clearInterval(this.idleWatchdogHandle); this.idleWatchdogHandle = null; }
+    if (this.continueHereHandle) { clearInterval(this.continueHereHandle); this.continueHereHandle = null; }
+    if (this.dispatchGapHandle) { clearTimeout(this.dispatchGapHandle); this.dispatchGapHandle = null; }
+  }
+
+  resetDispatchCounters(): void {
+    this.unitDispatchCount.clear();
+    this.unitLifetimeDispatches.clear();
+    this.unitConsecutiveSkips.clear();
+  }
+
+  get lockBasePath(): string {
+    return this.originalBasePath || this.basePath;
+  }
+
+  completeCurrentUnit(): CompletedUnit | null {
+    if (!this.currentUnit) return null;
+    const done: CompletedUnit = { ...this.currentUnit, finishedAt: Date.now() };
+    this.completedUnits.push(done);
+    this.currentUnit = null;
+    return done;
+  }
+
+  reset(): void {
+    this.clearTimers();
+
+    // Lifecycle
+    this.active = false;
+    this.paused = false;
+    this.pausedForSecrets = false;
+    this.stepMode = false;
+    this.verbose = false;
+    this.cmdCtx = null;
+
+    // Paths
+    this.basePath = "";
+    this.originalBasePath = "";
+    this.gitService = null;
+
+    // Dispatch
+    this.unitDispatchCount.clear();
+    this.unitLifetimeDispatches.clear();
+    this.unitRecoveryCount.clear();
+    this.unitConsecutiveSkips.clear();
+    // Note: completedKeySet is intentionally NOT cleared — it persists
+    // across restarts to prevent re-dispatching completed units.
+
+    // Unit
+    this.currentUnit = null;
+    this.currentUnitRouting = null;
+    this.completedUnits = [];
+    this.currentMilestoneId = null;
+
+    // Model
+    this.autoModeStartModel = null;
+    this.originalModelId = null;
+    this.originalModelProvider = null;
+    this.lastBudgetAlertLevel = 0;
+
+    // Recovery
+    this.pendingCrashRecovery = null;
+    this.pendingVerificationRetry = null;
+    this.verificationRetryCount.clear();
+    this.pausedSessionFile = null;
+    this.resourceVersionOnStart = null;
+    this.lastStateRebuildAt = 0;
+
+    // Guards
+    this.handlingAgentEnd = false;
+    this.pendingAgentEndRetry = false;
+    this.dispatching = false;
+    this.skipDepth = 0;
+    this.recentlyEvictedKeys.clear();
+
+    // Metrics
+    this.autoStartTime = 0;
+    this.lastPromptCharCount = undefined;
+    this.lastBaselineCharCount = undefined;
+    this.pendingQuickTasks = [];
+
+    // Signal handler
+    this.sigtermHandler = null;
+  }
+
+  toJSON(): Record<string, unknown> {
+    return {
+      active: this.active,
+      paused: this.paused,
+      stepMode: this.stepMode,
+      basePath: this.basePath,
+      currentMilestoneId: this.currentMilestoneId,
+      currentUnit: this.currentUnit,
+      completedUnits: this.completedUnits.length,
+      completedKeySet: this.completedKeySet.size,
+      unitDispatchCount: Object.fromEntries(this.unitDispatchCount),
+      dispatching: this.dispatching,
+      skipDepth: this.skipDepth,
+    };
+  }
+}

package/dist/resources/extensions/gsd/auto-budget.ts

@@ -0,0 +1,32 @@
+/**
+ * Budget alert level tracking and enforcement for auto-mode.
+ * Pure functions — no module state or side effects.
+ */
+
+import type { BudgetEnforcementMode } from "./types.js";
+
+export type BudgetAlertLevel = 0 | 75 | 80 | 90 | 100;
+
+export function getBudgetAlertLevel(budgetPct: number): BudgetAlertLevel {
+  if (budgetPct >= 1.0) return 100;
+  if (budgetPct >= 0.90) return 90;
+  if (budgetPct >= 0.80) return 80;
+  if (budgetPct >= 0.75) return 75;
+  return 0;
+}
+
+export function getNewBudgetAlertLevel(previousLevel: BudgetAlertLevel, budgetPct: number): BudgetAlertLevel | null {
+  const currentLevel = getBudgetAlertLevel(budgetPct);
+  if (currentLevel === 0 || currentLevel <= previousLevel) return null;
+  return currentLevel;
+}
+
+export function getBudgetEnforcementAction(
+  enforcement: BudgetEnforcementMode,
+  budgetPct: number,
+): "none" | "warn" | "pause" | "halt" {
+  if (budgetPct < 1.0) return "none";
+  if (enforcement === "halt") return "halt";
+  if (enforcement === "pause") return "pause";
+  return "warn";
+}

package/dist/resources/extensions/gsd/auto-dashboard.ts

@@ -6,7 +6,7 @@
  * or AutoContext dependency. State accessors are passed as callbacks.
  */
 
-import type { ExtensionContext, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import type { ExtensionContext, ExtensionCommandContext, SessionMessageEntry } from "@gsd/pi-coding-agent";
 import type { GSDState } from "./types.js";
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
@@ -18,7 +18,7 @@ import {
 import { parseRoadmap, parsePlan } from "./files.js";
 import { readFileSync, existsSync } from "node:fs";
 import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
-import { makeUI, GLYPH, INDENT } from "../shared/ui.js";
+import { makeUI, GLYPH, INDENT } from "../shared/mod.js";
 
 // ─── Dashboard Data ───────────────────────────────────────────────────────────
 
@@ -159,6 +159,49 @@ export function formatWidgetTokens(count: number): string {
   return `${Math.round(count / 1000000)}M`;
 }
 
+// ─── ETA Estimation ──────────────────────────────────────────────────────────
+
+/**
+ * Estimate remaining time based on average unit duration from the metrics ledger.
+ * Returns a formatted string like "~12m remaining" or null if insufficient data.
+ */
+export function estimateTimeRemaining(): string | null {
+  const ledger = getLedger();
+  if (!ledger || ledger.units.length < 2) return null;
+
+  const sliceProgress = getRoadmapSlicesSync();
+  if (!sliceProgress || sliceProgress.total === 0) return null;
+
+  const remainingSlices = sliceProgress.total - sliceProgress.done;
+  if (remainingSlices <= 0) return null;
+
+  // Compute average duration per completed slice from the ledger
+  const completedSliceUnits = ledger.units.filter(
+    u => u.finishedAt > 0 && u.startedAt > 0,
+  );
+  if (completedSliceUnits.length < 2) return null;
+
+  const totalDuration = completedSliceUnits.reduce(
+    (sum, u) => sum + (u.finishedAt - u.startedAt), 0,
+  );
+  const avgDuration = totalDuration / completedSliceUnits.length;
+
+  // Rough estimate: remaining slices × average units per slice × avg duration
+  const completedSlices = sliceProgress.done || 1;
+  const unitsPerSlice = completedSliceUnits.length / completedSlices;
+  const estimatedMs = remainingSlices * unitsPerSlice * avgDuration;
+
+  if (estimatedMs < 5_000) return null; // Too small to display
+
+  const s = Math.floor(estimatedMs / 1000);
+  if (s < 60) return `~${s}s remaining`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `~${m}m remaining`;
+  const h = Math.floor(m / 60);
+  const rm = m % 60;
+  return rm > 0 ? `~${h}h ${rm}m remaining` : `~${h}h remaining`;
+}
+
 // ─── Slice Progress Cache ─────────────────────────────────────────────────────
 
 /** Cached slice progress for the widget — avoid async in render */
@@ -266,6 +309,16 @@ export function updateProgressWidget(
   }
   if (cachedBranch) widgetPwd = `${widgetPwd} (${cachedBranch})`;
 
+  // Set a string-array fallback first — this is the only version RPC mode will
+  // see, since the factory widget set below is not supported in RPC mode.
+  const progressText = buildProgressTextLines(
+    verb, phaseLabel, unitId, mid, slice, task, next,
+    accessors, tierBadge, widgetPwd,
+  );
+  ctx.ui.setWidget("gsd-progress", progressText);
+
+  // Set the factory-based widget — in TUI mode this replaces the string-array
+  // version with a dynamic, animated widget. In RPC mode this call is a no-op.
   ctx.ui.setWidget("gsd-progress", (tui, theme) => {
     let pulseBright = true;
     let cachedLines: string[] | undefined;
@@ -277,15 +330,16 @@ export function updateProgressWidget(
       tui.requestRender();
     }, 800);
 
-    // Refresh progress cache from disk every 5s so the widget reflects
+    // Refresh progress cache from disk every 15s so the widget reflects
     // task/slice completion mid-unit. Without this, the progress bar only
     // updates at dispatch time, appearing frozen during long-running units.
+    // 15s (vs 5s) reduces synchronous file I/O on the hot path.
     const progressRefreshTimer = mid ? setInterval(() => {
       try {
         updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
         cachedLines = undefined;
       } catch { /* non-fatal */ }
-    }, 5_000) : null;
+    }, 15_000) : null;
 
     return {
       render(width: number): string[] {
@@ -322,7 +376,10 @@ export function updateProgressWidget(
 
         lines.push("");
 
-        const target = task ? `${task.id}: ${task.title}` : unitId;
+        const isHook = unitType.startsWith("hook/");
+        const target = isHook
+          ? (unitId.split("/").pop() ?? unitId)
+          : (task ? `${task.id}: ${task.title}` : unitId);
         const actionLeft = `${pad}${theme.fg("accent", "▸")} ${theme.fg("accent", verb)}  ${theme.fg("text", target)}`;
         const tierTag = tierBadge ? theme.fg("dim", `[${tierBadge}] `) : "";
         const phaseBadge = `${tierTag}${theme.fg("dim", phaseLabel)}`;
@@ -342,10 +399,19 @@ export function updateProgressWidget(
             let meta = theme.fg("dim", `${done}/${total} slices`);
 
             if (activeSliceTasks && activeSliceTasks.total > 0) {
-              const taskNum = Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
+              // For hooks, show the trigger task number (done), not the next task (done + 1)
+              const taskNum = isHook
+                ? Math.max(activeSliceTasks.done, 1)
+                : Math.min(activeSliceTasks.done + 1, activeSliceTasks.total);
               meta += theme.fg("dim", `  ·  task ${taskNum}/${activeSliceTasks.total}`);
             }
 
+            // ETA estimate
+            const eta = estimateTimeRemaining();
+            if (eta) {
+              meta += theme.fg("dim", `  ·  ${eta}`);
+            }
+
             lines.push(truncateToWidth(`${pad}${bar}  ${meta}`, width));
           }
         }
@@ -370,13 +436,16 @@ export function updateProgressWidget(
           let totalCacheRead = 0, totalCacheWrite = 0;
           if (cmdCtx) {
             for (const entry of cmdCtx.sessionManager.getEntries()) {
-              if (entry.type === "message" && (entry as any).message?.role === "assistant") {
-                const u = (entry as any).message.usage;
-                if (u) {
-                  totalInput += u.input || 0;
-                  totalOutput += u.output || 0;
-                  totalCacheRead += u.cacheRead || 0;
-                  totalCacheWrite += u.cacheWrite || 0;
+              if (entry.type === "message") {
+                const msgEntry = entry as SessionMessageEntry;
+                if (msgEntry.message?.role === "assistant") {
+                  const u = (msgEntry.message as any).usage;
+                  if (u) {
+                    totalInput += u.input || 0;
+                    totalOutput += u.output || 0;
+                    totalCacheRead += u.cacheRead || 0;
+                    totalCacheWrite += u.cacheWrite || 0;
+                  }
                 }
               }
             }
@@ -395,7 +464,13 @@ export function updateProgressWidget(
           if (totalOutput) sp.push(`↓${formatWidgetTokens(totalOutput)}`);
           if (totalCacheRead) sp.push(`R${formatWidgetTokens(totalCacheRead)}`);
           if (totalCacheWrite) sp.push(`W${formatWidgetTokens(totalCacheWrite)}`);
+          // Cache hit rate for current unit
+          if (totalCacheRead + totalInput > 0) {
+            const hitRate = Math.round((totalCacheRead / (totalCacheRead + totalInput)) * 100);
+            sp.push(`\u26A1${hitRate}%`);
+          }
           if (cumulativeCost) sp.push(`$${cumulativeCost.toFixed(3)}`);
+          else if (autoTotals?.apiRequests) sp.push(`${autoTotals.apiRequests} reqs`);
 
           const cxDisplay = cxPct === "?"
             ? `?/${formatWidgetTokens(cxWindow)}`
@@ -454,6 +529,65 @@ export function updateProgressWidget(
   });
 }
 
+// ─── Text Fallback for RPC Mode ───────────────────────────────────────────
+
+/**
+ * Build a compact string-array representation of the progress widget.
+ * Used as a fallback when the factory-based widget cannot render (RPC mode).
+ */
+function buildProgressTextLines(
+  verb: string,
+  phaseLabel: string,
+  unitId: string,
+  mid: { id: string; title: string } | null,
+  slice: { id: string; title: string } | null,
+  task: { id: string; title: string } | null,
+  next: string,
+  accessors: WidgetStateAccessors,
+  tierBadge: string | undefined,
+  widgetPwd: string,
+): string[] {
+  const mode = accessors.isStepMode() ? "step" : "auto";
+  const elapsed = formatAutoElapsed(accessors.getAutoStartTime());
+  const tierStr = tierBadge ? ` [${tierBadge}]` : "";
+
+  const lines: string[] = [];
+  lines.push(`[GSD ${mode}] ${verb} ${unitId}${tierStr}${elapsed ? ` — ${elapsed}` : ""}`);
+
+  if (mid) lines.push(`  Milestone: ${mid.id} — ${mid.title}`);
+  if (slice) lines.push(`  Slice: ${slice.id} — ${slice.title}`);
+  if (task) lines.push(`  Task: ${task.id} — ${task.title}`);
+
+  // Progress bar
+  const sp = cachedSliceProgress;
+  if (sp && sp.total > 0) {
+    const pct = Math.round((sp.done / sp.total) * 100);
+    const taskInfo = sp.activeSliceTasks
+      ? ` (tasks: ${sp.activeSliceTasks.done}/${sp.activeSliceTasks.total})`
+      : "";
+    lines.push(`  Progress: ${sp.done}/${sp.total} slices (${pct}%)${taskInfo}`);
+  }
+
+  // Cost / tokens
+  const ledger = getLedger();
+  const totals = ledger ? getProjectTotals(ledger.units) : null;
+  if (totals) {
+    const parts: string[] = [];
+    if (totals.tokens.input || totals.tokens.output) {
+      parts.push(`tokens: ${formatWidgetTokens(totals.tokens.input)}↑ ${formatWidgetTokens(totals.tokens.output)}↓`);
+    }
+    if (totals.cost > 0) {
+      parts.push(`cost: ${formatCost(totals.cost)}`);
+    }
+    if (parts.length > 0) lines.push(`  ${parts.join(" — ")}`);
+  }
+
+  if (next) lines.push(`  Next: ${next}`);
+  lines.push(`  ${widgetPwd}`);
+
+  return lines;
+}
+
 // ─── Right-align Helper ───────────────────────────────────────────────────────
 
 /** Right-align helper: build a line with left content and right content. */