feat(showcase-dashboard): D6-ceiling chip color algorithm + aggregate key

Update depth-utils to treat D6 as an integration-scoped aggregate
(d6:<slug> not d6:<slug>/<featureId>), raise maxPossible from 5 to 6
when D5 mapping exists, and adjust chipColor derivation so D5-green
without D6 yields amber instead of green. Update composed-cell memo
comparator and cell-drilldown dimensions. Comprehensive test updates
across cell-model, depth-utils, compute-tally-detail, unified-cell,
and status-tab.

Author: jpr5

showcase/shell-dashboard/src/components/__tests__/compute-tally-detail.test.tsx

@@ -38,14 +38,19 @@ function makeIntegration(slug: string, demoIds: string[]): Integration {
   return {
     slug,
     name: slug,
+    category: "python",
     language: "python",
+    description: "",
+    repo: "",
     backend_url: `https://${slug}.example.com`,
-    docs_url: "",
-    source_url: "",
+    deployed: true,
+    features: demoIds,
     demos: demoIds.map((id) => ({
       id,
+      name: id,
+      description: "",
+      tags: [],
       route: `/${id}`,
-      command: "",
     })),
   } as Integration;
 }
@@ -56,7 +61,7 @@ function makeFeature(id: string, name: string): Feature {
     name,
     description: "",
     category: "core",
-    kind: "standard",
+    kind: "primary",
   } as Feature;
 }
 
@@ -85,17 +90,18 @@ describe("computeColumnTallyDetail", () => {
     });
   });
 
