gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/auto-dashboard.test.ts

@@ -13,6 +13,10 @@ import {
   formatWidgetTokens,
   estimateTimeRemaining,
   extractUatSliceId,
+  updateProgressWidget,
+  setAutoOutcomeWidget,
+  getRoadmapSlicesSync,
+  clearSliceProgressCache,
   getWidgetMode,
   cycleWidgetMode,
   _resetWidgetModeForTests,
@@ -20,10 +24,19 @@ import {
   _refreshLastCommitForTests,
   _getLastCommitForTests,
   _getLastCommitFetchedAtForTests,
+  formatRuntimeHealthSignal,
+  shouldRenderRoadmapProgress,
 } from "../auto-dashboard.ts";
-
-const autoSource = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "auto.ts"), "utf-8");
-const dashboardSource = readFileSync(join(process.cwd(), "src", "resources", "extensions", "gsd", "auto-dashboard.ts"), "utf-8");
+import { getAutoDashboardData } from "../auto.ts";
+import { autoSession } from "../auto-runtime-state.ts";
+import { formatRtkSavingsLabel } from "../../shared/rtk-session-stats.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
 
 function makeTempDir(prefix: string): string {
   return join(
@@ -183,6 +196,71 @@ test("formatWidgetTokens formats millions with M", () => {
   assert.equal(formatWidgetTokens(25_000_000), "25M");
 });
 
+test("formatRuntimeHealthSignal surfaces idle recovery instead of generic progress", () => {
+  const signal = formatRuntimeHealthSignal({
+    version: 1,
+    unitType: "research-milestone",
+    unitId: "M001",
+    startedAt: 1_000,
+    updatedAt: 600_000,
+    phase: "recovered",
+    wrapupWarningSent: false,
+    continueHereFired: false,
+    timeoutAt: null,
+    lastProgressAt: 1_000,
+    progressCount: 1,
+    lastProgressKind: "idle-recovery-retry",
+    recoveryAttempts: 1,
+    lastRecoveryReason: "idle",
+  }, 600_000);
+
+  assert.deepEqual(signal, {
+    level: "yellow",
+    summary: "Recovering",
+    detail: "retry 1 after idle stall",
+  });
+});
+
+test("setAutoOutcomeWidget renders a durable next-action handoff", () => {
+  let widgetFactory: any;
+  setAutoOutcomeWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(key: string, factory: any) {
+          if (key === "gsd-outcome") widgetFactory = factory;
+        },
+      },
+    } as any,
+    {
+      status: "paused",
+      title: "Auto-mode paused",
+      detail: "Paused by user request.",
+      unitLabel: "researching M005/S01",
+      nextAction: "Type to steer, or run /gsd auto to resume.",
+      commands: ["/gsd auto", "/gsd status for overview"],
+      startedAt: Date.now() - 2_000,
+    },
+  );
+
+  assert.equal(typeof widgetFactory, "function");
+  const component = widgetFactory(
+    { requestRender() {} },
+    { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+  );
+  const output = component.render(100).join("\n");
+  assert.match(output, /Auto-mode paused/);
+  assert.match(output, /Paused by user request/);
+  assert.match(output, /researching M005\/S01/);
+  assert.match(output, /\/gsd auto/);
+});
+
+test("shouldRenderRoadmapProgress hides pre-roadmap zero-slice progress", () => {
+  assert.equal(shouldRenderRoadmapProgress(null), false);
+  assert.equal(shouldRenderRoadmapProgress({ done: 0, total: 0, activeSliceTasks: null } as any), false);
+  assert.equal(shouldRenderRoadmapProgress({ done: 0, total: 1, activeSliceTasks: null } as any), true);
+});
+
 // ─── estimateTimeRemaining ──────────────────────────────────────────────
 
 test("estimateTimeRemaining returns null when no ledger data", () => {
@@ -210,14 +288,159 @@ test("formatAutoElapsed returns empty string for negative autoStartTime", () =>
 });
 
 test("getAutoDashboardData returns RTK savings in the dashboard payload", () => {
-  assert.match(autoSource, /const rtkSavings = sessionId && s\.basePath/);
-  assert.match(autoSource, /rtkSavings,/);
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = makeTempDir("rtk-dashboard");
+  autoSession.cmdCtx = {
+    sessionManager: { getSessionId: () => "session-1" },
+  } as any;
+  try {
+    const data = getAutoDashboardData();
+    assert.equal(Object.hasOwn(data, "rtkSavings"), true);
+    assert.equal(
+      data.rtkSavings === null || typeof data.rtkSavings === "object",
+      true,
+    );
+  } finally {
+    cleanup(autoSession.basePath);
+    autoSession.reset();
+  }
+});
+
+test("RTK savings label formats the dashboard footer text", () => {
+  assert.equal(formatRtkSavingsLabel(null), null);
+  assert.equal(
+    formatRtkSavingsLabel({
+      commands: 2,
+      inputTokens: 10_000,
+      outputTokens: 1_000,
+      savedTokens: 2_500,
+      savingsPct: 25,
+      totalTimeMs: 100,
+      avgTimeMs: 50,
+      updatedAt: new Date(0).toISOString(),
+    }),
+    "rtk: 2.5k saved (25%)",
+  );
 });
 
-test("auto progress widget renders RTK savings under the footer stats line", () => {
-  assert.match(dashboardSource, /formatRtkSavingsLabel/);
-  assert.match(dashboardSource, /getRtkSessionSavings\(accessors\.getBasePath\(\), sessionId\)/);
-  assert.match(dashboardSource, /lines\.push\(rightAlign\("", theme\.fg\("dim", cachedRtkLabel\), width\)\);/);
+test("updateProgressWidget refreshes slice progress cache immediately", (t) => {
+  const dir = makeTempDir("progress-cache");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+
+  t.after(() => {
+    closeDatabase();
+    clearSliceProgressCache();
+    cleanup(dir);
+  });
+
+  openDatabase(join(dir, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete", sequence: 1 });
+  insertSlice({ milestoneId: "M001", id: "S02", title: "Active", status: "pending", sequence: 2 });
+  insertSlice({ milestoneId: "M001", id: "S03", title: "Pending", status: "pending", sequence: 3 });
+  insertTask({ milestoneId: "M001", sliceId: "S02", id: "T01", title: "Task", status: "complete" });
+
+  clearSliceProgressCache();
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: { setWidget() {} },
+    } as any,
+    "complete-slice",
+    "M001/S02",
+    {
+      phase: "summarizing",
+      activeMilestone: { id: "M001", title: "Milestone" },
+      activeSlice: { id: "S02", title: "Active" },
+      activeTask: null,
+    } as any,
+    {
+      getAutoStartTime: () => 0,
+      isStepMode: () => false,
+      getCmdCtx: () => null,
+      getBasePath: () => dir,
+      isVerbose: () => false,
+      isSessionSwitching: () => false,
+      getCurrentDispatchedModelId: () => null,
+    },
+  );
+
+  const progress = getRoadmapSlicesSync();
+  assert.ok(progress, "progress cache should be populated immediately after updateProgressWidget");
+  assert.deepEqual({
+    done: progress.done,
+    total: progress.total,
+    activeSliceTasks: progress.activeSliceTasks,
+  }, {
+    done: 1,
+    total: 3,
+    activeSliceTasks: { done: 1, total: 1 },
+  });
+});
+
+test("updateProgressWidget full mode keeps footer-owned signals out of auto deck", (t) => {
+  const dir = makeTempDir("command-deck");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  let widget: { render(width: number): string[]; dispose?: () => void } | null = null;
+
+  t.after(() => {
+    widget?.dispose?.();
+    clearSliceProgressCache();
+    cleanup(dir);
+  });
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setHeader() {},
+        setStatus() {},
+        setWidget(_key: string, factory: any) {
+          if (_key === "gsd-progress") {
+            widget = factory(
+              { requestRender() {} },
+              { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+            );
+          }
+        },
+      },
+      sessionManager: { getSessionId: () => "session-1" },
+    } as any,
+    "execute-task",
+    "M004/S01/T01",
+    {
+      phase: "executing",
+      activeMilestone: { id: "M004", title: "Budget Tracking" },
+      activeSlice: { id: "S01", title: "Schema migration + expense add --repeat" },
+      activeTask: { id: "T01", title: "Add repeat column via idempotent ALTER TABLE" },
+    } as any,
+    {
+      getAutoStartTime: () => Date.now() - 18_000,
+      isStepMode: () => false,
+      getCmdCtx: () => ({
+        model: { id: "claude-sonnet-4-6", provider: "claude-code", contextWindow: 1_000_000 },
+        getContextUsage: () => ({ percent: 0.2, contextWindow: 1_000_000 }),
+        sessionManager: { getEntries: () => [] },
+      } as any),
+      getBasePath: () => dir,
+      isVerbose: () => false,
+      isSessionSwitching: () => false,
+      getCurrentDispatchedModelId: () => "claude-code/claude-sonnet-4-6",
+    },
+  );
+
+  const installedWidget = widget as { render(width: number): string[]; dispose?: () => void } | null;
+  assert.ok(installedWidget, "progress widget should be installed");
+  const rendered = installedWidget.render(120).join("\n");
+
+  assert.match(rendered, /GSD\s+AUTO/);
+  assert.match(rendered, /Budget Tracking/);
+  assert.match(rendered, /T01: Add repeat column via idempotent ALTER TABLE/);
+  assert.match(rendered, /dashboard/);
+  assert.doesNotMatch(rendered, /claude-sonnet-4-6/, "footer owns provider/model display");
+  assert.doesNotMatch(rendered, /0\.2%|ctx|1\.0M/, "footer owns raw context meter display");
+  assert.doesNotMatch(rendered, /\$/, "footer owns session cost display");
 });
 
 test("last commit refresh backs off cleanly when base path is not a git repo", (t) => {