dashboard: founder admin Customers page (Track B)

New /app/admin/customers console for platform admins. Gated on the new
is_platform_admin flag on AuthMeResponse — non-admin users redirect to
root (404-equivalent) instead of seeing a 403, and the sidebar link is
suppressed entirely.

Page surfaces:
- Filter pills (All / Anonymous / Free / Hobby / Pro / Team) + search
- Sortable table: Email · Tier · MRR · Storage · Deploys · Last active · Signed up
- Row click opens CustomerDetailDrawer (right-side slide-in)
- Drawer tabs: Overview / Resources / Activity / Promos
- "Issue promo" modal — kind, value, applies_to, valid_for_days; surfaces
  the generated code with a Copy button
- "Promote / demote tier" modal — requires typed PROMOTE / DEMOTE
  confirmation, computed from current → target tier rank

Backend contract assumed (Track A):
- GET  /api/v1/admin/customers
- GET  /api/v1/admin/customers/:team_id
- POST /api/v1/admin/customers/:team_id/tier
- POST /api/v1/admin/customers/:team_id/promo

23 new tests covering route gating, sorting, filtering, drawer tabs,
promo issuance, and tier-change confirmation. Full suite: 365 passed,
3 skipped (was 342 + 23 new).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: mastermanas805

src/App.tsx

@@ -96,6 +96,13 @@ const SettingsPage = lazy(() =>
 const ContractsPage = lazy(() =>
   import('./pages/ContractsPage').then((m) => ({ default: m.ContractsPage })),
 )
+// AdminCustomersPage — founder console at /app/admin/customers. The page
+// itself reads ctx.me.is_platform_admin and renders a Navigate when the
+// caller isn't an admin, so non-admins never see the route exists. We
+// still lazy-load it so the bytes don't ship for regular users.
+const AdminCustomersPage = lazy(() =>
+  import('./pages/AdminCustomersPage').then((m) => ({ default: m.AdminCustomersPage })),
+)
 
 import { getToken } from './api'
 
@@ -196,6 +203,9 @@ export function AppRoutes() {
           <Route path="billing" element={<BillingPage />} />
           <Route path="settings" element={<SettingsPage />} />
           <Route path="contracts" element={<ContractsPage />} />
+          {/* Admin-only — the page itself renders <Navigate to="/" /> for
+              non-admin users so the route 404s instead of 403s. */}
+          <Route path="admin/customers" element={<AdminCustomersPage />} />
         </Route>
 
         {/* Back-compat: every legacy unprefixed path that used to be a

src/api/index.ts

@@ -10,7 +10,10 @@
 import type {
   Resource, DashboardStack, DashboardDeployment, DeploymentStatus,
   DashboardTeam, BillingDetails, Invoice,
-  TeamMember, TeamInvitation, AuthMeResponse, VaultEntry, ActivityItem
+  TeamMember, TeamInvitation, AuthMeResponse, VaultEntry, ActivityItem,
+  AdminCustomerListResponse, AdminCustomerDetailResponse,
+  AdminIssuePromoInput, AdminIssuePromoResponse,
+  AdminSetTierInput, AdminSetTierResponse,
 } from './types'
 
 export * from './types'
@@ -159,6 +162,10 @@ export async function fetchMe(): Promise<AuthMeResponse> {
      *  field entirely — callers must treat undefined as "no
      *  experiment, render control variant". */
     experiments?: Record<string, string>
+    /** Track A — server-authoritative platform-admin flag. The
+     *  dashboard surfaces the `/app/admin/customers` console only when
+     *  this is `true`. Absent on older API builds → treat as `false`. */
+    is_platform_admin?: boolean
   }
   // No try/catch — errors propagate. The previous fixture fallback masked
   // backend outages by serving the `aanya@acme.dev` mock identity, which
@@ -190,6 +197,7 @@ export async function fetchMe(): Promise<AuthMeResponse> {
       created_at: '',
     },
     experiments: me.experiments,
+    is_platform_admin: me.is_platform_admin === true,
   }
 }
 