-  it("green D3 cells land in green bucket", () => {
+  it("green D6 cells land in green bucket", () => {
     const integration = makeIntegration("my-int", ["feat-a", "feat-b"]);
     const features = [
       makeFeature("feat-a", "Feature A"),
       makeFeature("feat-b", "Feature B"),
     ];
 
-    // Both features have green D3 → achievedDepth=3, ceilingDepth=3 → green chip
+    // Both features have green D3 + green D6 → chipColor=green (D6-ceiling)
     const liveStatus: LiveStatusMap = new Map([
       ["e2e:my-int/feat-a", makeRow("e2e:my-int/feat-a", "e2e", "green")],
       ["e2e:my-int/feat-b", makeRow("e2e:my-int/feat-b", "e2e", "green")],
+      ["d6:my-int", makeRow("d6:my-int", "d6", "green")],
     ]);
 
     const result = computeColumnTallyDetail(
@@ -114,15 +120,15 @@ describe("computeColumnTallyDetail", () => {
     expect(result.red).toEqual([]);
   });
 
-  it("red D3 cells are gray (achievedDepth=0) and excluded", () => {
+  it("red D3 → red chip, green D3 without D5/D6 → gray (excluded)", () => {
     const integration = makeIntegration("my-int", ["feat-a", "feat-b"]);
     const features = [
       makeFeature("feat-a", "Feature A"),
       makeFeature("feat-b", "Feature B"),
     ];
 
-    // feat-a: D3=red → achievedDepth=0, ceilingDepth=3 → gray (skipped)
-    // feat-b: D3=green → green chip
+    // feat-a: D3=red → chipColor=red (d1d4GateFails)
+    // feat-b: D3=green but no D5/D6 → chipColor=gray (D6-ceiling)
     const liveStatus: LiveStatusMap = new Map([
       ["e2e:my-int/feat-a", makeRow("e2e:my-int/feat-a", "e2e", "red")],
       ["e2e:my-int/feat-b", makeRow("e2e:my-int/feat-b", "e2e", "green")],
@@ -136,11 +142,11 @@ describe("computeColumnTallyDetail", () => {
     );
 
     expect(result.unknown).toBe(false);
-    expect(result.green).toEqual([
-      { label: "Feature B", dimension: "e2e", featureId: "feat-b" },
-    ]);
+    expect(result.green).toEqual([]);
     expect(result.amber).toEqual([]);
-    expect(result.red).toEqual([]);
+    expect(result.red).toEqual([
+      { label: "Feature A", dimension: "e2e", featureId: "feat-a" },
+    ]);
   });
 
   it("features without demos are gray (unwired) and excluded", () => {
@@ -151,8 +157,10 @@ describe("computeColumnTallyDetail", () => {
       makeFeature("feat-2", "Feature 2"),
     ];
 
+    // D3=green + D6=green → chipColor=green (D6-ceiling algorithm)
     const liveStatus: LiveStatusMap = new Map([
       ["e2e:partial/feat-1", makeRow("e2e:partial/feat-1", "e2e", "green")],
+      ["d6:partial", makeRow("d6:partial", "d6", "green")],
     ]);
 
     const result = computeColumnTallyDetail(
@@ -163,7 +171,7 @@ describe("computeColumnTallyDetail", () => {
     );
 
     expect(result.unknown).toBe(false);
-    // Only feat-1 appears (has a demo); feat-2 is unwired → gray → excluded
+    // feat-1: wired + D3=green + D6=green → green; feat-2: unwired → gray
     expect(result.green).toEqual([
       { label: "Feature 1", dimension: "e2e", featureId: "feat-1" },
     ]);
@@ -203,9 +211,11 @@ describe("computeColumnTallyDetail", () => {
       makeFeature("feat-b", "Feature B"),
     ];
 
+    // D3=green + D6=green → chipColor=green for supported features
     const liveStatus: LiveStatusMap = new Map([
       ["e2e:ns-int/feat-a", makeRow("e2e:ns-int/feat-a", "e2e", "green")],
       ["e2e:ns-int/feat-b", makeRow("e2e:ns-int/feat-b", "e2e", "green")],
+      ["d6:ns-int", makeRow("d6:ns-int", "d6", "green")],
     ]);
 
     const result = computeColumnTallyDetail(
@@ -216,7 +226,7 @@ describe("computeColumnTallyDetail", () => {
     );
 
     expect(result.unknown).toBe(false);
-    // feat-a: green; feat-b: unsupported → gray → excluded
+    // feat-a: D3+D6 green → green; feat-b: unsupported → gray → excluded
     expect(result.green).toEqual([
       { label: "Feature A", dimension: "e2e", featureId: "feat-a" },
     ]);

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

@@ -204,7 +204,7 @@ describe("deriveDepth", () => {
   // ── isRegression now compares against maxPossible, not historical max_depth ──
 
   it("isRegression is true when achieved < maxPossible (D5 mapping exists, CV red)", () => {
-    // "agentic-chat" has D5 mapping → maxPossible=5, achieved=4 → regression
+    // "agentic-chat" has D5 mapping → maxPossible=6, achieved=4 → regression
     const c = cell("lgp", "agentic-chat", "wired", 4);
     const live = mapOf([
       row("health:lgp", "health", "green"),
@@ -215,7 +215,7 @@ describe("deriveDepth", () => {
     ]);
     const result = deriveDepth(c, live);
     expect(result.achieved).toBe(4);
-    expect(result.maxPossible).toBe(5);
+    expect(result.maxPossible).toBe(6);
     expect(result.isRegression).toBe(true);
   });
 
@@ -235,12 +235,12 @@ describe("deriveDepth", () => {
   });
 
   it("isRegression is true when health drops (maxPossible > 0)", () => {
-    // "agentic-chat" has D5 mapping → maxPossible=5, health red → achieved=0
+    // "agentic-chat" has D5 mapping → maxPossible=6, health red → achieved=0
     const c = cell("lgp", "agentic-chat", "wired", 1);
     const live = mapOf([row("health:lgp", "health", "red")]);
     const result = deriveDepth(c, live);
     expect(result.achieved).toBe(0);
-    expect(result.maxPossible).toBe(5);
+    expect(result.maxPossible).toBe(6);
     expect(result.isRegression).toBe(true);
   });
 
@@ -350,15 +350,15 @@ describe("deriveDepth", () => {
     expect(result.achieved).toBe(4);
   });
 
-  it("returns D6 when D0-D5 green plus D6 green", () => {
+  it("returns D6 when D0-D5 green plus D6 green (aggregate key)", () => {
     const c = cell("lgp", "agentic-chat");
     const live = mapOf([
       row("health:lgp", "health", "green"),
       row("agent:lgp", "agent", "green"),
       row("e2e:lgp/agentic-chat", "e2e", "green"),
       row("chat:lgp", "chat", "green"),
       row("d5:lgp/agentic-chat", "d5", "green"),
-      row("d6:lgp/agentic-chat", "d6", "green"),
+      row("d6:lgp", "d6", "green"),
     ]);
     const result = deriveDepth(c, live);
     expect(result.achieved).toBe(6);
@@ -379,7 +379,7 @@ describe("deriveDepth", () => {
   // ── maxPossible computation ──
 
   describe("maxPossible", () => {
-    it("(a) D5 mapping exists, all green → achieved=5, maxPossible=5, chip=GREEN territory", () => {
+    it("(a) D5 mapping exists, D5 green but D6 missing → achieved=5, maxPossible=6, regression", () => {
       const c = cell("lgp", "agentic-chat");
       const live = mapOf([
         row("health:lgp", "health", "green"),
@@ -390,30 +390,29 @@ describe("deriveDepth", () => {
       ]);
       const result = deriveDepth(c, live);
       expect(result.achieved).toBe(5);
-      expect(result.maxPossible).toBe(5);
-      // achieved === maxPossible → at ceiling, no regression
-      expect(result.isRegression).toBe(false);
+      expect(result.maxPossible).toBe(6);
+      // achieved < maxPossible → regression (D6 not yet achieved)
+      expect(result.isRegression).toBe(true);
     });
 
-    it("(a-full) D5+D6 green → achieved=6, maxPossible=5 (D6 is stretch, still at-ceiling)", () => {
+    it("(a-full) D5+D6 green → achieved=6, maxPossible=6, at ceiling", () => {
       const c = cell("lgp", "agentic-chat");
       const live = mapOf([
         row("health:lgp", "health", "green"),
         row("agent:lgp", "agent", "green"),
         row("e2e:lgp/agentic-chat", "e2e", "green"),
         row("chat:lgp", "chat", "green"),
         row("d5:lgp/agentic-chat", "d5", "green"),
-        row("d6:lgp/agentic-chat", "d6", "green"),
+        row("d6:lgp", "d6", "green"),
       ]);
       const result = deriveDepth(c, live);
       expect(result.achieved).toBe(6);
-      expect(result.maxPossible).toBe(5);
-      // depthColorClass treats `depth >= maxDepth` as at-ceiling, so D6
-      // still renders green even though it exceeds the structural cap.
+      expect(result.maxPossible).toBe(6);
+      // achieved === maxPossible → at ceiling, no regression
       expect(result.isRegression).toBe(false);
     });
 
-    it("(b) D5 mapping exists, CV red → achieved=4, maxPossible=5, chip=AMBER territory", () => {
+    it("(b) D5 mapping exists, CV red → achieved=4, maxPossible=6, chip=AMBER territory", () => {
       const c = cell("lgp", "agentic-chat");
       const live = mapOf([
         row("health:lgp", "health", "green"),
@@ -424,11 +423,11 @@ describe("deriveDepth", () => {
       ]);
       const result = deriveDepth(c, live);
       expect(result.achieved).toBe(4);
-      expect(result.maxPossible).toBe(5);
+      expect(result.maxPossible).toBe(6);
       expect(result.isRegression).toBe(true);
     });
 
-    it("(c) D5 mapping exists, CV no data → achieved=4, maxPossible=5, chip=AMBER territory", () => {
+    it("(c) D5 mapping exists, CV no data → achieved=4, maxPossible=6, chip=AMBER territory", () => {
       const c = cell("lgp", "agentic-chat");
       const live = mapOf([
         row("health:lgp", "health", "green"),
@@ -439,7 +438,7 @@ describe("deriveDepth", () => {
       ]);
       const result = deriveDepth(c, live);
       expect(result.achieved).toBe(4);
-      expect(result.maxPossible).toBe(5);
+      expect(result.maxPossible).toBe(6);
       expect(result.isRegression).toBe(true);
     });
 
@@ -471,7 +470,7 @@ describe("deriveDepth", () => {
       expect(result.isRegression).toBe(true);
     });
 
-    it("(f) D2 with maxPossible=5 → chip=RED territory (3 levels below)", () => {
+    it("(f) D2 with maxPossible=6 → chip=RED territory (4 levels below)", () => {
       const c = cell("lgp", "agentic-chat");
       const live = mapOf([
         row("health:lgp", "health", "green"),
@@ -480,8 +479,8 @@ describe("deriveDepth", () => {
       ]);
       const result = deriveDepth(c, live);
       expect(result.achieved).toBe(2);
-      expect(result.maxPossible).toBe(5);
-      // 5 - 2 = 3, which is > 2 → RED territory
+      expect(result.maxPossible).toBe(6);
+      // 6 - 2 = 4, which is > 2 → RED territory
       expect(result.isRegression).toBe(true);
     });
 
@@ -490,7 +489,7 @@ describe("deriveDepth", () => {
       const live = mapOf([]); // no live data
       const result = deriveDepth(c, live);
       expect(result.achieved).toBe(0);
-      expect(result.maxPossible).toBe(5); // D5 mapping exists
+      expect(result.maxPossible).toBe(6); // D5 mapping exists → D6 reachable
       expect(result.isRegression).toBe(true);
     });
 

showcase/shell-dashboard/src/components/__tests__/unified-cell.test.tsx

@@ -165,6 +165,7 @@ function makeModel(overrides?: Partial<CellModel>): CellModel {
     d3: makeLevel(true, "green"),
     d4: makeLevel(true, "green"),
     d5: makeLevel(true, "green"),
+    d6: makeLevel(false),
     achievedDepth: 5,
     ceilingDepth: 5,
     chipColor: "green",

showcase/shell-dashboard/src/components/composed-cell.tsx

@@ -269,7 +269,7 @@ function arePropsEqual(
     keyFor("e2e", slug, featureId),
     keyFor("smoke", slug),
     keyFor("d5", slug, featureId),
-    keyFor("d6", slug, featureId),
+    keyFor("d6", slug),
   ];
   for (const k of directKeys) {
     if (prev.ctx.liveStatus.get(k) !== next.ctx.liveStatus.get(k)) return false;

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

@@ -11,16 +11,13 @@
  *   D3 = e2e:<slug>/<featureId> green (per-cell)
  *   D4 = chat:<slug> OR tools:<slug> green (integration-scoped)
  *   D5 = d5:<slug>/<d5FeatureType> green (per-cell, mapped via CATALOG_TO_D5_KEY)
- *   D6 = d6:<slug>/<featureId> green (per-cell)
+ *   D6 = d6:<slug> green (integration-scoped aggregate)
  *
  * Achieved depth = highest D where ALL lower depths are also green.
  * Short-circuits: if any level is not green, stop there.
  */
-import {
-  keyFor,
-  CATALOG_TO_D5_KEY,
-  type LiveStatusMap,
-} from "@/lib/live-status";
+import { keyFor, CATALOG_TO_D5_KEY } from "@/lib/live-status";
+import type { LiveStatusMap } from "@/lib/live-status";
 
 /** Minimal catalog cell shape consumed by depth derivation. */
 export interface CatalogCell {
@@ -93,12 +90,8 @@ function isD5Green(
  * - D0: always possible for wired/stub cells
  * - D1-D4: always possible if the cell has a feature ID
  * - D5: possible only if CATALOG_TO_D5_KEY[featureId] exists and has entries
- * - D6: a stretch goal, not a structural ceiling — D6 probes are rare and
- *   not registered per-feature, so we treat D5 as the ceiling. A cell that
- *   actually reaches D6 still renders green (depthColorClass treats
- *   `depth >= maxDepth` as at-ceiling), so capping at 5 doesn't penalize
- *   the rare D6 achievers — it just stops penalizing every D5 cell as
- *   "below ceiling" when D6 was never wired.
+ * - D6: possible when a D5 mapping exists (D6 uses an integration-scoped
+ *   aggregate key, so no additional per-feature mapping is needed)
  */
 function computeMaxPossible(cell: CatalogCell): AchievedDepth {
   // Unsupported/unshipped: max possible is 0.
@@ -118,8 +111,8 @@ function computeMaxPossible(cell: CatalogCell): AchievedDepth {
     return 4;
   }
 
-  // D5 mapping exists. D6 is a stretch goal — see fn doc above.
-  return 5;
+  // D5 mapping exists and D6 is reachable.
+  return 6;
 }
 
 /**
@@ -221,8 +214,8 @@ export function deriveDepth(
   }
   achieved = 5;
 
-  // D6: d6:<slug>/<featureId> green (per-cell)
-  if (isGreen(live, keyFor("d6", cell.integration, cell.feature))) {
+  // D6: d6:<slug> green (integration-scoped aggregate)
+  if (isGreen(live, keyFor("d6", cell.integration))) {
     achieved = 6;
   }
 

showcase/shell-dashboard/src/components/status-tab.test.tsx

@@ -36,7 +36,12 @@ function entry(
 describe("StatusTab", () => {
   it("renders schedule table and running panel", () => {
     const { getByTestId } = render(
-      <StatusTab entries={[entry()]} onTrigger={async () => {}} />,
+      <StatusTab
+        entries={[entry()]}
+        onTrigger={async () => {}}
+        selectedProbeId={null}
+        onSelectProbe={() => {}}
+      />,
     );
     expect(getByTestId("status-table")).toBeDefined();
     expect(getByTestId("status-running-panel")).toBeDefined();
@@ -45,7 +50,12 @@ describe("StatusTab", () => {
   it("forwards trigger callback when row trigger is invoked", async () => {
     const onTrigger = vi.fn(async () => {});
     const { getByTestId, getByText } = render(
-      <StatusTab entries={[entry()]} onTrigger={onTrigger} />,
+      <StatusTab
+        entries={[entry()]}
+        onTrigger={onTrigger}
+        selectedProbeId={null}
+        onSelectProbe={() => {}}
+      />,
     );
     fireEvent.click(getByTestId("status-trigger-smoke"));
     fireEvent.click(getByText("Run all"));
@@ -54,7 +64,12 @@ describe("StatusTab", () => {
 
   it("renders idle panel when no entries provided", () => {
     const { getByTestId } = render(
-      <StatusTab entries={[]} onTrigger={async () => {}} />,
+      <StatusTab
+        entries={[]}
+        onTrigger={async () => {}}
+        selectedProbeId={null}
+        onSelectProbe={() => {}}
+      />,
     );
     expect(getByTestId("running-idle")).toBeDefined();
   });