gsd-pi 2.28.0 → 2.29.0-dev.7612840

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

@@ -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 ───────────────────────────────────────────────────────────
 
@@ -309,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;
@@ -366,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)}`;
@@ -386,7 +399,10 @@ 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}`);
             }
 
@@ -448,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)}`
@@ -507,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. */

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

@@ -0,0 +1,150 @@
+/**
+ * Idempotency checks for auto-mode unit dispatch.
+ *
+ * Handles completed-key membership, artifact cross-validation,
+ * consecutive skip counting, phantom skip loop detection, key eviction,
+ * and fallback persistence.
+ *
+ * Extracted from dispatchNextUnit() in auto.ts. Pure decision logic
+ * with set mutations — does NOT call dispatchNextUnit or stopAuto.
+ */
+
+import { invalidateAllCaches } from "./cache.js";
+import {
+  verifyExpectedArtifact,
+  persistCompletedKey,
+  removePersistedKey,
+} from "./auto-recovery.js";
+import { resolveMilestoneFile } from "./paths.js";
+import { MAX_CONSECUTIVE_SKIPS, MAX_LIFETIME_DISPATCHES } from "./auto/session.js";
+import type { AutoSession } from "./auto/session.js";
+
+export interface IdempotencyContext {
+  s: AutoSession;
+  unitType: string;
+  unitId: string;
+  basePath: string;
+  /** Notification callback */
+  notify: (message: string, level: "info" | "warning" | "error") => void;
+}
+
+export type IdempotencyResult =
+  | { action: "skip"; reason: string }
+  | { action: "rerun"; reason: string }
+  | { action: "proceed" }
+  | { action: "stop"; reason: string };
+
+/**
+ * Check whether a unit should be skipped (already completed), rerun
+ * (stale completion record), or dispatched normally.
+ *
+ * Mutates s.completedKeySet, s.unitConsecutiveSkips, s.unitLifetimeDispatches,
+ * and s.recentlyEvictedKeys as needed.
+ */
+export function checkIdempotency(ictx: IdempotencyContext): IdempotencyResult {
+  const { s, unitType, unitId, basePath, notify } = ictx;
+  const idempotencyKey = `${unitType}/${unitId}`;
+
+  // ── Primary path: key exists in completed set ──
+  if (s.completedKeySet.has(idempotencyKey)) {
+    const artifactExists = verifyExpectedArtifact(unitType, unitId, basePath);
+    if (artifactExists) {
+      // Guard against infinite skip loops
+      const skipCount = (s.unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
+      s.unitConsecutiveSkips.set(idempotencyKey, skipCount);
+      if (skipCount > MAX_CONSECUTIVE_SKIPS) {
+        // Cross-check: verify the unit's milestone is still active (#790)
+        const skippedMid = unitId.split("/")[0];
+        const skippedMilestoneComplete = skippedMid
+          ? !!resolveMilestoneFile(basePath, skippedMid, "SUMMARY")
+          : false;
+        if (skippedMilestoneComplete) {
+          s.unitConsecutiveSkips.delete(idempotencyKey);
+          invalidateAllCaches();
+          notify(
+            `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid}. Re-dispatching from fresh state.`,
+            "info",
+          );
+          return { action: "skip", reason: "phantom-loop-cleared" };
+        }
+        s.unitConsecutiveSkips.delete(idempotencyKey);
+        s.completedKeySet.delete(idempotencyKey);
+        s.recentlyEvictedKeys.add(idempotencyKey);
+        removePersistedKey(basePath, idempotencyKey);
+        invalidateAllCaches();
+        notify(
+          `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount} times without advancing. Evicting completion record and forcing reconciliation.`,
+          "warning",
+        );
+        return { action: "skip", reason: "evicted" };
+      }
+      // Count toward lifetime cap
+      const lifeSkip = (s.unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
+      s.unitLifetimeDispatches.set(idempotencyKey, lifeSkip);
+      if (lifeSkip > MAX_LIFETIME_DISPATCHES) {
+        return { action: "stop", reason: `Hard loop: ${unitType} ${unitId} (skip cycle)` };
+      }
+      notify(
+        `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
+        "info",
+      );
+      return { action: "skip", reason: "completed" };
+    } else {
+      // Stale completion record — artifact missing. Remove and re-run.
+      s.completedKeySet.delete(idempotencyKey);
+      removePersistedKey(basePath, idempotencyKey);
+      notify(
+        `Re-running ${unitType} ${unitId} — marked complete but expected artifact missing.`,
+        "warning",
+      );
+      return { action: "rerun", reason: "stale-key" };
+    }
+  }
+
+  // ── Fallback: key missing but artifact exists ──
+  if (verifyExpectedArtifact(unitType, unitId, basePath) && !s.recentlyEvictedKeys.has(idempotencyKey)) {
+    persistCompletedKey(basePath, idempotencyKey);
+    s.completedKeySet.add(idempotencyKey);
+    invalidateAllCaches();
+    // Same consecutive-skip guard as the primary path
+    const skipCount2 = (s.unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
+    s.unitConsecutiveSkips.set(idempotencyKey, skipCount2);
+    if (skipCount2 > MAX_CONSECUTIVE_SKIPS) {
+      const skippedMid2 = unitId.split("/")[0];
+      const skippedMilestoneComplete2 = skippedMid2
+        ? !!resolveMilestoneFile(basePath, skippedMid2, "SUMMARY")
+        : false;
+      if (skippedMilestoneComplete2) {
+        s.unitConsecutiveSkips.delete(idempotencyKey);
+        invalidateAllCaches();
+        notify(
+          `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid2}. Re-dispatching from fresh state.`,
+          "info",
+        );
+        return { action: "skip", reason: "phantom-loop-cleared" };
+      }
+      s.unitConsecutiveSkips.delete(idempotencyKey);
+      s.completedKeySet.delete(idempotencyKey);
+      removePersistedKey(basePath, idempotencyKey);
+      invalidateAllCaches();
+      notify(
+        `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount2} times without advancing. Evicting completion record and forcing reconciliation.`,
+        "warning",
+      );
+      return { action: "skip", reason: "evicted" };
+    }
+    // Count toward lifetime cap
+    const lifeSkip2 = (s.unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
+    s.unitLifetimeDispatches.set(idempotencyKey, lifeSkip2);
+    if (lifeSkip2 > MAX_LIFETIME_DISPATCHES) {
+      return { action: "stop", reason: `Hard loop: ${unitType} ${unitId} (skip cycle)` };
+    }
+    notify(
+      `Skipping ${unitType} ${unitId} — artifact exists but completion key was missing. Repaired and advancing.`,
+      "info",
+    );
+    return { action: "skip", reason: "fallback-persisted" };
+  }
+
+  return { action: "proceed" };
+}