pi-mega-compact 0.20.59 → 0.20.61

package/extensions/dashboard-client/src/App.tsx

@@ -4,39 +4,53 @@
  * SPRINT-B1: React scaffold with tab routing, header, error boundary.
  * SPRINT-C1+: tabs wired progressively with real content.
  * SPRINT-V2: NEW_UI flag splits OldDashboard (legacy) from NewDashboard (AppShell).
+ * DASH-0d: the `TabContent` lazy list + switch consolidate onto the 7 fixed
+ * navigational surfaces (Overview, Sessions, Cache+Performance, Memory Graph,
+ * Diagnostics, Setup, Admin) behind MEGACOMPACT_DASH_0D. An additive hash router
+ * maps every legacy #deep-link to a live consolidated surface. Flag-OFF
+ * reproduces the pre-rollup 13-tab surface list byte-identically (the
+ * DASH-0D-LEGACY region). The consolidated rendering is the DASH-0D-CONSOLIDATED
+ * region — both are parsed by scripts/dash-tab-count.mjs.
  */
 
-import React, { useState, useCallback } from "react";
+import React, { useState, useEffect, useCallback } from "react";
 import { ErrorBoundary } from "./components/ErrorBoundary";
 import { TabBar } from "./components/TabBar";
 import { LoadingSpinner } from "./components/LoadingSpinner";
 import { useApi } from "./hooks/useApi";
-import { fetchSnapshot } from "./api/client";
-import type { SnapshotResponse } from "@contracts";
+import { fetchSnapshot, fetchSettings } from "./api/client";
+import type { SnapshotResponse, SettingsResponse } from "@contracts";
 import { NEW_UI } from "./config";
 import { AppShell } from "./components/layout/AppShell";
 import {
   PRIMARY_TABS,
   ADVANCED_TABS,
   ADVANCED_TAB_IDS as advancedTabIds,
+  DASH_SURFACE_IDS,
+  DASH_SURFACE_LABELS,
   type TabId,
+  type DashTabId,
 } from "./tabs/registry";
+import { useHashTab } from "./tabs/dashHashRouter";
 export type { TabId };
 
-// Tab components — lazy-loaded. C1 fills Overview + Events; C2/C3 fill the rest.
+// Tab components — lazy-loaded. DASH-0d: the consolidated 7 host components come
+// from the merged barrel homes; the 13 legacy-only components stay for flag-off.
 const OverviewTab = React.lazy(() => import("./tabs/OverviewTab"));
+const SessionsTab = React.lazy(() => import("./tabs/SessionsTab"));
+const CacheTab = React.lazy(() => import("./tabs/CacheTab"));
+const MemoryMapTab = React.lazy(() => import("./tabs/MemoryMapTab"));
+const VectorCortexTab = React.lazy(() => import("./tabs/VectorCortexTab"));
+const SetupTab = React.lazy(() => import("./tabs/SetupTab"));
+const AdminTab = React.lazy(() => import("./tabs/AdminTab"));
+// Legacy-only host components (flag-off pre-rollup surface set).
 const ReposTab = React.lazy(() => import("./tabs/ReposTab"));
 const EventsTab = React.lazy(() => import("./tabs/EventsTab"));
-const SetupTab = React.lazy(() => import("./tabs/SetupTab"));
 const MetricsTab = React.lazy(() => import("./tabs/MetricsTab"));
-const CacheTab = React.lazy(() => import("./tabs/CacheTab"));
-const SessionsTab = React.lazy(() => import("./tabs/SessionsTab"));
 const WikiTab = React.lazy(() => import("./tabs/WikiTab"));
 const TurnsTab = React.lazy(() => import("./tabs/TurnsTab"));
 const MaintenanceTab = React.lazy(() => import("./tabs/MaintenanceTab"));
-const MemoryMapTab = React.lazy(() => import("./tabs/MemoryMapTab"));
 const HealthTab = React.lazy(() => import("./tabs/HealthTab"));
