fix(showcase): downgrade stale-green D5/D6 dashboard rows like D3

Extend the e2e staleness downgrade to resolveD5/resolveD6 in cell-model and to
depth-utils so a frozen-green pipeline no longer credits D5/D6 as healthy. Also
correct misleading comments/test-doc nits flagged in review.

Author: jpr5

showcase/shell-dashboard/src/components/__tests__/depth-utils.test.ts

@@ -1,6 +1,8 @@
 /**
- * Unit tests for depth derivation utility.
- * Parameterized: all D0-D6 combos, short-circuit on red, unshipped returns D0.
+ * Unit tests for the depth-derivation utility (deriveDepth).
+ * Covers the D0-D6 ladder walk, short-circuit on non-green, unshipped/
+ * unsupported handling, maxPossible/isRegression computation, multi-key D5
+ * mappings, and D5/D6 staleness downgrades.
  */
 import { describe, it, expect } from "vitest";
 import { deriveDepth } from "../depth-utils";
@@ -370,6 +372,69 @@ describe("deriveDepth", () => {
     expect(result.achieved).toBe(6);
   });
 
+  // ── D5/D6 staleness mirrors cell-model.ts (both consumers agree) ──
+  describe("D5/D6 staleness downgrade", () => {
+    const NOW = Date.parse("2026-05-30T12:00:00Z");
+    const STALE_AT = new Date(NOW - 7 * 60 * 60 * 1000).toISOString();
+    const FRESH_AT = new Date(NOW - 60 * 1000).toISOString();
+
+    it("does not credit D5 when its green row is stale", () => {
+      const c = cell("lgp", "agentic-chat");
+      const live = mapOf([
+        row("health:lgp", "health", "green", FRESH_AT),
+        row("agent:lgp", "agent", "green", FRESH_AT),
+        row("e2e:lgp/agentic-chat", "e2e", "green", FRESH_AT),
+        row("chat:lgp", "chat", "green", FRESH_AT),
+        row("d5:lgp/agentic-chat", "d5", "green", STALE_AT),
+      ]);
+      const result = deriveDepth(c, live, NOW);
+      // Stale green D5 must not advance past D4.
+      expect(result.achieved).toBe(4);
+    });
+
+    it("credits D5 when its green row is fresh", () => {
+      const c = cell("lgp", "agentic-chat");
+      const live = mapOf([
+        row("health:lgp", "health", "green", FRESH_AT),
+        row("agent:lgp", "agent", "green", FRESH_AT),
+        row("e2e:lgp/agentic-chat", "e2e", "green", FRESH_AT),
+        row("chat:lgp", "chat", "green", FRESH_AT),
+        row("d5:lgp/agentic-chat", "d5", "green", FRESH_AT),
+      ]);
+      const result = deriveDepth(c, live, NOW);
+      expect(result.achieved).toBe(5);
+    });
+
+    it("does not credit D6 when its green row is stale", () => {
+      const c = cell("lgp", "agentic-chat");
+      const live = mapOf([
+        row("health:lgp", "health", "green", FRESH_AT),
+        row("agent:lgp", "agent", "green", FRESH_AT),
+        row("e2e:lgp/agentic-chat", "e2e", "green", FRESH_AT),
+        row("chat:lgp", "chat", "green", FRESH_AT),
+        row("d5:lgp/agentic-chat", "d5", "green", FRESH_AT),
+        row("d6:lgp", "d6", "green", STALE_AT),
+      ]);
+      const result = deriveDepth(c, live, NOW);
+      // Stale green D6 must not advance past D5.
+      expect(result.achieved).toBe(5);
+    });
+
+    it("credits D6 when its green row is fresh", () => {
+      const c = cell("lgp", "agentic-chat");
+      const live = mapOf([
+        row("health:lgp", "health", "green", FRESH_AT),
+        row("agent:lgp", "agent", "green", FRESH_AT),
+        row("e2e:lgp/agentic-chat", "e2e", "green", FRESH_AT),
+        row("chat:lgp", "chat", "green", FRESH_AT),
+        row("d5:lgp/agentic-chat", "d5", "green", FRESH_AT),
+        row("d6:lgp", "d6", "green", FRESH_AT),
+      ]);
+      const result = deriveDepth(c, live, NOW);
+      expect(result.achieved).toBe(6);
+    });
+  });
+
   it("returns D4 for feature with no D5 mapping", () => {
     const c = cell("lgp", "unknown-feature");
     const live = mapOf([

showcase/shell-dashboard/src/components/depth-utils.ts

@@ -64,6 +64,22 @@ function isGreen(live: LiveStatusMap, key: string): boolean {
   return row?.state === "green";
 }
 
+/**
+ * A row counts as green only when it is green AND fresh. A frozen-green row
+ * from a stalled driver must NOT credit its depth — the same false-green
+ * staleness downgrade `cell-model.ts` applies to D3/D5/D6, mirrored here so
+ * both consumers agree.
+ */
+function isGreenAndFresh(
+  live: LiveStatusMap,
+  key: string,
+  now: number,
+): boolean {
+  const row = live.get(key);
+  if (row?.state !== "green") return false;
+  return !isRowStale(row, now, E2E_STALE_AFTER_MS);
+}
+
 /** Row is stale if `observed_at` is older than `maxAgeMs` relative to `now`. */
 function isRowStale(row: StatusRow, now: number, maxAgeMs: number): boolean {
   const observedMs = Date.parse(row.observed_at);
@@ -89,13 +105,16 @@ function isE2eGreenAndFresh(
 }
 
 /**
- * Check whether all D5 PB rows for a given (slug, catalogFeatureId) are green.
- * Returns false if the feature has no D5 mapping or any mapped row is missing/non-green.
+ * Check whether all D5 PB rows for a given (slug, catalogFeatureId) are green
+ * AND fresh. Returns false if the feature has no D5 mapping or any mapped row
+ * is missing/non-green/stale. The staleness gate mirrors `cell-model.ts` so a
+ * frozen-green CV row from a stalled driver no longer credits D5.
  */
 function isD5Green(
   live: LiveStatusMap,
   slug: string,
   featureId: string,
+  now: number,
 ): boolean {
   const d5Keys = CATALOG_TO_D5_KEY[featureId];
   // No D5 mapping = no CV test exists for this feature = cannot be D5.
@@ -104,7 +123,9 @@ function isD5Green(
   if (!d5Keys || d5Keys.length === 0) {
     return false;
   }
-  return d5Keys.every((d5Key) => isGreen(live, keyFor("d5", slug, d5Key)));
+  return d5Keys.every((d5Key) =>
+    isGreenAndFresh(live, keyFor("d5", slug, d5Key), now),
+  );
 }
 
 /**
@@ -236,7 +257,7 @@ export function deriveDepth(
   achieved = 4;
 
   // D5: d5:<slug>/<d5FeatureType> green (per-cell, mapped via CATALOG_TO_D5_KEY)
-  if (!isD5Green(live, cell.integration, cell.feature)) {
+  if (!isD5Green(live, cell.integration, cell.feature, now)) {
     return {
       achieved,
       maxPossible,
@@ -247,7 +268,7 @@ export function deriveDepth(
   achieved = 5;
 
   // D6: d6:<slug> green (integration-scoped aggregate)
-  if (isGreen(live, keyFor("d6", cell.integration))) {
+  if (isGreenAndFresh(live, keyFor("d6", cell.integration), now)) {
     achieved = 6;
   }
 

showcase/shell-dashboard/src/lib/__tests__/cell-model.test.ts

@@ -170,7 +170,7 @@ describe("buildCellModel", () => {
     });
   });
 
-  // ── D3+D4 pass, D5 exists but fails → amber chip ───────────────────
+  // ── D3+D4 pass, D5 exists but fails → red chip ─────────────────────
   describe("D3+D4 pass, D5 exists but fails", () => {
     it("returns red chip (D6-ceiling: D5 red, D6 absent)", () => {
       const live = mapOf([
@@ -623,4 +623,114 @@ describe("buildCellModel", () => {
       expect(model.d3?.status).toBe("red");
     });
   });
+
+  // ── D5/D6 staleness downgrade (same false-green mode, one dimension up) ──
+  // A frozen-green D5/D6 row from a stalled driver must be downgraded the
+  // same way D3 is, so it no longer credits the depth ladder / ceiling.
+  describe("D5/D6 staleness downgrade", () => {
+    const NOW = Date.parse("2026-05-30T12:00:00Z");
+
+    function rowAtAge(
+      key: string,
+      dimension: string,
+      ageMs: number,
+      state: State = "green",
+    ) {
+      const observedAt = new Date(NOW - ageMs).toISOString();
+      return row(key, dimension, state, {
+        observed_at: observedAt,
+        transitioned_at: observedAt,
+      });
+    }
+
+    const STALE = E2E_STALE_AFTER_MS + 60 * 60 * 1000;
+    const FRESH = 60 * 1000;
+
+    it("downgrades a stale green D5 row to amber (no longer credits D5/ceiling)", () => {
+      const live = mapOf([
+        rowAtAge(keyFor("e2e", "agno", "agentic-chat"), "e2e", FRESH, "green"),
+        rowAtAge(keyFor("chat", "agno"), "chat", FRESH, "green"),
+        rowAtAge(keyFor("d5", "agno", "agentic-chat"), "d5", STALE, "green"),
+      ]);
+      const model = buildCellModel(
+        live,
+        wiredInput("agno", "agentic-chat"),
+        NOW,
+      );
+      // Stale green D5 must NOT present as a healthy D5.
+      expect(model.d5?.status).toBe("amber");
+      // Depth ladder must not credit D5 when the signal is stale.
+      expect(model.achievedDepth).toBe(4);
+      // Chip: D5 not green, D6 absent → red (no longer amber-on-green-D5).
+      expect(model.chipColor).toBe("red");
+    });
+
+    it("keeps a fresh green D5 row green", () => {
+      const live = mapOf([
+        rowAtAge(keyFor("e2e", "agno", "agentic-chat"), "e2e", FRESH, "green"),
+        rowAtAge(keyFor("chat", "agno"), "chat", FRESH, "green"),
+        rowAtAge(keyFor("d5", "agno", "agentic-chat"), "d5", FRESH, "green"),
+      ]);
+      const model = buildCellModel(
+        live,
+        wiredInput("agno", "agentic-chat"),
+        NOW,
+      );
+      expect(model.d5?.status).toBe("green");
+      expect(model.achievedDepth).toBe(5);
+      // D5 green but no D6 → amber.
+      expect(model.chipColor).toBe("amber");
+    });
+
+    it("downgrades a stale green D6 row to amber (no longer credits D6/green chip)", () => {
+      const live = mapOf([
+        rowAtAge(keyFor("e2e", "agno", "agentic-chat"), "e2e", FRESH, "green"),
+        rowAtAge(keyFor("chat", "agno"), "chat", FRESH, "green"),
+        rowAtAge(keyFor("d5", "agno", "agentic-chat"), "d5", FRESH, "green"),
+        rowAtAge(keyFor("d6", "agno"), "d6", STALE, "green"),
+      ]);
+      const model = buildCellModel(
+        live,
+        wiredInput("agno", "agentic-chat"),
+        NOW,
+      );
+      // Stale green D6 must NOT present as a healthy D6.
+      expect(model.d6?.status).toBe("amber");
+      // Depth ladder must not credit D6 when the signal is stale.
+      expect(model.achievedDepth).toBe(5);
+      // D5 green but D6 not green → amber, not green.
+      expect(model.chipColor).toBe("amber");
+    });
+
+    it("keeps a fresh green D6 row green", () => {
+      const live = mapOf([
+        rowAtAge(keyFor("e2e", "agno", "agentic-chat"), "e2e", FRESH, "green"),
+        rowAtAge(keyFor("chat", "agno"), "chat", FRESH, "green"),
+        rowAtAge(keyFor("d5", "agno", "agentic-chat"), "d5", FRESH, "green"),
+        rowAtAge(keyFor("d6", "agno"), "d6", FRESH, "green"),
+      ]);
+      const model = buildCellModel(
+        live,
+        wiredInput("agno", "agentic-chat"),
+        NOW,
+      );
+      expect(model.d6?.status).toBe("green");
+      expect(model.achievedDepth).toBe(6);
+      expect(model.chipColor).toBe("green");
+    });
+
+    it("leaves a stale RED D5 row red (staleness only downgrades green)", () => {
+      const live = mapOf([
+        rowAtAge(keyFor("e2e", "agno", "agentic-chat"), "e2e", FRESH, "green"),
+        rowAtAge(keyFor("chat", "agno"), "chat", FRESH, "green"),
+        rowAtAge(keyFor("d5", "agno", "agentic-chat"), "d5", STALE, "red"),
+      ]);
+      const model = buildCellModel(
+        live,
+        wiredInput("agno", "agentic-chat"),
+        NOW,
+      );
+      expect(model.d5?.status).toBe("red");
+    });
+  });
 });

showcase/shell-dashboard/src/lib/cell-model.ts

@@ -123,15 +123,23 @@ function resolveD4(live: LiveStatusMap, slug: string): TestLevel {
  * Uses `CATALOG_TO_D5_KEY` to map catalog feature IDs to D5 PB row key
  * suffixes. When multiple sub-keys exist (e.g. `beautiful-chat` fans out
  * to 5 pills), worst-state wins.
+ *
+ * Staleness applies the same downgrade as `resolveD3`: a green D5 row whose
+ * `observed_at` is older than `E2E_STALE_AFTER_MS` is downgraded to `amber`
+ * (degraded). When the driver stops writing, a frozen-green row would
+ * otherwise credit D5 forever — the same false-green mode one dimension up.
+ * Only green is downgraded; a stale red/degraded row already signals a
+ * problem and is left as-is.
  */
 function resolveD5(
   live: LiveStatusMap,
   slug: string,
   featureId: string,
+  now: number,
 ): TestLevel {
   const d5Keys = CATALOG_TO_D5_KEY[featureId];
 
-  // No mapping and no fallback row → test doesn't exist for this feature.
+  // No mapping → test doesn't exist for this feature.
   if (!d5Keys || d5Keys.length === 0) {
     return { exists: false, status: null, row: null };
   }
@@ -151,6 +159,10 @@ function resolveD5(
     return { exists: true, status: null, row: null };
   }
 
+  if (worst.state === "green" && isStale(worst, now, E2E_STALE_AFTER_MS)) {
+    return { exists: true, status: "amber", row: worst };
+  }
+
   return {
     exists: true,
     status: stateToTestStatus(worst.state),
@@ -204,12 +216,20 @@ function resolveD3(
  * D6 is an aggregate integration-level signal (`d6:<slug>`), NOT per-cell.
  * The e2e-full driver emits a single row per integration that covers
  * the entire parity comparison against the reference implementation.
+ *
+ * Staleness applies the same downgrade as `resolveD3`: a green D6 row whose
+ * `observed_at` is older than `E2E_STALE_AFTER_MS` is downgraded to `amber`
+ * (degraded), so a frozen-green row from a stalled driver no longer credits
+ * D6 forever. Only green is downgraded; stale red/degraded is left as-is.
  */
-function resolveD6(live: LiveStatusMap, slug: string): TestLevel {
+function resolveD6(live: LiveStatusMap, slug: string, now: number): TestLevel {
   const row = live.get(keyFor("d6", slug)) ?? null;
   if (!row) {
     return { exists: false, status: null, row: null };
   }
+  if (row.state === "green" && isStale(row, now, E2E_STALE_AFTER_MS)) {
+    return { exists: true, status: "amber", row };
+  }
   return {
     exists: true,
     status: stateToTestStatus(row.state),
@@ -272,8 +292,8 @@ export function buildCellModel(
   // ── Wired + supported: resolve each depth independently ───────────
   const d3 = resolveD3(live, slug, featureId, now);
   const d4 = resolveD4(live, slug);
-  const d5 = resolveD5(live, slug, featureId);
-  const d6 = resolveD6(live, slug);
+  const d5 = resolveD5(live, slug, featureId, now);
+  const d6 = resolveD6(live, slug, now);
 
   // ceilingDepth: highest CONTIGUOUS depth where a test EXISTS.
   // D4 only counts if D3 exists; D5 only counts if D4 counts; D6 only