@stigmer/react 3.12.5 → 3.12.6

package/src/models/ModelSelector.tsx

@@ -9,6 +9,7 @@ import { useModelRegistry } from "./useModelRegistry.js";
 import type { ModelInfo, CostTier, SpeedTier } from "./registry.js";
 import { HARNESS_META, HARNESS_OPTIONS, type HarnessOption } from "./harness.js";
 import { FAST_SERVICE_TIER, type ServiceTierOption } from "./service-tier.js";
+import type { ThinkingModeOption } from "./thinking-mode.js";
 
 const COST_TIER_LABEL: Record<CostTier, string> = {
   economy: "$",
@@ -23,6 +24,17 @@ const SPEED_TIER_LABEL: Record<SpeedTier, string> = {
   slow: "Powerful",
 };
 
+/**
+ * Whether the thinking switch may act on this model (stigmer/stigmer#772):
+ * the registry declares the capability AND the model is cursor-harness —
+ * the only harness with a thinking translation in v1. Native models
+ * truthfully declare the capability too, but selecting it there would be
+ * refused at create time, so the control never renders for them.
+ */
+function supportsThinking(model: ModelInfo): boolean {
+  return model.harness === "cursor" && model.thinkingCapable === true;
+}
+
 /** Props for {@link ModelSelector}. */
 export interface ModelSelectorProps {
   /** Currently selected model ID. */
@@ -95,6 +107,30 @@ export interface ModelSelectorProps {
    */
   readonly onServiceTierChange?: (tier: ServiceTierOption) => void;
 
+  /**
+   * Current thinking mode for the selected model (stigmer/stigmer#772).
+   * Defaults to "disabled". Only meaningful together with
+   * {@link onThinkingModeChange}.
+   */
+  readonly thinkingMode?: ThinkingModeOption;
+  /**
+   * Called when the user toggles extended reasoning. Providing this enables
+   * the "Thinking" switch as a sibling of the fast-tier switch in the
+   * popover's options area, which renders ONLY while the selected model is
+   * a cursor-harness model declaring the thinking capability
+   * ({@link ModelInfo.thinkingCapable}) — no dead controls, and v1 honors
+   * the selection on the cursor harness only.
+   *
+   * The same persistence rule as the fast tier: an active thinking mode
+   * survives switches between thinking-capable models (trigger badge +
+   * options switch keep it visible) and resets to "disabled" only when the
+   * new model lacks the capability — an unsupported combination can never
+   * be submitted (#772, refused at create time). Unlike fast, thinking
+   * bills at base per-token rates; enabled turns consume more output
+   * (reasoning) tokens.
+   */
+  readonly onThinkingModeChange?: (mode: ThinkingModeOption) => void;
+
   /**
    * @deprecated Use {@link onHarnessChange} instead.
    */
@@ -125,6 +161,14 @@ export interface ModelSelectorProps {
  * switch keep the state honest — and resets only for models with no fast
  * variant, where it would be refused at create time.
  *
+ * **Thinking mode (#772).** The same options-area pattern for the second
+ * variant dimension: opting in via
+ * {@link ModelSelectorProps.onThinkingModeChange} renders a "Thinking"
+ * switch for cursor-harness models declaring the thinking capability.
+ * Capability-gated rather than priced-variant-gated — thinking bills at
+ * base per-token rates and costs more only through extra reasoning
+ * (output) tokens. Persistence and reset rules mirror the fast tier's.
+ *
  * @example
  * ```tsx
  * <ModelSelector
@@ -153,6 +197,8 @@ export function ModelSelector({
   placeholderLabel,
   serviceTier = "standard",
   onServiceTierChange,
+  thinkingMode = "disabled",
+  onThinkingModeChange,
 }: ModelSelectorProps) {
   const portalContainer = useStigmerPortalContainer();
 
@@ -277,9 +323,19 @@ export function ModelSelector({
       ) {
         onServiceTierChange("standard");
       }
+      // The identical persistence rule for the thinking mode (#772):
+      // survives between thinking-capable cursor models, resets only
+      // where the selection would be refused at create time.
+      if (
+        thinkingMode === "enabled"
+        && onThinkingModeChange
+        && !supportsThinking(model)
+      ) {
+        onThinkingModeChange("disabled");
+      }
       setOpen(false);
     },
-    [onValueChange, serviceTier, onServiceTierChange],
+    [onValueChange, serviceTier, onServiceTierChange, thinkingMode, onThinkingModeChange],
   );
 
   const scrollHighlightIntoView = useCallback((idx: number) => {
@@ -338,6 +394,15 @@ export function ModelSelector({
   const fastActive =
     serviceTier === "fast"
     && (selectedModel?.serviceTiers.includes(FAST_SERVICE_TIER) ?? false);
+  // The thinking switch renders under the same no-dead-controls rule,
+  // gated on the capability instead of a priced variant (#772).
+  const showThinkingToggle =
+    onThinkingModeChange !== undefined
+    && selectedModel !== undefined
+    && supportsThinking(selectedModel);
+  const thinkingActive =
+    thinkingMode === "enabled"
+    && (selectedModel !== undefined && supportsThinking(selectedModel));
 
   const usingPlaceholder = !value && placeholderLabel !== undefined;
   const triggerLabel = usingPlaceholder
@@ -379,6 +444,16 @@ export function ModelSelector({
             Fast
           </span>
         )}
+        {thinkingActive && (
+          <span
+            className={cn(
+              "stg:inline-flex stg:shrink-0 stg:items-center stg:gap-0.5 stg:rounded-full stg:border stg:border-primary stg:px-1.5 stg:py-px",
+              "stg:text-[0.6rem] stg:font-medium stg:uppercase stg:tracking-wider stg:text-primary",
+            )}
+          >
+            Thinking
+          </span>
+        )}
         <ChevronIcon />
       </Popover.Trigger>
 
@@ -483,6 +558,24 @@ export function ModelSelector({
               </div>
             )}
 
+            {showThinkingToggle && (
+              <div className="stg:flex stg:items-center stg:justify-between stg:border-b stg:border-border stg:px-3 stg:py-2">
+                <div className="stg:flex stg:flex-col">
+                  <span className="stg:text-xs stg:text-foreground">Thinking</span>
+                  <span className="stg:text-[0.65rem] stg:text-muted-foreground">
+                    Extended reasoning; uses more output tokens
+                  </span>
+                </div>
+                <Switch
+                  checked={thinkingActive}
+                  onCheckedChange={(next) =>
+                    onThinkingModeChange?.(next ? "enabled" : "disabled")
+                  }
+                  aria-label="Thinking"
+                />
+              </div>
+            )}
+
             {/* Search input */}
             <div className="stg:border-b stg:border-border stg:px-3 stg:py-1.5">
               <input

package/src/models/index.ts

@@ -13,3 +13,5 @@ export { DEFAULT_HARNESS, HARNESS_LABELS, HARNESS_META, HARNESS_OPTIONS, toProto
 export type { HarnessOption, HarnessDisplayInfo } from "./harness.js";
 export { FAST_SERVICE_TIER, toProtoServiceTier, fromProtoServiceTier } from "./service-tier.js";
 export type { ServiceTierOption } from "./service-tier.js";
+export { toProtoThinkingMode, fromProtoThinkingMode } from "./thinking-mode.js";
+export type { ThinkingModeOption } from "./thinking-mode.js";

package/src/models/registry.ts

@@ -114,6 +114,22 @@ export interface ModelInfo {
    * parse the same document and must agree on what absence means.
    */
   readonly visionCapability?: boolean;
+  /**
+   * Tri-state thinking capability from the registry's `capabilities` block
+   * (stigmer/stigmer#772), the same absence convention as
+   * {@link visionCapability}:
+   *
+   * - `true` — the model declares an extended-reasoning (thinking) variant;
+   *   the thinking switch in the model popover's options area may render
+   * - `false` — explicitly assessed as having none
+   * - `undefined` — never assessed; **stay silent, never treat as false**
+   *
+   * Capability-gated, not pricing-gated (unlike {@link serviceTiers}):
+   * thinking bills at base per-token rates, so no priced variant exists to
+   * key on. v1 honors the selection on the cursor harness only — gate any
+   * control on `harness === "cursor"` as well as this flag.
+   */
+  readonly thinkingCapable?: boolean;
 }
 
 /**
@@ -229,6 +245,17 @@ function parseVisionCapability(capabilities: unknown): boolean | undefined {
   return typeof vision === "boolean" ? vision : undefined;
 }
 
+/**
+ * Extract `capabilities.thinking` with the same tri-state convention as
+ * {@link parseVisionCapability} (stigmer/stigmer#772): a missing or
+ * malformed `capabilities` block stays `undefined`, never coerced to false.
+ */
+function parseThinkingCapability(capabilities: unknown): boolean | undefined {
+  if (!capabilities || typeof capabilities !== "object") return undefined;
+  const thinking = (capabilities as Record<string, unknown>).thinking;
+  return typeof thinking === "boolean" ? thinking : undefined;
+}
+
 /**
  * Parse the document-level `limits.vision` block. Returns `undefined` for
  * documents that predate the block or carry a malformed one — absence
@@ -284,6 +311,7 @@ export function parseRegistryDocument(data: unknown): ModelRegistryDocument {
     .filter(isModelEntry)
     .map((m) => {
       const visionCapability = parseVisionCapability(m.capabilities);
+      const thinkingCapable = parseThinkingCapability(m.capabilities);
       return {
         modelId: m.id,
         provider: m.provider as Provider,
@@ -300,6 +328,7 @@ export function parseRegistryDocument(data: unknown): ModelRegistryDocument {
         // Conditional spread keeps unassessed models free of the key
         // (tri-state absence, not an explicit undefined).
         ...(visionCapability !== undefined ? { visionCapability } : {}),
+        ...(thinkingCapable !== undefined ? { thinkingCapable } : {}),
       };
     });
 

package/src/models/thinking-mode.ts

@@ -0,0 +1,48 @@
+import { ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+/**
+ * String form of the thinking mode for component props and hook inputs
+ * (stigmer/stigmer#772). Mirrors {@link ServiceTierOption}: components
+ * speak strings, execution creation speaks proto.
+ *
+ * "disabled" is the model's base variant; "enabled" is the model's
+ * extended-reasoning variant — selectable only for models whose
+ * {@link ModelInfo.thinkingCapable} is true. Unlike the fast tier,
+ * thinking bills at base per-token rates; enabled turns simply consume
+ * more output (reasoning) tokens.
+ */
+export type ThinkingModeOption = "disabled" | "enabled";
+
+/**
+ * Convert a {@link ThinkingModeOption} string to the proto enum.
+ */
+export function toProtoThinkingMode(mode: ThinkingModeOption): ThinkingMode {
+  switch (mode) {
+    case "enabled":
+      return ThinkingMode.ENABLED;
+    case "disabled":
+    default:
+      return ThinkingMode.DISABLED;
+  }
+}
+
+/**
+ * Convert a proto {@link ThinkingMode} enum to its string form.
+ *
+ * `UNSPECIFIED` (and any unknown value) maps to `undefined` so callers can
+ * decide their own default — matching the proto contract (`UNSPECIFIED`
+ * resolves to `THINKING_MODE_DISABLED` in the runner, never the provider
+ * account default).
+ */
+export function fromProtoThinkingMode(
+  mode: ThinkingMode | undefined,
+): ThinkingModeOption | undefined {
+  switch (mode) {
+    case ThinkingMode.DISABLED:
+      return "disabled";
+    case ThinkingMode.ENABLED:
+      return "enabled";
+    default:
+      return undefined;
+  }
+}

package/src/oauth-app/OAuthAppDetailPanel.tsx

@@ -2,7 +2,7 @@
 
 import { type FormEvent, useCallback, useId, useState } from "react";
 import { cn } from "@stigmer/theme";
-import { getUserMessage } from "@stigmer/sdk";
+import { getUserMessage, toOAuthAppUpdateInput } from "@stigmer/sdk";
 import type { OAuthApp } from "@stigmer/protos/ai/stigmer/iam/oauthapp/v1/api_pb";
 import {
   TokenEndpointAuthMethod,
@@ -132,30 +132,32 @@ export function OAuthAppDetailPanel({
         .filter(Boolean);
 
       try {
+        // Full-spec-replace safety: spread the complete mapped input and
+        // override every field this form owns, so a future spec field the
+        // form does not know about survives the save. An empty secret
+        // input keeps the fetched value — the redaction marker — which
+        // the server's update pipeline treats as "keep the stored
+        // secret"; a non-empty input replaces it.
+        const mapped = toOAuthAppUpdateInput(oauthApp);
         const updated = await update({
-          name: meta?.name ?? "",
-          slug: meta?.slug,
-          org: meta?.org ?? "",
+          ...mapped,
           provider: provider.trim(),
           clientId: clientId.trim(),
-          ...(clientSecret.trim() && { clientSecret: clientSecret.trim() }),
+          clientSecret: clientSecret.trim() || mapped.clientSecret,
           authorizationUrl: authorizationUrl.trim(),
           tokenUrl: tokenUrl.trim(),
-          ...(parsedScopes.length > 0 && { scopes: parsedScopes }),
-          ...(userinfoUrl.trim() && { userinfoUrl: userinfoUrl.trim() }),
-          ...(scopeParameterName.trim() && {
-            scopeParameterName: scopeParameterName.trim(),
-          }),
-          ...(tokenEndpointAuthMethod !== "unspecified" && {
-            tokenEndpointAuthMethod:
-              TOKEN_AUTH_METHOD_MAP[tokenEndpointAuthMethod],
-          }),
-          ...(vendorApprovalStatus !== "unspecified" && {
-            vendorApprovalStatus: APPROVAL_STATUS_MAP[vendorApprovalStatus],
-          }),
-          ...(vendorApprovalDocsUrl.trim() && {
-            vendorApprovalDocsUrl: vendorApprovalDocsUrl.trim(),
-          }),
+          scopes: parsedScopes.length > 0 ? parsedScopes : undefined,
+          userinfoUrl: userinfoUrl.trim() || undefined,
+          scopeParameterName: scopeParameterName.trim() || undefined,
+          tokenEndpointAuthMethod:
+            tokenEndpointAuthMethod !== "unspecified"
+              ? TOKEN_AUTH_METHOD_MAP[tokenEndpointAuthMethod]
+              : undefined,
+          vendorApprovalStatus:
+            vendorApprovalStatus !== "unspecified"
+              ? APPROVAL_STATUS_MAP[vendorApprovalStatus]
+              : undefined,
+          vendorApprovalDocsUrl: vendorApprovalDocsUrl.trim() || undefined,
         });
         setMode("view");
         onUpdated?.(updated);
@@ -164,7 +166,7 @@ export function OAuthAppDetailPanel({
       }
     },
     [
-      meta, provider, clientId, clientSecret, authorizationUrl, tokenUrl,
+      oauthApp, provider, clientId, clientSecret, authorizationUrl, tokenUrl,
       scopes, userinfoUrl, scopeParameterName, tokenEndpointAuthMethod,
       vendorApprovalStatus, vendorApprovalDocsUrl, update, clearUpdateError,
       onUpdated,

package/src/oauth-app/__tests__/OAuthAppDetailPanel.test.tsx

@@ -0,0 +1,94 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import {
+  OAuthAppSchema,
+  type OAuthApp,
+} from "@stigmer/protos/ai/stigmer/iam/oauthapp/v1/api_pb";
+import { TokenEndpointAuthMethod } from "@stigmer/protos/ai/stigmer/iam/oauthapp/v1/spec_pb";
+import type { OAuthAppInput } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { OAuthAppDetailPanel } from "../OAuthAppDetailPanel";
+
+/**
+ * Regression suite for the full-spec-replace wipe bug: the panel must
+ * spread `toOAuthAppUpdateInput` and override only what it edits, so a
+ * spec field the form does not know about survives the save. The secret
+ * has its own contract: an empty secret input sends the fetched value —
+ * the server's redaction marker — which the update pipeline treats as
+ * "keep the stored secret" (oss#395 pins the marker/ciphertext boundary).
+ */
+
+const REDACTED = "***REDACTED***";
+
+const APP: OAuthApp = create(OAuthAppSchema, {
+  metadata: {
+    id: "oa-1",
+    name: "GitHub OAuth",
+    slug: "github-oauth",
+    org: "acme",
+  },
+  spec: {
+    provider: "github",
+    clientId: "gh-client-1",
+    clientSecret: REDACTED,
+    authorizationUrl: "https://github.com/login/oauth/authorize",
+    tokenUrl: "https://github.com/login/oauth/access_token",
+    scopes: ["repo"],
+    tokenEndpointAuthMethod: TokenEndpointAuthMethod.CLIENT_SECRET_POST,
+  },
+});
+
+function renderPanel(update: ReturnType<typeof vi.fn>) {
+  const client = {
+    oauthapp: { update },
+  } as never;
+  return render(
+    <StigmerContext.Provider value={client}>
+      <OAuthAppDetailPanel oauthApp={APP} />
+    </StigmerContext.Provider>,
+  );
+}
+
+afterEach(cleanup);
+
+describe("OAuthAppDetailPanel save payload", () => {
+  it("keeps the stored secret (redaction marker) when the secret input is left empty", async () => {
+    const update = vi.fn(async (_input: OAuthAppInput) => APP);
+    renderPanel(update);
+
+    fireEvent.click(screen.getByRole("button", { name: "Edit" }));
+    const provider = await screen.findByLabelText("Provider");
+    fireEvent.change(provider, { target: { value: "github-enterprise" } });
+    fireEvent.click(screen.getByRole("button", { name: "Save changes" }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    const input = update.mock.calls[0]![0];
+
+    // Empty secret input → the redaction marker rides along → the server
+    // preserves the stored secret.
+    expect(input.clientSecret).toBe(REDACTED);
+    // The edited field.
+    expect(input.provider).toBe("github-enterprise");
+    // Unedited fields round-trip.
+    expect(input.tokenEndpointAuthMethod).toBe(
+      TokenEndpointAuthMethod.CLIENT_SECRET_POST,
+    );
+    expect(input.scopes).toEqual(["repo"]);
+    expect(input.org).toBe("acme");
+    expect(input.slug).toBe("github-oauth");
+  });
+
+  it("sends a newly entered secret instead of the marker", async () => {
+    const update = vi.fn(async (_input: OAuthAppInput) => APP);
+    renderPanel(update);
+
+    fireEvent.click(screen.getByRole("button", { name: "Edit" }));
+    const secret = await screen.findByLabelText("Client secret");
+    fireEvent.change(secret, { target: { value: "new-secret" } });
+    fireEvent.click(screen.getByRole("button", { name: "Save changes" }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    expect(update.mock.calls[0]![0].clientSecret).toBe("new-secret");
+  });
+});

package/src/platform-client/PlatformClientDetailPanel.tsx

@@ -3,7 +3,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 { getUserMessage, toPlatformClientUpdateInput } from "@stigmer/sdk";
 import { IamRole } from "@stigmer/protos/ai/stigmer/iam/v1/enum_pb";
 import { timestampDate, type Timestamp } from "@bufbuild/protobuf/wkt";
 import type { PlatformClient } from "@stigmer/protos/ai/stigmer/iam/platformclient/v1/api_pb";
@@ -176,21 +176,22 @@ export function PlatformClientDetailPanel({
       e.preventDefault();
       clearUpdateError();
       try {
+        // Full-spec-replace safety: spread the complete mapped input and
+        // override only the edited fields, so unlisted spec fields (e.g.
+        // environment_refs, the embedded-assistant credential binding)
+        // survive the save. Cleared fields are set to undefined
+        // explicitly — omitting them would carry the stale mapped value.
         const updated = await update({
-          name: meta?.name ?? "",
-          slug: meta?.slug,
-          org: meta?.org ?? "",
+          ...toPlatformClientUpdateInput(platformClient),
           neverExpires,
-          ...(!neverExpires &&
-            expiresAt && {
-              expiresAt: new Date(expiresAt).toISOString(),
-            }),
+          expiresAt:
+            !neverExpires && expiresAt ? new Date(expiresAt) : undefined,
           autoProvisionAccounts: autoProvision,
           autoGrantOnOrg: autoGrant,
-          ...(autoGrant &&
-            autoGrantRole !== IamRole.iam_role_unspecified && {
-              autoGrantRole,
-            }),
+          autoGrantRole:
+            autoGrant && autoGrantRole !== IamRole.iam_role_unspecified
+              ? autoGrantRole
+              : undefined,
           allowedOrigins: origins,
         });
         setMode("view");
@@ -200,7 +201,7 @@ export function PlatformClientDetailPanel({
       }
     },
     [
-      meta,
+      platformClient,
       neverExpires,
       expiresAt,
       autoProvision,

package/src/platform-client/__tests__/PlatformClientDetailPanel.test.tsx

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { create } from "@bufbuild/protobuf";
+import { timestampFromDate } from "@bufbuild/protobuf/wkt";
+import {
+  PlatformClientSchema,
+  type PlatformClient,
+} from "@stigmer/protos/ai/stigmer/iam/platformclient/v1/api_pb";
+import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import { IamRole } from "@stigmer/protos/ai/stigmer/iam/v1/enum_pb";
+import type { PlatformClientInput } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import { PlatformClientDetailPanel } from "../PlatformClientDetailPanel";
+
+/**
+ * Regression suite for the full-spec-replace wipe bug: before the
+ * generated-mapper migration, this panel hand-built its update input and
+ * NEVER sent `environment_refs` — saving any edit silently wiped the
+ * client's credential-delivery environment bindings. The panel must
+ * spread `toPlatformClientUpdateInput` and override only what it edits.
+ */
+
+const PLATFORM_CLIENT: PlatformClient = create(PlatformClientSchema, {
+  metadata: {
+    id: "pc-1",
+    name: "Embed Client",
+    slug: "embed-client",
+    org: "acme",
+  },
+  spec: {
+    clientId: "client-abc",
+    expiresAt: timestampFromDate(new Date("2027-06-01T00:00:00Z")),
+    neverExpires: false,
+    autoProvisionAccounts: true,
+    autoGrantOnOrg: true,
+    autoGrantRole: IamRole.admin,
+    allowedOrigins: ["https://embed.acme.example"],
+    environmentRefs: [
+      { org: "acme", slug: "prod", kind: ApiResourceKind.environment },
+    ],
+  },
+});
+
+function renderPanel(update: ReturnType<typeof vi.fn>) {
+  const client = {
+    platformclient: { update },
+  } as never;
+  return render(
+    <StigmerContext.Provider value={client}>
+      <PlatformClientDetailPanel platformClient={PLATFORM_CLIENT} />
+    </StigmerContext.Provider>,
+  );
+}
+
+afterEach(cleanup);
+
+describe("PlatformClientDetailPanel save payload", () => {
+  it("round-trips environment_refs on an origins-only edit (the wipe bug)", async () => {
+    const update = vi.fn(async (_input: PlatformClientInput) => PLATFORM_CLIENT);
+    renderPanel(update);
+
+    fireEvent.click(screen.getByRole("button", { name: "Edit" }));
+    fireEvent.click(screen.getByRole("button", { name: "Save changes" }));
+
+    await waitFor(() => expect(update).toHaveBeenCalledTimes(1));
+    const input = update.mock.calls[0]![0];
+
+    // The wipe-bug guard: the form does not render environment bindings,
+    // yet they must survive the save.
+    expect(input.environmentRefs).toEqual([
+      { org: "acme", slug: "prod", kind: ApiResourceKind.environment },
+    ]);
+    // Form-owned fields round-trip from the edit state.
+    expect(input.allowedOrigins).toEqual(["https://embed.acme.example"]);
+    expect(input.autoGrantRole).toBe(IamRole.admin);
+    expect(input.expiresAt).toBeInstanceOf(Date);
+    // Addressing fields for the update pipeline's org+slug lookup.
+    expect(input.org).toBe("acme");
+    expect(input.slug).toBe("embed-client");
+    expect(input.name).toBe("Embed Client");
+  });
+});