@stigmer/react 3.12.3 → 3.12.5

package/src/organization/__tests__/OrgProfilePanel.test.tsx

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  OrganizationSchema,
+  type Organization,
+} from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/api_pb";
+import type { OrganizationInput } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { DeploymentModeContext } from "../../deployment-mode";
+import { OrgProfilePanel } from "../OrgProfilePanel";
+
+/**
+ * Regression suite for the full-spec-replace wipe bug (oss#293 Phase 1):
+ * `organization.update()` wholesale replaces the stored spec, so a profile
+ * save that sends only the edited fields silently wipes every other mutable
+ * spec field — most visibly `spec.preferences.standing_context` set via the
+ * CLI or the preferences page. The panel must spread the complete mapped
+ * input and override only what it edits.
+ */
+
+const ORG: Organization = create(OrganizationSchema, {
+  metadata: {
+    id: "acme",
+    name: "Acme Corp",
+    slug: "acme",
+    org: "acme",
+  },
+  spec: {
+    description: "We make everything.",
+    logoUrl: "https://acme.example/logo.png",
+    preferences: { standingContext: "We deploy to us-east-1." },
+  },
+});
+
+function createMockStigmer(overrides?: {
+  update?: ReturnType<typeof vi.fn>;
+}) {
+  return {
+    organization: {
+      get: vi.fn(async () => ORG),
+      update: overrides?.update ?? vi.fn(async () => ORG),
+    },
+  } as never;
+}
+
+// Deployment mode "local" keeps the IdentityProvidersSummary sub-panel
+// inert (identity_provider is cloud-only), so no extra client stubs are
+// needed — the suite tests the form, not the summary.
+function renderPanel(client: unknown) {
+  return render(
+    <StigmerContext.Provider value={client as never}>
+      <DeploymentModeContext.Provider value="local">
+        <OrgProfilePanel orgId="acme" />
+      </DeploymentModeContext.Provider>
+    </StigmerContext.Provider>,
+  );
+}
+
+afterEach(cleanup);
+
+describe("OrgProfilePanel save payload", () => {
+  it("round-trips unedited spec fields — preferences survive a profile save", async () => {
+    const update = vi.fn(async (_input: OrganizationInput) => ORG);
+    const client = createMockStigmer({ update });
+    renderPanel(client);
+
+    // Wait for the server-sync effect to fill the form before editing —
+    // interacting on first appearance races the sync.
+    const description = await screen.findByLabelText("Description");
+    await waitFor(() =>
+      expect(description).toHaveProperty("value", "We make everything."),
+    );
+    fireEvent.change(description, { target: { value: "New description" } });
+    fireEvent.click(screen.getByRole("button", { name: "Save changes" }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    const input = update.mock.calls[0]![0];
+
+    // The edited field.
+    expect(input.description).toBe("New description");
+    // The unedited fields the form does not render — the wipe-bug guard.
+    expect(input.preferences).toEqual({
+      standingContext: "We deploy to us-east-1.",
+    });
+    expect(input.logoUrl).toBe("https://acme.example/logo.png");
+    // Addressing fields for the update pipeline's org+slug lookup.
+    expect(input.org).toBe("acme");
+    expect(input.slug).toBe("acme");
+    expect(input.name).toBe("Acme Corp");
+  });
+
+  it("sends the edited name and keeps discard/dirty semantics intact", async () => {
+    const update = vi.fn(async (_input: OrganizationInput) => ORG);
+    renderPanel(createMockStigmer({ update }));
+
+    const name = await screen.findByLabelText("Name");
+    await waitFor(() => expect(name).toHaveProperty("value", "Acme Corp"));
+    fireEvent.change(name, { target: { value: "Acme Corporation" } });
+    fireEvent.click(screen.getByRole("button", { name: "Save changes" }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    expect(update.mock.calls[0]![0].name).toBe("Acme Corporation");
+    expect(update.mock.calls[0]![0].preferences).toEqual({
+      standingContext: "We deploy to us-east-1.",
+    });
+  });
+});

package/src/organization/index.ts

@@ -16,5 +16,7 @@ export { CreateOrganizationForm } from "./CreateOrganizationForm.js";
 export type { CreateOrganizationFormProps } from "./CreateOrganizationForm.js";
 export { OrgProfilePanel } from "./OrgProfilePanel.js";
 export type { OrgProfilePanelProps } from "./OrgProfilePanel.js";
+export { OrgPreferencesPanel } from "./OrgPreferencesPanel.js";
+export type { OrgPreferencesPanelProps } from "./OrgPreferencesPanel.js";
 export { OrgSwitcher } from "./OrgSwitcher.js";
 export type { OrgSwitcherProps } from "./OrgSwitcher.js";

package/src/platform-client/CreatePlatformClientForm.tsx

@@ -2,6 +2,7 @@
 
 import { type FormEvent, type KeyboardEvent, useCallback, useId, useState } from "react";
 import { cn } from "@stigmer/theme";
+import { UNSTYLED_FIELDSET } from "../internal/element-resets.js";
 import { getUserMessage } from "@stigmer/sdk";
 import { IamRole } from "@stigmer/protos/ai/stigmer/iam/v1/enum_pb";
 import type { PlatformClientCreateResponse } from "@stigmer/protos/ai/stigmer/iam/platformclient/v1/io_pb";
@@ -167,7 +168,7 @@ export function CreatePlatformClientForm({
       />
 
       {/* Expiry */}
-      <fieldset className="stg:space-y-2" disabled={isCreating}>
+      <fieldset className={cn(UNSTYLED_FIELDSET, "stg:space-y-2")} disabled={isCreating}>
         <legend className="stg:text-xs stg:font-medium stg:text-foreground">
           Expiry
         </legend>
@@ -202,7 +203,7 @@ export function CreatePlatformClientForm({
       </fieldset>
 
       {/* JIT provisioning */}
-      <fieldset className="stg:space-y-2.5" disabled={isCreating}>
+      <fieldset className={cn(UNSTYLED_FIELDSET, "stg:space-y-2.5")} disabled={isCreating}>
         <hr className="stg:border-border-muted" />
         <legend className="stg:text-xs stg:font-medium stg:text-foreground">
           JIT provisioning
@@ -263,7 +264,7 @@ export function CreatePlatformClientForm({
       </fieldset>
 
       {/* Allowed origins */}
-      <fieldset className="stg:space-y-2" disabled={isCreating}>
+      <fieldset className={cn(UNSTYLED_FIELDSET, "stg:space-y-2")} disabled={isCreating}>
         <hr className="stg:border-border-muted" />
         <legend className="stg:text-xs stg:font-medium stg:text-foreground">
           Allowed origins

package/src/platform-client/PlatformClientDetailPanel.tsx

@@ -2,6 +2,7 @@
 
 import { type FormEvent, type KeyboardEvent, useCallback, useId, useState } from "react";
 import { cn } from "@stigmer/theme";
+import { UNSTYLED_FIELDSET } from "../internal/element-resets.js";
 import { getUserMessage } from "@stigmer/sdk";
 import { IamRole } from "@stigmer/protos/ai/stigmer/iam/v1/enum_pb";
 import { timestampDate, type Timestamp } from "@bufbuild/protobuf/wkt";
@@ -302,7 +303,7 @@ export function PlatformClientDetailPanel({
           </div>
 
           {/* Expiry */}
-          <fieldset className="stg:space-y-2" disabled={isUpdating}>
+          <fieldset className={cn(UNSTYLED_FIELDSET, "stg:space-y-2")} disabled={isUpdating}>
             <legend className="stg:text-xs stg:font-medium stg:text-foreground">
               Expiry
             </legend>
@@ -337,7 +338,7 @@ export function PlatformClientDetailPanel({
           </fieldset>
 
           {/* JIT provisioning */}
-          <fieldset className="stg:space-y-2.5" disabled={isUpdating}>
+          <fieldset className={cn(UNSTYLED_FIELDSET, "stg:space-y-2.5")} disabled={isUpdating}>
             <hr className="stg:border-border-muted" />
             <legend className="stg:text-xs stg:font-medium stg:text-foreground">
               JIT provisioning
@@ -393,7 +394,7 @@ export function PlatformClientDetailPanel({
           </fieldset>
 
           {/* Allowed origins */}
-          <fieldset className="stg:space-y-2" disabled={isUpdating}>
+          <fieldset className={cn(UNSTYLED_FIELDSET, "stg:space-y-2")} disabled={isUpdating}>
             <hr className="stg:border-border-muted" />
             <legend className="stg:text-xs stg:font-medium stg:text-foreground">
               Allowed origins

package/src/pricing-governance/BaselineEditor.tsx

@@ -1,6 +1,7 @@
 "use client";
 
 import { useCallback, useState, type FormEvent } from "react";
+import { UNSTYLED_FIELDSET } from "../internal/element-resets.js";
 import { create } from "@bufbuild/protobuf";
 import { getUserMessage } from "@stigmer/sdk";
 import {
@@ -546,7 +547,7 @@ export function BaselineEditor({
         Featured (appears in the curated default picker list)
       </label>
 
-      <fieldset className="stg:space-y-2">
+      <fieldset className={`${UNSTYLED_FIELDSET} stg:space-y-2`}>
         <legend className="stg:text-xs stg:font-medium stg:text-foreground">
           Rates ($ per million tokens)
         </legend>
@@ -565,7 +566,7 @@ export function BaselineEditor({
         </div>
       </fieldset>
 
-      <fieldset className="stg:space-y-2">
+      <fieldset className={`${UNSTYLED_FIELDSET} stg:space-y-2`}>
         <legend className="stg:text-xs stg:font-medium stg:text-foreground">Pricing variants</legend>
         {form.variants.map((variant, index) => (
           <div key={index} className="stg:space-y-2 stg:rounded-md stg:border stg:border-border-muted stg:px-2.5 stg:py-2">

package/src/pricing-governance/PricingGovernanceConsole.tsx

@@ -11,6 +11,7 @@ import { RetireConfirm } from "./RetireConfirm.js";
 import { ModelGovernanceDetail } from "./ModelGovernanceDetail.js";
 import { OperatorAccessNotice } from "./OperatorAccessNotice.js";
 import { GovernanceBadge, PendingOverrideCard, RateCell } from "./governance-primitives.js";
+import { UNSTYLED_LIST } from "../internal/element-resets.js";
 import { INPUT_CLASSES } from "../internal/form-primitives.js";
 import { TruncatedText } from "../internal/truncated-text.js";
 import { ZERO } from "./pricing-format.js";
@@ -328,7 +329,7 @@ function ModelsTab({
               : "The catalog is empty — has the baseline seed migration run?"}
           </p>
         ) : (
-          <ul role="list" aria-label="Models" className="stg:m-0 stg:list-none stg:p-0">
+          <ul role="list" aria-label="Models" className={UNSTYLED_LIST}>
             {view.models.map((row) => (
               <ModelRow key={row.key} row={row} onOpen={() => view.openDetail(row.key)} />
             ))}

package/src/provider-standing/ProviderStandingAccessNotice.tsx

@@ -0,0 +1,36 @@
+"use client";
+
+import { cn } from "@stigmer/theme";
+
+/**
+ * The access-denied state for the provider-standing operator surface.
+ * Server-side authorization (`can_view_provider_standing` on
+ * `platform:stigmer`) is the real gate — this is the honest, designed
+ * face of that denial for anyone who navigates to the operator route
+ * without the permission, instead of a raw RPC error string.
+ */
+export function ProviderStandingAccessNotice({
+  className,
+}: {
+  readonly className?: string;
+}) {
+  return (
+    <div
+      className={cn(
+        "stg:rounded-lg stg:border stg:border-border stg:bg-card stg:px-4 stg:py-6 stg:text-center",
+        className,
+      )}
+      role="status"
+    >
+      <p className="stg:text-xs stg:font-semibold stg:text-foreground">
+        Platform operator access required
+      </p>
+      <p className="stg:mx-auto stg:mt-1 stg:max-w-md stg:text-xs stg:text-muted-foreground">
+        Provider standing reports the health of the platform&apos;s own LLM
+        provider accounts, which is Stigmer-internal. It needs the platform
+        operator role — organization roles do not grant it. If you believe
+        you should have access, contact a platform operator.
+      </p>
+    </div>
+  );
+}

package/src/provider-standing/ProviderStandingConsole.tsx

@@ -0,0 +1,216 @@
+"use client";
+
+import { cn } from "@stigmer/theme";
+import { getUserMessage, isPermissionDenied } from "@stigmer/sdk";
+import type { Timestamp } from "@bufbuild/protobuf/wkt";
+import type { ProviderStandingEntry } from "@stigmer/protos/ai/stigmer/platform/providerstanding/v1/io_pb";
+import { Button } from "../button/index.js";
+import { ProviderStandingAccessNotice } from "./ProviderStandingAccessNotice.js";
+import { useProviderStanding } from "./useProviderStanding.js";
+
+/** Props for {@link ProviderStandingConsole}. */
+export interface ProviderStandingConsoleProps {
+  /** Additional CSS class names. */
+  readonly className?: string;
+}
+
+// BigInt literals (0n) require an ES2020 target, which not every consuming
+// app's tsconfig guarantees — the constructor form is target-agnostic (the
+// cursor-account-format precedent).
+const ZERO = BigInt(0);
+
+/**
+ * A probe verdict older than this is flagged stale — the probe-silence
+ * alert's UI twin: the probe runs hourly and the alert fires at 3h (the
+ * 60m interval plus generous grace), so the console goes amber on the
+ * same clock operators are paged on.
+ */
+const STALE_AFTER_MS = 3 * 60 * 60 * 1000;
+
+/**
+ * Display metadata for the probe's closed status vocabulary (the
+ * lowercase labels StandingStatus persists). An unknown future label
+ * degrades to a muted badge showing the raw label — the wire contract is
+ * a string precisely so consoles never fail to decode a new status.
+ */
+const STATUS_DISPLAY: Record<string, { label: string; tone: "ok" | "warn" | "muted" }> = {
+  healthy: { label: "Healthy", tone: "ok" },
+  platform_billing: { label: "Billing rejected", tone: "warn" },
+  platform_auth: { label: "Auth rejected", tone: "warn" },
+  unclassified_error: { label: "Erroring", tone: "warn" },
+  unreachable: { label: "Unreachable", tone: "warn" },
+  not_configured: { label: "Not configured", tone: "muted" },
+};
+
+/**
+ * The platform-operator console page for provider standing: one card per
+ * platform LLM provider account with the latest canary-probe verdict —
+ * status, round-trip latency, upstream HTTP status, a bounded error
+ * summary, and when the probe last ran (flagged when stale).
+ *
+ * Read-only by design: the detection core (hourly probe, standing store,
+ * degraded/silence alerts) lives server-side; this surface only makes it
+ * visible where operators already look. Requires
+ * `can_view_provider_standing` on `platform:stigmer` — non-operators see
+ * the designed access notice.
+ *
+ * @example
+ * ```tsx
+ * <ProviderStandingConsole />
+ * ```
+ */
+export function ProviderStandingConsole({ className }: ProviderStandingConsoleProps) {
+  const { standing, isLoading, isRefetching, error, refetch } = useProviderStanding();
+
+  if (isLoading) {
+    return (
+      <div className={cn("stg:space-y-2", className)} aria-busy="true">
+        <div className="stg:h-4 stg:w-40 stg:animate-pulse stg:rounded stg:bg-muted-subtle" />
+        {Array.from({ length: 2 }, (_, i) => (
+          <div key={i} className="stg:h-16 stg:animate-pulse stg:rounded-lg stg:bg-muted-subtle" />
+        ))}
+      </div>
+    );
+  }
+
+  if (error) {
+    // A non-operator landing here is expected (the route is reachable by
+    // URL) — show the designed access notice, not a raw RPC error.
+    if (isPermissionDenied(error)) {
+      return <ProviderStandingAccessNotice className={className} />;
+    }
+    return (
+      <p className={cn("stg:text-destructive stg:text-xs", className)} role="alert">
+        {getUserMessage(error)}
+      </p>
+    );
+  }
+
+  const providers = standing?.providers ?? [];
+
+  return (
+    <div className={cn("stg:space-y-3", className)}>
+      <div className="stg:flex stg:items-center stg:justify-between">
+        <p className="stg:text-xs stg:text-muted-foreground">
+          Latest canary verdict per platform provider account, probed hourly.
+        </p>
+        <Button
+          variant="outline"
+          size="sm"
+          onClick={refetch}
+          disabled={isRefetching}
+        >
+          {isRefetching ? "Refreshing…" : "Refresh"}
+        </Button>
+      </div>
+
+      {providers.length === 0 ? (
+        <p className="stg:rounded-lg stg:border stg:border-border stg:bg-card stg:px-4 stg:py-6 stg:text-center stg:text-xs stg:text-muted-foreground">
+          No probe verdicts recorded yet — the standing probe has not
+          completed a pass since this deployment came up.
+        </p>
+      ) : (
+        <ul className="stg:m-0 stg:grid stg:list-none stg:gap-2 stg:p-0 sm:stg:grid-cols-2">
+          {providers.map((entry) => (
+            <StandingCard key={entry.provider} entry={entry} />
+          ))}
+        </ul>
+      )}
+    </div>
+  );
+}
+
+function StandingCard({ entry }: { readonly entry: ProviderStandingEntry }) {
+  const display = STATUS_DISPLAY[entry.status] ?? {
+    label: entry.status || "unknown",
+    tone: "muted" as const,
+  };
+  const stale = isStale(entry.checkedAt);
+
+  return (
+    <li className="stg:rounded-lg stg:border stg:border-border stg:bg-card stg:p-3">
+      <div className="stg:flex stg:items-center stg:justify-between stg:gap-2">
+        <span className="stg:text-sm stg:font-semibold stg:capitalize stg:text-foreground">
+          {entry.provider}
+        </span>
+        <StatusBadge tone={display.tone} label={display.label} />
+      </div>
+
+      <dl className="stg:mt-2 stg:flex stg:flex-wrap stg:gap-x-4 stg:gap-y-1 stg:text-xs stg:text-muted-foreground">
+        {entry.latencyMs > ZERO && (
+          <div className="stg:flex stg:gap-1">
+            <dt>Latency</dt>
+            <dd className="stg:m-0 stg:text-foreground">{`${entry.latencyMs}ms`}</dd>
+          </div>
+        )}
+        {entry.httpStatus > 0 && (
+          <div className="stg:flex stg:gap-1">
+            <dt>HTTP</dt>
+            <dd className="stg:m-0 stg:text-foreground">{entry.httpStatus}</dd>
+          </div>
+        )}
+        <div className="stg:flex stg:gap-1">
+          <dt>Probed</dt>
+          <dd
+            className={cn(
+              "stg:m-0",
+              stale ? "stg:font-medium stg:text-destructive" : "stg:text-foreground",
+            )}
+          >
+            {formatProbeTime(entry.checkedAt)}
+            {stale ? " — stale" : ""}
+          </dd>
+        </div>
+      </dl>
+
+      {entry.errorSummary && (
+        <p className="stg:mt-2 stg:break-words stg:rounded stg:bg-muted-subtle stg:px-2 stg:py-1 stg:text-[11px] stg:text-muted-foreground">
+          {entry.errorSummary}
+        </p>
+      )}
+    </li>
+  );
+}
+
+/**
+ * Small tonal status badge — the cursor-accounts StateBadge shape, local
+ * to this module (the two operator surfaces evolve independently).
+ */
+function StatusBadge({
+  tone,
+  label,
+}: {
+  readonly tone: "ok" | "warn" | "muted";
+  readonly label: string;
+}) {
+  return (
+    <span
+      className={cn(
+        "stg:inline-block stg:rounded stg:px-1.5 stg:py-0.5 stg:text-[10px] stg:font-medium",
+        tone === "ok" && "stg:bg-accent stg:text-primary",
+        tone === "warn" && "stg:bg-muted-subtle stg:text-destructive",
+        tone === "muted" && "stg:bg-muted-subtle stg:text-muted-foreground",
+      )}
+    >
+      {label}
+    </span>
+  );
+}
+
+function isStale(ts: Timestamp | undefined): boolean {
+  if (!ts || ts.seconds === ZERO) return true;
+  return Date.now() - Number(ts.seconds) * 1000 > STALE_AFTER_MS;
+}
+
+/** Proto Timestamp to a compact local date-time (e.g. "Jul 22, 14:05"). */
+function formatProbeTime(ts: Timestamp | undefined): string {
+  if (!ts || ts.seconds === ZERO) {
+    return "never";
+  }
+  return new Date(Number(ts.seconds) * 1000).toLocaleString(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}

package/src/provider-standing/__tests__/ProviderStandingConsole.test.tsx

@@ -0,0 +1,143 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { create } from "@bufbuild/protobuf";
+import { timestampFromDate } from "@bufbuild/protobuf/wkt";
+import { StigmerError } from "@stigmer/sdk";
+import {
+  ProviderStandingEntrySchema,
+  ProviderStandingViewSchema,
+} from "@stigmer/protos/ai/stigmer/platform/providerstanding/v1/io_pb";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { ProviderStandingConsole } from "../ProviderStandingConsole";
+
+function createMockStigmer(getStandingView: ReturnType<typeof vi.fn>) {
+  return {
+    providerStanding: { getStandingView },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+function entry(overrides: Record<string, unknown> = {}) {
+  return create(ProviderStandingEntrySchema, {
+    provider: "anthropic",
+    status: "healthy",
+    httpStatus: 200,
+    latencyMs: BigInt(842),
+    errorSummary: "",
+    checkedAt: timestampFromDate(new Date()),
+    ...overrides,
+  });
+}
+
+function view(entries: ReturnType<typeof entry>[]) {
+  return create(ProviderStandingViewSchema, { providers: entries });
+}
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+describe("ProviderStandingConsole", () => {
+  it("renders one card per provider with status, latency, and probe time", async () => {
+    const client = createMockStigmer(
+      vi.fn().mockResolvedValue(
+        view([
+          entry(),
+          entry({
+            provider: "openai",
+            status: "platform_billing",
+            httpStatus: 429,
+            latencyMs: BigInt(0),
+            errorSummary: "insufficient_quota: billing hard limit reached",
+          }),
+        ]),
+      ),
+    );
+    render(<ProviderStandingConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => {
+      expect(screen.getByText("anthropic")).toBeTruthy();
+    });
+    expect(screen.getByText("Healthy")).toBeTruthy();
+    expect(screen.getByText("842ms")).toBeTruthy();
+
+    expect(screen.getByText("openai")).toBeTruthy();
+    expect(screen.getByText("Billing rejected")).toBeTruthy();
+    expect(screen.getByText("429")).toBeTruthy();
+    expect(
+      screen.getByText("insufficient_quota: billing hard limit reached"),
+    ).toBeTruthy();
+  });
+
+  it("flags a verdict older than the probe-silence window as stale", async () => {
+    const fourHoursAgo = new Date(Date.now() - 4 * 60 * 60 * 1000);
+    const client = createMockStigmer(
+      vi.fn().mockResolvedValue(
+        view([entry({ checkedAt: timestampFromDate(fourHoursAgo) })]),
+      ),
+    );
+    render(<ProviderStandingConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => {
+      expect(screen.getByText(/— stale/)).toBeTruthy();
+    });
+  });
+
+  it("degrades an unknown future status label to a muted badge with the raw label", async () => {
+    const client = createMockStigmer(
+      vi.fn().mockResolvedValue(view([entry({ status: "rate_limited" })])),
+    );
+    render(<ProviderStandingConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => {
+      expect(screen.getByText("rate_limited")).toBeTruthy();
+    });
+  });
+
+  it("shows the designed access notice on permission denied, not a raw RPC error", async () => {
+    const client = createMockStigmer(
+      vi.fn().mockRejectedValue(
+        new StigmerError("permission-denied", "only platform operators can view provider standing", 7),
+      ),
+    );
+    render(<ProviderStandingConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => {
+      expect(screen.getByText("Platform operator access required")).toBeTruthy();
+    });
+  });
+
+  it("shows the error message for non-permission failures", async () => {
+    const client = createMockStigmer(
+      vi.fn().mockRejectedValue(new StigmerError("internal", "standing lookup failed", 13)),
+    );
+    render(<ProviderStandingConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => {
+      expect(screen.getByRole("alert")).toBeTruthy();
+    });
+  });
+
+  it("explains the empty state before the probe's first pass", async () => {
+    const client = createMockStigmer(vi.fn().mockResolvedValue(view([])));
+    render(<ProviderStandingConsole />, { wrapper: wrapper(client) });
+
+    await waitFor(() => {
+      expect(screen.getByText(/No probe verdicts recorded yet/)).toBeTruthy();
+    });
+  });
+});

package/src/provider-standing/index.ts

@@ -0,0 +1,8 @@
+// Data hooks
+export { useProviderStanding } from "./useProviderStanding.js";
+export type { UseProviderStandingReturn } from "./useProviderStanding.js";
+
+// Styled components
+export { ProviderStandingConsole } from "./ProviderStandingConsole.js";
+export type { ProviderStandingConsoleProps } from "./ProviderStandingConsole.js";
+export { ProviderStandingAccessNotice } from "./ProviderStandingAccessNotice.js";