-const VectorCortexTab = React.lazy(() => import("./tabs/VectorCortexTab"));
 
 interface AppState {
   snapshot: SnapshotResponse | null;
@@ -44,7 +58,52 @@ interface AppState {
   error: Error | null;
 }
 
-function TabContent({
+const DASH_0D_KEY = "MEGACOMPACT_DASH_0D";
+
+/**
+ * Resolve the DASH-0d consolidation flag from the server-authoritative
+ * `/api/rag-settings` state (the dashboard client has no `process` global).
+ * Absent/not-yet-loaded => true (default ON), matching the server default.
+ */
+function dash0dEnabled(settings: SettingsResponse | null): boolean {
+  if (!settings) return true;
+  for (const cat of settings.categories) {
+    for (const s of cat.settings) {
+      if (s.key === DASH_0D_KEY && s.type === "boolean") return s.value === true;
+    }
+  }
+  return true;
+}
+
+/** The unified active-tab state: a legacy 13-tab TabId OR a consolidated surface. */
+type ActiveTab = TabId | DashTabId;
+
+/** Consolidated 7-surface content (DASH-0d). Parsed by scripts/dash-tab-count.mjs. */
+function ConsolidatedContent({
+  activeTab,
+  snapshot,
+  loading,
+  error,
+}: AppState & { activeTab: DashTabId }): React.ReactElement {
+  return (
+    <React.Suspense fallback={<LoadingSpinner />}>
+      {/* DASH-0D-CONSOLIDATED */}
+      {activeTab === "overview" && (
+        <OverviewTab snapshot={snapshot} loading={loading} error={error} />
+      )}
+      {activeTab === "sessions" && <SessionsTab />}
+      {activeTab === "cache-perf" && <CacheTab />}
+      {activeTab === "memory-graph" && <MemoryMapTab />}
+      {activeTab === "diagnostics" && <VectorCortexTab />}
+      {activeTab === "setup" && <SetupTab />}
+      {activeTab === "admin" && <AdminTab />}
+      {/* DASH-0D-CONSOLIDATED-END */}
+    </React.Suspense>
+  );
+}
+
+/** Pre-rollup 13-tab content (flag-off). Parsed by scripts/dash-tab-count.mjs. */
+function LegacyContent({
   activeTab,
   snapshot,
   loading,
@@ -52,6 +111,7 @@ function TabContent({
 }: AppState & { activeTab: TabId }): React.ReactElement {
   return (
     <React.Suspense fallback={<LoadingSpinner />}>
+      {/* DASH-0D-LEGACY */}
       {activeTab === "overview" && (
         <OverviewTab snapshot={snapshot} loading={loading} error={error} />
       )}
@@ -67,6 +127,7 @@ function TabContent({
       {activeTab === "memory-map" && <MemoryMapTab />}
       {activeTab === "health" && <HealthTab />}
       {activeTab === "vector-cortex" && <VectorCortexTab />}
+      {/* DASH-0D-LEGACY-END */}
     </React.Suspense>
   );
 }
@@ -102,7 +163,7 @@ function OldDashboard({
           onTabChange={setActiveTab}
         />
         <main className="dashboard-content">
-          <TabContent activeTab={activeTab} snapshot={snapshot} loading={loading} error={error} />
+          <LegacyContent activeTab={activeTab} snapshot={snapshot} loading={loading} error={error} />
         </main>
       </div>
     </ErrorBoundary>
@@ -122,14 +183,40 @@ function NewDashboard({
   return (
     <ErrorBoundary>
       <AppShell active={activeTab} onTabChange={setActiveTab} snapshot={snapshot}>
-        <TabContent activeTab={activeTab} snapshot={snapshot} loading={loading} error={error} />
+        <LegacyContent activeTab={activeTab} snapshot={snapshot} loading={loading} error={error} />
       </AppShell>
     </ErrorBoundary>
   );
 }
 
+/** DASH-0d consolidated 7-surface navigation rail (flag-ON New UI path). */
+function ConsolidatedNav({
+  active,
+  onSelect,
+}: {
+  active: DashTabId;
+  onSelect: (id: DashTabId) => void;
+}): React.ReactElement {
+  return (
+    <nav className="consolidated-nav" role="tablist" aria-label="Dashboard surfaces">
+      {DASH_SURFACE_IDS.map((id) => (
+        <button
+          key={id}
+          type="button"
+          role="tab"
+          aria-selected={active === id}
+          className={active === id ? "active" : ""}
+          onClick={() => onSelect(id)}
+        >
+          {DASH_SURFACE_LABELS[id] ?? id}
+        </button>
+      ))}
+    </nav>
+  );
+}
+
 export default function App(): React.ReactElement {
-  const [activeTab, setActiveTab] = useState<TabId>("overview");
+  const [activeTab, setActiveTab] = useState<ActiveTab>("overview");
   const {
     data: snapshot,
     loading,
@@ -142,11 +229,57 @@ export default function App(): React.ReactElement {
     },
   );
 
+  // Server-resolved DASH-0d flag (default ON when settings absent).
+  const { data: settingsData } = useApi<SettingsResponse>(
+    useCallback(() => fetchSettings(), []),
+    { pollInterval: 0, maxRetries: 0 },
+  );
+  const dash0dOn = dash0dEnabled(settingsData);
+
+  // Additive hash→surface deep-link router: every legacy #hash maps to a live
+  // consolidated surface; empty hash keeps current behavior (default overview).
+  // Only active under the DASH-0d 7-surface rendering — flag-off keeps the
+  // pre-rollup 13-tab behavior unchanged (hash ignored).
+  const hashSurface = useHashTab();
+  useEffect(() => {
+    if (dash0dOn && hashSurface != null) setActiveTab(hashSurface);
+  }, [dash0dOn, hashSurface]);
+
+  // Flag-ON consolidated New-UI surface: a 7-surface rail + the consolidated
+  // content. Flag-OFF (or legacy NEW_UI false) renders the 13-tab path as today.
+  if (NEW_UI() && dash0dOn) {
+    const current = DASH_SURFACE_IDS.includes(activeTab as DashTabId)
+      ? (activeTab as DashTabId)
+      : "overview";
+    return (
+      <ErrorBoundary>
+        <div className="dashboard-app">
+          <header className="dashboard-header">
+            <h1>mega-compact dashboard <span className="tier">{snapshot?.tier ?? "unknown"}</span></h1>
+          </header>
+          <ConsolidatedNav active={current} onSelect={(id: DashTabId) => setActiveTab(id)} />
+          <main className="dashboard-content">
+            <ConsolidatedContent
+              activeTab={current}
+              snapshot={snapshot}
+              loading={loading}
+              error={error}
+            />
+          </main>
+        </div>
+      </ErrorBoundary>
+    );
+  }
+
+  // Flag-off (or legacy NEW_UI): always a legacy TabId (hash routing is gated
+  // on dash0dOn above, so activeTab stays a 13-tab id here).
+  const legacyTab = (activeTab as TabId) ?? "overview";
+
   if (NEW_UI()) {
     return (
       <NewDashboard
-        activeTab={activeTab}
-        setActiveTab={setActiveTab}
+        activeTab={legacyTab}
+        setActiveTab={(id: TabId) => setActiveTab(id)}
         snapshot={snapshot}
         loading={loading}
         error={error}
@@ -156,8 +289,8 @@ export default function App(): React.ReactElement {
 
   return (
     <OldDashboard
-      activeTab={activeTab}
-      setActiveTab={setActiveTab}
+      activeTab={legacyTab}
+      setActiveTab={(id: TabId) => setActiveTab(id)}
       snapshot={snapshot}
       loading={loading}
       error={error}

package/extensions/dashboard-client/src/tabs/AdminTab.tsx

@@ -0,0 +1,81 @@
+/**
+ * dashboard-client/src/tabs/AdminTab.tsx — Admin tab (DASH-0c delegate-shell).
+ *
+ * DASH-0c: the Admin surface combines the maintenance actions with the config
+ * editor. A `AdminViews` toggle ("maintenance" / "config") switches between
+ * `MaintenanceTab` (the maintenance shell over MaintenanceTab/*) and `ConfigTab`
+ * (the config editor). Both bodies are UNCHANGED — only their hosting changes to
+ * this new delegate-shell. `MaintenanceTab.tsx` and `ConfigTab.tsx` stay importable
+ * from their original hosts (`ConfigTab` also stays wired into SetupTab per the
+ * dual-host note). Flag-ON renders the toggle + both views; flag-OFF renders only
+ * the maintenance view (the predecessor's `admin → MaintenanceTab` mapping),
+ * and App.tsx keeps its current TabId routing this sprint (DASH-0d rewires).
+ *
+ * Flag: `MEGACOMPACT_DASH_0C` default ON. The dashboard client is a browser
+ * bundle with NO `process` global, so the positive sprint flag cannot be read
+ * server-side-style (`process.env`) inside the client. Instead the flag is read
+ * from the server-authoritative `/api/rag-settings` state: the server resolves
+ * `process.env["MEGACOMPACT_DASH_0C"] ?? default` into the `SettingState.value`
+ * boolean.
+ */
+
+import type React from "react";
+import { useCallback, useState } from "react";
+import type { SettingsResponse } from "@contracts";
+import { useApi } from "../hooks/useApi";
+import { fetchSettings } from "../api/client";
+import { Toggle } from "../components/ui/toggle";
+import MaintenanceTab from "./MaintenanceTab";
+import ConfigTab from "./ConfigTab";
+
+const DASH_0C_KEY = "MEGACOMPACT_DASH_0C";
+
+/** Resolve the DASH-0c consolidation flag from the server settings state.
+ *  Absent/not-yet-loaded => false (flag-off posture), so flag-off users never
+ *  see the toggle flash; the toggle appears only once settings confirm it is ON. */
+function dash0cEnabled(settings: SettingsResponse | null): boolean {
+	if (!settings) return false;
+	for (const cat of settings.categories) {
+		for (const s of cat.settings) {
+			if (s.key === DASH_0C_KEY && s.type === "boolean") return s.value === true;
+		}
+	}
+	return false;
+}
+
+type AdminViews = "maintenance" | "config";
+
+export default function AdminTab(): React.ReactElement {
+	const [view, setView] = useState<AdminViews>("maintenance");
+
+	const { data: settingsData } = useApi<SettingsResponse>(
+		useCallback(() => fetchSettings(), []),
+		{ pollInterval: 0, maxRetries: 0 },
+	);
+	const dash0cOn = dash0cEnabled(settingsData);
+
+	if (!dash0cOn) {
+		return <MaintenanceTab />;
+	}
+
+	return (
+		<div className="flex flex-col gap-4">
+			<div
+				className="flex items-center gap-2"
+				role="tablist"
+				aria-label="Admin views"
+			>
+				<Toggle
+					pressed={view === "maintenance"}
+					onClick={() => setView("maintenance")}
+				>
+					Maintenance
+				</Toggle>
+				<Toggle pressed={view === "config"} onClick={() => setView("config")}>
+					Config
+				</Toggle>
+			</div>
+			{view === "maintenance" ? <MaintenanceTab /> : <ConfigTab />}
+		</div>
+	);
+}

package/extensions/dashboard-client/src/tabs/CacheTab/MetricsCards.tsx

@@ -0,0 +1,66 @@
+/**
+ * dashboard-client/src/tabs/CacheTab/MetricsCards.tsx — Performance cards (C2),
+ * moved VERBATIM from the top-level MetricsTab.tsx.
+ *
+ * DASH-0c: the Cache+Performance surface absorbs MetricsTab as a Performance
+ * section. This file holds the byte-preserved metrics body (the `MetricsCards`
+ * component). The standalone `tabs/MetricsTab.tsx` is reduced to a shell that
+ * re-exports it (kept for the #metrics deep-link + rollback symmetry). Only the
+ * export name changed (MetricsTab → MetricsCards); the render body is otherwise
+ * identical.
+ *
+ * Fetches /api/perf (rolling-window aggregates) + /api/snapshot (for model).
+ * Renders ModelBadge + PerfChart + 5 perf cards (latency, throughput, process,
+ * snapshot cost, TUI lag proxy). Polls every 10s.
+ */
+
+import type React from "react";
+import { useCallback } from "react";
+import { useApi } from "../../hooks/useApi";
+import { fetchPerf, fetchSnapshot } from "../../api/client";
+import type { PerfResponse, SnapshotResponse } from "@contracts";
+import { NEW_UI } from "../../config";
+import { PerfChart } from "../../components/PerfChart";
+import { PerfCards } from "../../components/PerfCards";
+import { ModelBadge } from "../../components/ModelBadge";
+import { RagDashboard } from "../../components/RagDashboard";
+
+export function MetricsCards(): React.ReactElement {
+	const { data: perf, error: perfErr } = useApi<PerfResponse>(
+		useCallback(() => fetchPerf({ minutes: 30 }), []),
+		{ pollInterval: 10_000 },
+	);
+	const { data: snapshot } = useApi<SnapshotResponse>(
+		useCallback(() => fetchSnapshot(), []),
+		{ pollInterval: 10_000 },
+	);
+
+	if (perfErr && !perf) {
+		return (
+			<div className="tab-stub">Error loading perf: {perfErr.message}</div>
+		);
+	}
+	if (!perf) {
+		return <div className="tab-stub">Loading perf…</div>;
+	}
+
+	return (
+		<div className="flex flex-col gap-4">
+			{snapshot?.model && (
+				<ModelBadge
+					name={snapshot.model.name}
+					providerName={snapshot.model.providerName}
+					provider={snapshot.model.provider}
+					inputRate={snapshot.model.inputRate}
+					outputRate={snapshot.model.outputRate}
+				/>
+			)}
+			<PerfChart perf={perf} />
+			<PerfCards perf={perf} />
+			<div className="text-xs text-muted-foreground">
+				{perf.sampleCount} samples · updated {perf.updatedAt}
+			</div>
+			{NEW_UI() && <RagDashboard />}
+		</div>
+	);
+}

package/extensions/dashboard-client/src/tabs/CacheTab.tsx

@@ -18,6 +18,7 @@ import type {
 	CacheStripesResponse,
 	PerfResponse,
 	PrefixStabilityResponse,
+	SettingsResponse,
 } from "@contracts";
 import { useApi } from "../hooks/useApi";
 import {
@@ -26,6 +27,7 @@ import {
 	fetchCacheStripes,
 	fetchPrefixStability,
 	fetchPerf,
+	fetchSettings,
 } from "../api/client";
 import { CacheHitsCard } from "../components/CacheHitsCard";
 import { TimeSavedCard } from "../components/TimeSavedCard";
@@ -35,6 +37,25 @@ import { CacheHitRateTrendCard } from "../components/CacheHitRateTrendCard";
 import { PrefixStabilityCard } from "../components/PrefixStabilityCard";
 import { Button } from "../components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "../components/ui/card";
+import { MetricsCards } from "./CacheTab/MetricsCards";
+
+const DASH_0C_KEY = "MEGACOMPACT_DASH_0C";
+
+/** Resolve the DASH-0c consolidation flag from the server settings state.
+ *  The dashboard client is a browser bundle with NO `process` global, so the
+ *  positive sprint flag is read from the server-authoritative /api/rag-settings
+ *  state (the server resolves MEGACOMPACT_DASH_0C into a SettingState boolean).
+ *  Absent/not-yet-loaded => false (flag-off posture), so flag-off users never
+ *  see the Performance section flash; it mounts only once settings confirm ON. */
+function dash0cEnabled(settings: SettingsResponse | null): boolean {
+	if (!settings) return false;
+	for (const cat of settings.categories) {
+		for (const s of cat.settings) {
+			if (s.key === DASH_0C_KEY && s.type === "boolean") return s.value === true;
+		}
+	}
+	return false;
+}
 
 export default function CacheTab(): React.ReactElement {
 	const [infoExpanded, setInfoExpanded] = useState(false);
@@ -87,6 +108,13 @@ export default function CacheTab(): React.ReactElement {
 		{ pollInterval: 5000 },
 	);
 
+	/* --- DASH-0c: server-resolved settings state for the flag gate --- */
+	const { data: settingsData } = useApi<SettingsResponse>(
+		useCallback(() => fetchSettings(), []),
+		{ pollInterval: 0, maxRetries: 0 },
+	);
+	const dash0cOn = dash0cEnabled(settingsData);
+
 	return (
 		<div className="flex flex-col gap-4">
 			<div>
@@ -223,6 +251,24 @@ export default function CacheTab(): React.ReactElement {
 					);
 				})()
 			)}
+			{/* ==============================================================
+			    Section 5 -- Performance (DASH-0c)
+			    The metrics body (ModelBadge + PerfChart + PerfCards + RagDashboard)
+			    absorbed from MetricsTab as a Performance section. Moved VERBATIM to
+			    ./CacheTab/MetricsCards.tsx. Omitted entirely when flag-off so the
+			    cache-only body is byte-identical to the predecessor.
+			    ============================================================== */}
+			{dash0cOn && (
+				<section aria-labelledby="cache-perf-cards">
+					<h2
+						id="cache-perf-cards"
+						className="font-heading text-lg font-semibold"
+					>
+						Performance
+					</h2>
+					<MetricsCards />
+				</section>
+			)}
 		</div>
 	);
 }

package/extensions/dashboard-client/src/tabs/MetricsTab.tsx

@@ -1,58 +1,17 @@
 /**
- * dashboard-client/src/tabs/MetricsTab.tsx — Metrics tab (C2).
+ * dashboard-client/src/tabs/MetricsTab.tsx — Metrics tab (C2) shell.
  *
- * Fetches /api/perf (rolling-window aggregates) + /api/snapshot (for model).
- * Renders ModelBadge + PerfChart + 5 perf cards (latency, throughput, process,
- * snapshot cost, TUI lag proxy). Polls every 10s.
+ * DASH-0c: the Cache+Performance surface absorbs the metrics body as a
+ * Performance section; this file is reduced to a shell that re-exports
+ * `MetricsCards` (the byte-preserved body moved to ./CacheTab/MetricsCards.tsx).
+ * Kept as a deep-link anchor for #metrics and for rollback symmetry (flag-off
+ * renders MetricsTab as a standalone top-level surface). A DASH-0d cleanup deletes
+ * this standalone copy after a deep-link audit proves no live consumer points
+ * at it. The render body is otherwise identical to the pre-DASH-0c MetricsTab.
  */
 
-import type React from "react";
-import { useCallback } from "react";
-import { useApi } from "../hooks/useApi";
-import { fetchPerf, fetchSnapshot } from "../api/client";
-import type { PerfResponse, SnapshotResponse } from "@contracts";
-import { NEW_UI } from "../config";
-import { PerfChart } from "../components/PerfChart";
-import { PerfCards } from "../components/PerfCards";
-import { ModelBadge } from "../components/ModelBadge";
-import { RagDashboard } from "../components/RagDashboard";
+import { MetricsCards } from "./CacheTab/MetricsCards";
 
 export default function MetricsTab(): React.ReactElement {
-	const { data: perf, error: perfErr } = useApi<PerfResponse>(
-		useCallback(() => fetchPerf({ minutes: 30 }), []),
-		{ pollInterval: 10_000 },
-	);
-	const { data: snapshot } = useApi<SnapshotResponse>(
-		useCallback(() => fetchSnapshot(), []),
-		{ pollInterval: 10_000 },
-	);
-
-	if (perfErr && !perf) {
-		return (
-			<div className="tab-stub">Error loading perf: {perfErr.message}</div>
-		);
-	}
-	if (!perf) {
-		return <div className="tab-stub">Loading perf…</div>;
-	}
-
-	return (
-		<div className="flex flex-col gap-4">
-			{snapshot?.model && (
-				<ModelBadge
-					name={snapshot.model.name}
-					providerName={snapshot.model.providerName}
-					provider={snapshot.model.provider}
-					inputRate={snapshot.model.inputRate}
-					outputRate={snapshot.model.outputRate}
-				/>
-			)}
-			<PerfChart perf={perf} />
-			<PerfCards perf={perf} />
-			<div className="text-xs text-muted-foreground">
-				{perf.sampleCount} samples · updated {perf.updatedAt}
-			</div>
-			{NEW_UI() && <RagDashboard />}
-		</div>
-	);
+	return <MetricsCards />;
 }

package/extensions/dashboard-client/src/tabs/SetupTab.tsx

@@ -10,7 +10,8 @@
  * no external network calls.
  */
 import type React from "react";
-import { useState, useMemo } from "react";
+import { useState, useMemo, useCallback } from "react";
+import type { SettingsResponse } from "@contracts";
 import GameTab from "./GameTab";
 import AchievementsTab from "./AchievementsTab";
 import ConfigTab from "./ConfigTab";
@@ -18,8 +19,26 @@ import EmbedderSetup from "./SetupTab/EmbedderSetup";
 import ThresholdsPanel from "./SetupTab/ThresholdsPanel";
 import CortexSetup from "./SetupTab/CortexSetup";
 import { Toggle } from "../components/ui/toggle";
+import { useApi } from "../hooks/useApi";
+import { fetchSettings } from "../api/client";
 import { useSetupCortexPoll, isCortexSubTabVisible } from "./useSetupCortexPoll";
 
+const DASH_0C_KEY = "MEGACOMPACT_DASH_0C";
+
+/** Resolve the DASH-0c consolidation flag from the server settings state.
+ *  Absent/not-yet-loaded => false (flag-off posture), so flag-off users keep the
+ *  Config sub-tab; it is hidden only once settings confirm the flag is ON (the
+ *  config editor then lives solely on the Admin surface). */
+function dash0cEnabled(settings: SettingsResponse | null): boolean {
+	if (!settings) return false;
+	for (const cat of settings.categories) {
+		for (const s of cat.settings) {
+			if (s.key === DASH_0C_KEY && s.type === "boolean") return s.value === true;
+		}
+	}
+	return false;
+}
+
 type SetupSubTab =
 	| "embedder"
 	| "thresholds"
@@ -43,11 +62,21 @@ export default function SetupTab(): React.ReactElement {
 	const [subTab, setSubTab] = useState<SetupSubTab>("embedder");
 	const [cortex] = useSetupCortexPoll();
 
+	/* DASH-0c: flag-ON hides the config sub-tab member (the config editor is then
+	 * reachable only via the Admin surface). Flag-OFF renders config as today. */
+	const { data: settingsData } = useApi<SettingsResponse>(
+		useCallback(() => fetchSettings(), []),
+		{ pollInterval: 0, maxRetries: 0 },
+	);
+	const dash0cOn = dash0cEnabled(settingsData);
+
 	const subTabs = useMemo(() => {
-		const tabs = [...BASE_SUB_TABS];
+		const tabs = dash0cOn
+			? BASE_SUB_TABS.filter((t) => t.id !== "config")
+			: [...BASE_SUB_TABS];
 		if (isCortexSubTabVisible(cortex.data)) tabs.push(CORTEX_TAB);
 		return tabs;
-	}, [cortex.data]);
+	}, [cortex.data, dash0cOn]);
 
 	return (
 		<div className="mx-auto flex max-w-3xl flex-col gap-4 p-4">
@@ -68,7 +97,7 @@ export default function SetupTab(): React.ReactElement {
 
 			{subTab === "embedder" && <EmbedderSetup />}
 			{subTab === "thresholds" && <ThresholdsPanel />}
-			{subTab === "config" && <ConfigTab />}
+			{subTab === "config" && !dash0cOn && <ConfigTab />}
 			{subTab === "game" && <GameTab />}
 			{subTab === "achievements" && <AchievementsTab />}
 			{subTab === "cortex" && <CortexSetup />}