@@ -1219,3 +1227,98 @@ export type QuotaWallResponse = {
 export async function fetchQuotaWall(): Promise<QuotaWallResponse> {
   return call<QuotaWallResponse>('/api/v1/usage/wall')
 }
+
+// ─── Admin Customers (Track A — founder console) ────────────────────────
+//
+// Four endpoints back the /app/admin/customers page:
+//   listAdminCustomers       — GET  /api/v1/admin/customers
+//   getAdminCustomer         — GET  /api/v1/admin/customers/:team_id
+//   setAdminCustomerTier     — POST /api/v1/admin/customers/:team_id/tier
+//   issueAdminCustomerPromo  — POST /api/v1/admin/customers/:team_id/promo
+//
+// Track A returns 403 with `agent_action` for non-admin callers; the
+// dashboard's route guard turns the page into a 404 for those users so
+// the route's existence isn't leaked. Other errors propagate so the
+// page renders a real banner instead of silently failing.
+
+/** Filter / sort options accepted by GET /api/v1/admin/customers. The
+ *  query string is built up only for the fields the caller actually sets
+ *  so older API builds that don't yet honour a flag don't get tripped on
+ *  an empty string. */
+export interface ListAdminCustomersInput {
+  /** Free-text search (email, name, team_id substring). */
+  q?: string
+  /** Filter pill — undefined or 'all' returns every tier. */
+  tier?: 'all' | 'anonymous' | 'free' | 'hobby' | 'pro' | 'team' | 'growth'
+  /** Track A sort keys: mrr | last_active | created_at | storage | deployments. */
+  sort_by?: string
+  /** Page size — Track A clamps to 200; default 50. */
+  limit?: number
+  offset?: number
+}
+
+export async function listAdminCustomers(
+  input: ListAdminCustomersInput = {},
+): Promise<AdminCustomerListResponse> {
+  const params = new URLSearchParams()
+  if (input.q && input.q.trim()) params.set('q', input.q.trim())
+  if (input.tier && input.tier !== 'all') params.set('tier', input.tier)
+  if (input.sort_by) params.set('sort_by', input.sort_by)
+  if (input.limit !== undefined) params.set('limit', String(input.limit))
+  if (input.offset !== undefined) params.set('offset', String(input.offset))
+  const qs = params.toString()
+  const path = qs ? `/api/v1/admin/customers?${qs}` : '/api/v1/admin/customers'
+  const r = await call<{
+    ok: boolean
+    customers?: AdminCustomerListResponse['customers']
+    total?: number
+  }>(path)
+  return { ok: true, customers: r.customers ?? [], total: r.total ?? 0 }
+}
+
+export async function getAdminCustomer(
+  teamID: string,
+): Promise<AdminCustomerDetailResponse> {
+  const r = await call<{
+    ok: boolean
+    team?: AdminCustomerDetailResponse['team']
+    users?: AdminCustomerDetailResponse['users']
+    resources?: AdminCustomerDetailResponse['resources']
+    audit_log?: AdminCustomerDetailResponse['audit_log']
+    deploys?: AdminCustomerDetailResponse['deploys']
+    subscription?: AdminCustomerDetailResponse['subscription']
+    promos?: AdminCustomerDetailResponse['promos']
+  }>(`/api/v1/admin/customers/${encodeURIComponent(teamID)}`)
+  return {
+    ok: true,
+    team: r.team ?? ({ id: teamID } as AdminCustomerDetailResponse['team']),
+    users: r.users ?? [],
+    resources: r.resources ?? [],
+    audit_log: r.audit_log ?? [],
+    deploys: r.deploys ?? [],
+    subscription: r.subscription ?? null,
+    promos: r.promos ?? [],
+  }
+}
+
+export async function setAdminCustomerTier(
+  teamID: string,
+  input: AdminSetTierInput,
+): Promise<AdminSetTierResponse> {
+  const r = await call<{ ok: boolean; team: DashboardTeam }>(
+    `/api/v1/admin/customers/${encodeURIComponent(teamID)}/tier`,
+    { method: 'POST', body: JSON.stringify(input) },
+  )
+  return { ok: true, team: r.team }
+}
+
+export async function issueAdminCustomerPromo(
+  teamID: string,
+  input: AdminIssuePromoInput,
+): Promise<AdminIssuePromoResponse> {
+  const r = await call<{ ok: boolean; code: string; expires_at: string | null }>(
+    `/api/v1/admin/customers/${encodeURIComponent(teamID)}/promo`,
+    { method: 'POST', body: JSON.stringify(input) },
+  )
+  return { ok: true, code: r.code, expires_at: r.expires_at ?? null }
+}

src/api/types.ts

@@ -254,4 +254,106 @@ export interface AuthMeResponse {
   team: DashboardTeam
   access_token?: string
   experiments?: Record<string, string>
+  /** Track A platform-admin flag — when true, the dashboard renders the
+   *  `/app/admin/customers` route + sidebar link. Older API builds omit
+   *  the field entirely, in which case the dashboard treats the caller
+   *  as a regular user (404 on the admin route, link hidden). The flag
+   *  is server-authoritative; the dashboard never elevates by itself. */
+  is_platform_admin?: boolean
+}
+
+// ---------- Admin customers (Track A — founder console) ----------
+//
+// Shape of GET /api/v1/admin/customers responses. Track A is shipping
+// the backend in parallel; we mirror the contract here so the dashboard
+// compiles independently. Fields the agent API hasn't pinned yet are
+// marked optional so the adapter can degrade gracefully.
+
+export interface AdminCustomerSummary {
+  team_id: string
+  primary_email: string
+  /** Display name — agents that never set one fall back to the email
+   *  local part on the server side. May be empty for very old teams. */
+  name?: string
+  tier: Tier
+  /** Monthly MRR in INR paise (×100). Track A returns 0 for unpaid teams. */
+  mrr_monthly: number
+  /** Yearly MRR in INR paise — 0 when the team isn't on a yearly plan. */
+  mrr_yearly: number
+  /** Aggregate storage across every resource owned by the team. */
+  storage_bytes: number
+  /** Count of running deployments. */
+  deployments_active: number
+  /** ISO-8601 — last authenticated request (auth, provision, dashboard). */
+  last_active: string | null
+  created_at: string
+}
+
+export interface AdminCustomerListResponse {
+  ok: true
+  customers: AdminCustomerSummary[]
+  total: number
+}
+
+export interface AdminAuditEntry {
+  id: string
+  kind: string
+  summary: string
+  at: string
+  actor?: string
+}
+
+export interface AdminPromoEntry {
+  id: string
+  code: string
+  kind: 'percent_off' | 'first_month_free' | 'amount_off'
+  value: number
+  applies_to: number
+  valid_for_days: number
+  expires_at: string | null
+  created_at: string
+}
+
+export interface AdminSubscriptionInfo {
+  status?: string
+  next_renewal_at?: string | null
+  amount_inr?: number | null
+  razorpay_subscription_id?: string | null
+}
+
+export interface AdminCustomerDetailResponse {
+  ok: true
+  team: DashboardTeam & { primary_email?: string }
+  users: User[]
+  resources: Resource[]
+  audit_log: AdminAuditEntry[]
+  deploys: DashboardDeployment[]
+  subscription: AdminSubscriptionInfo | null
+  promos?: AdminPromoEntry[]
+}
+
+export interface AdminIssuePromoInput {
+  kind: 'percent_off' | 'first_month_free' | 'amount_off'
+  /** Integer — 15 for 15% off; 49 for $49 off; ignored for first_month_free. */
+  value: number
+  /** Integer — 1 = first month only, 3 = first 3 months, 0 = ongoing. */
+  applies_to: number
+  /** Days the code is redeemable for. Default 30. */
+  valid_for_days: number
+}
+
+export interface AdminIssuePromoResponse {
+  ok: true
+  code: string
+  expires_at: string | null
+}
+
+export interface AdminSetTierInput {
+  tier: Tier
+  reason: string
+}
+
+export interface AdminSetTierResponse {
+  ok: true
+  team: DashboardTeam
 }