@stigmer/react 3.3.0 → 3.4.1

package/src/execution/__tests__/useCreateAgentExecution.test.tsx

@@ -137,6 +137,92 @@ describe("useCreateAgentExecution — one-call session bootstrap (sessionSpec)",
     expect(input.sessionSpec.executionTarget).toBeUndefined();
   });
 
+  it("passes the metadata map through on the bootstrap spec", async () => {
+    const { result } = renderHook(() => useCreateAgentExecution(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.create({
+        org: "acme",
+        message: "Hello",
+        sessionSpec: {
+          agentInstanceId: "ain-1",
+          metadata: { "acme/tenant": "t-1" },
+        },
+      });
+    });
+
+    const input = mockCreate.mock.calls[0][0];
+    expect(input.sessionSpec.metadata).toEqual({ "acme/tenant": "t-1" });
+  });
+
+  it("maps the typed sessionContext onto the reserved metadata key", async () => {
+    const { result } = renderHook(() => useCreateAgentExecution(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.create({
+        org: "acme",
+        message: "Hello",
+        sessionSpec: {
+          agentInstanceId: "ain-1",
+          sessionContext: "Role: platform admin",
+        },
+      });
+    });
+
+    const input = mockCreate.mock.calls[0][0];
+    expect(input.sessionSpec.metadata).toEqual({
+      "stigmer.ai/session-context": "Role: platform admin",
+    });
+  });
+
+  it("lets the typed sessionContext win over a raw entry under the reserved key", async () => {
+    const { result } = renderHook(() => useCreateAgentExecution(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.create({
+        org: "acme",
+        message: "Hello",
+        sessionSpec: {
+          agentInstanceId: "ain-1",
+          metadata: {
+            "acme/tenant": "t-1",
+            "stigmer.ai/session-context": "stale raw value",
+          },
+          sessionContext: "typed value",
+        },
+      });
+    });
+
+    const input = mockCreate.mock.calls[0][0];
+    expect(input.sessionSpec.metadata).toEqual({
+      "acme/tenant": "t-1",
+      "stigmer.ai/session-context": "typed value",
+    });
+  });
+
+  it("omits metadata entirely when neither field is provided", async () => {
+    const { result } = renderHook(() => useCreateAgentExecution(), {
+      wrapper: createWrapper(makeMockClient()),
+    });
+
+    await act(async () => {
+      await result.current.create({
+        org: "acme",
+        message: "Hello",
+        sessionSpec: { agentInstanceId: "ain-1" },
+      });
+    });
+
+    const input = mockCreate.mock.calls[0][0];
+    expect(input.sessionSpec.metadata).toBeUndefined();
+  });
+
   it("returns the server-assigned session id from the bootstrap response", async () => {
     mockCreate.mockResolvedValueOnce({
       metadata: { id: "aex-1" },

package/src/execution/useCreateAgentExecution.ts

@@ -2,12 +2,13 @@
 
 import { useCallback, useState } from "react";
 import type { JsonObject } from "@bufbuild/protobuf";
-import type {
-  AttachmentInput,
-  EnvVarInput,
-  McpServerUsageInput,
-  ResourceRef,
-  WorkspaceEntryInput,
+import {
+  mergeSessionContext,
+  type AttachmentInput,
+  type EnvVarInput,
+  type McpServerUsageInput,
+  type ResourceRef,
+  type WorkspaceEntryInput,
 } from "@stigmer/sdk";
 import { useStigmer } from "../hooks.js";
 import { toError } from "../internal/toError.js";
@@ -41,6 +42,36 @@ export interface BootstrapSessionSpec {
   readonly mcpServerUsages?: McpServerUsageInput[];
   /** Skill references to enable for executions in this session. */
   readonly skillRefs?: ResourceRef[];
+  /**
+   * Custom key-value pairs stored on the created session's
+   * `SessionSpec.metadata`.
+   *
+   * A passthrough for embedder-owned keys (correlation IDs, tenant tags)
+   * and for platform-reserved `stigmer.ai/*` keys set explicitly. For the
+   * common case — standing user context injected into the agent's prompt —
+   * prefer the typed {@link sessionContext} field, which maps onto the
+   * reserved `stigmer.ai/session-context` key and wins over a raw entry
+   * under that key when both are provided.
+   */
+  readonly metadata?: Record<string, string>;
+  /**
+   * Standing, per-user context the agent receives on every turn but the
+   * conversation UI never renders — who the caller is, their experience
+   * level, their standing instructions (stigmer/stigmer#286).
+   *
+   * Stored on the created session's `SessionSpec.metadata` under
+   * `stigmer.ai/session-context`; the agent runner injects it into the
+   * system prompt as already-known background, so agents can greet the
+   * user by name and calibrate depth/defaults from the first turn without
+   * a visible context preamble.
+   *
+   * Personalization, not authorization: anyone who can create the session
+   * can set this (the same trust level as authoring the first message).
+   * Hidden from the conversation thread, not from the API — `session.get`
+   * returns it, so never put secrets here; secrets belong in `runtimeEnv`
+   * or Environment resources. Large values bloat every prompt.
+   */
+  readonly sessionContext?: string;
   /** Execution harness. Immutable after the first execution runs. */
   readonly harness?: HarnessOption;
   /** Where session activities execute. Immutable after the first execution runs. */
@@ -293,6 +324,10 @@ export function useCreateAgentExecution(): UseCreateAgentExecutionReturn {
               workspaceEntries: input.sessionSpec.workspaceEntries,
               mcpServerUsages: input.sessionSpec.mcpServerUsages,
               skillRefs: input.sessionSpec.skillRefs,
+              metadata: mergeSessionContext(
+                input.sessionSpec.metadata,
+                input.sessionSpec.sessionContext,
+              ),
               harness: input.sessionSpec.harness
                 ? toProtoHarness(input.sessionSpec.harness)
                 : undefined,

package/src/index.ts

@@ -156,7 +156,9 @@ export {
   channelSessionExternalUserKey,
   SessionViewer,
   NewSessionViewer,
+  SessionViewerLayout,
   useSessionPanel,
+  useSessionRailViews,
   usePlanDraft,
   planDraftKey,
   PlanEditor,
@@ -201,8 +203,10 @@ export type {
   SearchResultGroup,
   SessionViewerProps,
   NewSessionViewerProps,
+  SessionViewerLayoutProps,
   SessionPanelController,
   UseSessionPanelOptions,
+  UseSessionRailViewsOptions,
   PlanDraftController,
   PlanEditorProps,
   PlanStreamingDocumentProps,
@@ -526,6 +530,10 @@ export {
   useUpdateMcpServer,
   mcpServerToInput,
   toServerKey,
+  IdentityTransportStep,
+  EnvironmentAuthStep,
+  ReviewStep,
+  createInitialMcpServerWizardData,
 } from "./mcp-server/index.js";
 export type {
   UseMcpServerReturn,
@@ -563,6 +571,9 @@ export type {
   McpServerCreationWizardProps,
   McpServerCreationResult,
   McpServerWizardData,
+  IdentityTransportStepProps,
+  EnvironmentAuthStepProps,
+  ReviewStepProps,
 } from "./mcp-server/index.js";
 
 // Skill — data hooks, upload, file browser, and mutation
@@ -909,21 +920,16 @@ export type {
   OrgSwitcherProps,
 } from "./organization/index.js";
 
-// Billing — data hooks, behavior hooks, styled components, catalog, and formatting utilities
+// Billing — customer-facing data hooks, behavior hooks, styled components,
+// catalog, and formatting utilities
 export {
   useBillingAccount,
   useCreditLedger,
   useBillingUsageReport,
   useCustomerModelPricing,
-  usePricingGovernance,
-  useModelPricingBaselines,
-  useModelGovernanceView,
   useCreateCheckoutSession,
   useCreateBillingPortalSession,
   useSetAutoRechargeConfig,
-  useDecidePricingOverride,
-  useUpsertModelPricingBaseline,
-  useRetireModelPricingBaseline,
   BillingSection,
   CreditBalanceCard,
   PaymentMethodCard,
@@ -931,9 +937,6 @@ export {
   CreditPackGrid,
   CreditLedgerTable,
   LowBalanceBanner,
-  PricingGovernancePanel,
-  ModelCatalogPanel,
-  PricingGovernanceConsole,
   CREDIT_PACKS,
   formatPackPrice,
   formatCreditCount,
@@ -950,23 +953,11 @@ export type {
   UseCreditLedgerOptions,
   UseBillingUsageReportReturn,
   UseCustomerModelPricingReturn,
-  UsePricingGovernanceReturn,
-  UseModelPricingBaselinesOptions,
-  UseModelPricingBaselinesReturn,
-  GovernanceFlow,
-  ModelGovernanceRow,
-  UseModelGovernanceViewReturn,
   CreateCheckoutSessionInput,
   UseCreateCheckoutSessionReturn,
   UseCreateBillingPortalSessionReturn,
   SetAutoRechargeConfigInput,
   UseSetAutoRechargeConfigReturn,
-  DecidePricingOverrideInput,
-  UseDecidePricingOverrideReturn,
-  UpsertModelPricingBaselineInput,
-  UseUpsertModelPricingBaselineReturn,
-  RetireModelPricingBaselineInput,
-  UseRetireModelPricingBaselineReturn,
   BillingSectionProps,
   CreditBalanceCardProps,
   PaymentMethodCardProps,
@@ -974,12 +965,40 @@ export type {
   CreditPackGridProps,
   CreditLedgerTableProps,
   LowBalanceBannerProps,
+  CreditPackInfo,
+} from "./billing/index.js";
+
+// Pricing governance — platform-operator authoring of the model registry
+// baseline and pricing-override sign-offs (gated on can_manage_model_pricing)
+export {
+  usePricingGovernance,
+  useModelPricingBaselines,
+  useModelGovernanceView,
+  useDecidePricingOverride,
+  useUpsertModelPricingBaseline,
+  useRetireModelPricingBaseline,
+  PricingGovernancePanel,
+  ModelCatalogPanel,
+  PricingGovernanceConsole,
+} from "./pricing-governance/index.js";
+export type {
+  UsePricingGovernanceReturn,
+  UseModelPricingBaselinesOptions,
+  UseModelPricingBaselinesReturn,
+  GovernanceFlow,
+  ModelGovernanceRow,
+  UseModelGovernanceViewReturn,
+  DecidePricingOverrideInput,
+  UseDecidePricingOverrideReturn,
+  UpsertModelPricingBaselineInput,
+  UseUpsertModelPricingBaselineReturn,
+  RetireModelPricingBaselineInput,
+  UseRetireModelPricingBaselineReturn,
   PricingGovernancePanelProps,
   ModelCatalogPanelProps,
   PricingGovernanceConsoleProps,
   PricingGovernanceTab,
-  CreditPackInfo,
-} from "./billing/index.js";
+} from "./pricing-governance/index.js";
 
 // Cursor accounts — platform-operator management of managed Cursor teams
 // (admin keys, member execution keys, org assignments, roster/spend)

package/src/{billing → internal}/form-primitives.tsx

@@ -3,12 +3,12 @@
 import { cn } from "@stigmer/theme";
 
 // ---------------------------------------------------------------------------
-// Shared form primitives for the operator pricing surfaces (BaselineEditor,
-// RetireConfirm, the console's search inputs). Internal — not exported
-// from the billing barrel.
+// Shared form primitives for the operator consoles (pricing-governance
+// editors and search inputs, cursor-accounts editor and key forms).
+// Internal — never exported from the package barrel.
 // ---------------------------------------------------------------------------
 
-/** Standard text-input styling for the pricing surfaces. */
+/** Standard text-input styling for the operator consoles. */
 export const INPUT_CLASSES = cn(
   "w-full rounded-md border border-input bg-background px-2.5 py-1.5 text-xs text-foreground",
   "placeholder:text-muted-foreground",
@@ -38,31 +38,3 @@ export function Field({
     </label>
   );
 }
-
-/** Dollar-rate input field (decimal keypad, "$ per million tokens"). */
-export function RateField({
-  label,
-  value,
-  placeholder,
-  disabled,
-  onChange,
-}: {
-  readonly label: string;
-  readonly value: string;
-  readonly placeholder?: string;
-  readonly disabled: boolean;
-  readonly onChange: (value: string) => void;
-}) {
-  return (
-    <Field label={label}>
-      <input
-        className={INPUT_CLASSES}
-        inputMode="decimal"
-        value={value}
-        onChange={(e) => onChange(e.target.value)}
-        placeholder={placeholder ?? "0.00"}
-        disabled={disabled}
-      />
-    </Field>
-  );
-}

package/src/manifest/ApplyManifestDialog.tsx

@@ -23,10 +23,15 @@ export interface ApplyManifestDialogProps {
   /** Target organization slug for documents that omit `metadata.org`. */
   readonly org: string;
   /**
-   * Called after every document applied successfully, with the per-document
-   * results in apply order. Use for navigation or list refresh.
+   * Called when the dialog closes after at least one document applied,
+   * with the applied entries in apply order — on full success, and also
+   * when the operator dismisses the dialog after a partial apply (some
+   * documents applied, a later one failed). Use it to refresh a list so
+   * the newly applied resources appear without a reload. It never fires
+   * when nothing applied, and fires once per close. Mirrors
+   * {@link EditResourceYamlDialog}'s `onApplied`.
    */
-  readonly onSuccess?: (entries: readonly ManifestPreviewEntry[]) => void;
+  readonly onApplied?: (applied: readonly ManifestPreviewEntry[]) => void;
 }
 
 /**
@@ -56,7 +61,7 @@ export interface ApplyManifestDialogProps {
  *   open={open}
  *   onOpenChange={setOpen}
  *   org={activeOrg}
- *   onSuccess={() => refetchList()}
+ *   onApplied={() => refetchList()}
  * />
  * ```
  */
@@ -64,7 +69,7 @@ export function ApplyManifestDialog({
   open,
   onOpenChange,
   org,
-  onSuccess,
+  onApplied,
 }: ApplyManifestDialogProps) {
   const dialogRef = useRef<HTMLDialogElement>(null);
   const fileInputRef = useRef<HTMLInputElement>(null);
@@ -90,12 +95,26 @@ export function ApplyManifestDialog({
     }
   }, [open, reset]);
 
+  // Close the dialog and, if any document applied this session, refresh
+  // the caller's list. This is the dismiss-after-partial path: some
+  // documents applied before a later one failed, and the operator closes
+  // the dialog rather than retrying — those applied resources must still
+  // appear. The full-success path in `handleApply` fires `onApplied`
+  // itself (it holds the fresh applied list), so it never routes here.
+  const closeAndMaybeRefresh = useCallback(() => {
+    onOpenChange(false);
+    const applied = (manifest.entries ?? []).filter(
+      (e) => e.status === "applied",
+    );
+    if (applied.length > 0) onApplied?.(applied);
+  }, [onOpenChange, manifest.entries, onApplied]);
+
   const handleCancel = useCallback(
     (e: React.SyntheticEvent) => {
       e.preventDefault();
-      onOpenChange(false);
+      closeAndMaybeRefresh();
     },
-    [onOpenChange],
+    [closeAndMaybeRefresh],
   );
 
   const handleFileChange = useCallback(
@@ -107,18 +126,23 @@ export function ApplyManifestDialog({
   );
 
   const handleApply = useCallback(async () => {
-    const allApplied = await manifest.applyAll();
-    if (allApplied && manifest.entries) {
-      const count = manifest.entries.length;
+    const results = await manifest.applyAll();
+    const applied = results.filter((e) => e.status === "applied");
+    const allApplied = results.length > 0 && applied.length === results.length;
+    if (allApplied) {
       toast.success(
-        count === 1 ? "Resource applied" : `${count} resources applied`,
+        applied.length === 1
+          ? "Resource applied"
+          : `${applied.length} resources applied`,
       );
       onOpenChange(false);
-      onSuccess?.(manifest.entries);
+      onApplied?.(applied);
     }
-    // On failure the dialog stays open — per-entry status shows what
-    // applied and what failed.
-  }, [manifest, onOpenChange, onSuccess]);
+    // On partial/total failure the dialog stays open — per-entry status
+    // shows what applied and what failed. Any entries that DID apply
+    // still refresh the caller's list when the dialog is dismissed
+    // (closeAndMaybeRefresh), so successful writes are never hidden.
+  }, [manifest, onOpenChange, onApplied]);
 
   const canApply =
     manifest.entries !== null &&
@@ -198,7 +222,7 @@ export function ApplyManifestDialog({
           <div className="flex gap-2">
             <button
               type="button"
-              onClick={() => onOpenChange(false)}
+              onClick={closeAndMaybeRefresh}
               disabled={manifest.isApplying}
               className={cn(
                 "rounded-md px-3 py-1.5 text-sm font-medium transition-colors",

package/src/manifest/__tests__/ApplyManifestDialog.test.tsx

@@ -0,0 +1,147 @@
+// Tests for ApplyManifestDialog's onApplied contract — the refresh
+// signal every Library list page wires to appear-without-reload. It must
+// fire on full success AND when the operator dismisses the dialog after a
+// partial apply (some documents applied, a later one failed), and must
+// never fire when nothing applied. Historically onApplied's predecessor
+// had zero coverage and stayed unwired at every call site; this locks the
+// contract the list pages now depend on.
+
+import { describe, it, expect, vi, beforeAll, afterEach } from "vitest";
+import { render, screen, cleanup, fireEvent, waitFor } from "@testing-library/react";
+import { ApplyManifestDialog } from "../ApplyManifestDialog";
+import type {
+  ManifestPreviewEntry,
+  UseApplyManifestReturn,
+} from "../useApplyManifest";
+
+beforeAll(() => {
+  HTMLDialogElement.prototype.showModal = function showModal() {
+    this.open = true;
+  };
+  HTMLDialogElement.prototype.close = function close() {
+    this.open = false;
+  };
+});
+
+afterEach(() => {
+  cleanup();
+  vi.restoreAllMocks();
+});
+
+// A preview entry in a chosen terminal status; the document shape is only
+// what the dialog's preview row and apply flow read.
+function entry(
+  slug: string,
+  status: ManifestPreviewEntry["status"],
+): ManifestPreviewEntry {
+  return {
+    document: {
+      handler: { yamlKind: "datastore", displayName: "Datastore" },
+      name: slug,
+      slug,
+      org: "acme",
+    },
+    action: "create",
+    status,
+  } as ManifestPreviewEntry;
+}
+
+// The mock's mutable knobs: the entries the hook exposes and the terminal
+// entries applyAll resolves to. Set per test before rendering.
+let mockEntries: readonly ManifestPreviewEntry[] | null;
+let applyAllResult: readonly ManifestPreviewEntry[];
+const applyAllMock = vi.fn(async () => applyAllResult);
+
+vi.mock("../useApplyManifest", () => ({
+  useApplyManifest: (): UseApplyManifestReturn =>
+    ({
+      content: "kind: Datastore",
+      setContent: vi.fn(),
+      readFile: vi.fn(),
+      entries: mockEntries,
+      validationError: null,
+      isValidating: false,
+      hasRedactedSecrets: false,
+      applyAll: applyAllMock,
+      isApplying: false,
+      reset: vi.fn(),
+    }) as UseApplyManifestReturn,
+}));
+
+// CodeMirror stays out of the test environment.
+vi.mock("../YamlEditor", () => ({
+  YamlEditor: () => <div data-testid="yaml-editor" />,
+}));
+
+describe("ApplyManifestDialog — onApplied", () => {
+  it("fires with the applied entries on full success and closes", async () => {
+    mockEntries = [entry("a", "pending"), entry("b", "pending")];
+    applyAllResult = [entry("a", "applied"), entry("b", "applied")];
+    const onApplied = vi.fn();
+    const onOpenChange = vi.fn();
+
+    render(
+      <ApplyManifestDialog
+        open
+        onOpenChange={onOpenChange}
+        org="acme"
+        onApplied={onApplied}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: /apply/i }));
+
+    await waitFor(() => expect(onApplied).toHaveBeenCalledTimes(1));
+    expect(
+      onApplied.mock.calls[0][0].map((e: ManifestPreviewEntry) => e.document.slug),
+    ).toEqual(["a", "b"]);
+    expect(onOpenChange).toHaveBeenCalledWith(false);
+  });
+
+  it("fires with only the applied subset when a partial apply is dismissed", async () => {
+    // Applied one, failed the next — the dialog stays open on failure.
+    mockEntries = [entry("a", "applied"), entry("b", "failed")];
+    applyAllResult = [entry("a", "applied"), entry("b", "failed")];
+    const onApplied = vi.fn();
+    const onOpenChange = vi.fn();
+
+    render(
+      <ApplyManifestDialog
+        open
+        onOpenChange={onOpenChange}
+        org="acme"
+        onApplied={onApplied}
+      />,
+    );
+
+    // Apply first: full success did not happen, so onApplied has not fired.
+    fireEvent.click(screen.getByRole("button", { name: /apply/i }));
+    await waitFor(() => expect(applyAllMock).toHaveBeenCalled());
+    expect(onApplied).not.toHaveBeenCalled();
+
+    // Dismiss with an applied entry present → refresh the list.
+    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
+    expect(onApplied).toHaveBeenCalledTimes(1);
+    expect(
+      onApplied.mock.calls[0][0].map((e: ManifestPreviewEntry) => e.document.slug),
+    ).toEqual(["a"]);
+    expect(onOpenChange).toHaveBeenCalledWith(false);
+  });
+
+  it("does not fire when the dialog is dismissed with nothing applied", () => {
+    mockEntries = [entry("a", "pending")];
+    const onApplied = vi.fn();
+
+    render(
+      <ApplyManifestDialog
+        open
+        onOpenChange={vi.fn()}
+        org="acme"
+        onApplied={onApplied}
+      />,
+    );
+
+    fireEvent.click(screen.getByRole("button", { name: "Cancel" }));
+    expect(onApplied).not.toHaveBeenCalled();
+  });
+});

package/src/manifest/__tests__/useApplyManifest.test.tsx

@@ -174,12 +174,12 @@ describe("useApplyManifest", () => {
     });
     await act(settleValidation);
 
-    let allApplied = false;
+    let applied: readonly { status: string }[] = [];
     await act(async () => {
-      allApplied = await result.current.applyAll();
+      applied = await result.current.applyAll();
     });
 
-    expect(allApplied).toBe(true);
+    expect(applied.map((e) => e.status)).toEqual(["applied", "applied"]);
     expect(apply).toHaveBeenCalledTimes(2);
     expect(result.current.entries!.map((e) => e.status)).toEqual([
       "applied",
@@ -201,12 +201,12 @@ describe("useApplyManifest", () => {
     });
     await act(settleValidation);
 
-    let allApplied = true;
+    let applied: readonly { status: string }[] = [];
     await act(async () => {
-      allApplied = await result.current.applyAll();
+      applied = await result.current.applyAll();
     });
 
-    expect(allApplied).toBe(false);
+    expect(applied.map((e) => e.status)).toEqual(["failed", "skipped"]);
     expect(apply).toHaveBeenCalledTimes(1);
     expect(result.current.entries!.map((e) => e.status)).toEqual([
       "failed",