@stigmer/react 3.12.0 → 3.12.2

package/src/mcp-server/useMcpServerCredentials.ts

@@ -11,6 +11,7 @@ import { diffEnv } from "../environment/diffEnv.js";
 import { SYSTEM_ENV_VAR_KEYS } from "../environment/systemEnvVars.js";
 import type { EnvVarFormVariable } from "../environment/EnvVarForm.js";
 import { useOAuthGrantStatus } from "./useOAuthGrantStatus.js";
+import { useOrgOAuthApp } from "./useOrgOAuthApp.js";
 
 /**
  * Credential acquisition mode for an MCP server.
@@ -93,9 +94,15 @@ export interface UseMcpServerCredentialsReturn {
    * Servers whose env vars are all optional are always ready.
    */
   readonly isReady: boolean;
-  /** `true` while the personal environment or grant status is being fetched. */
+  /**
+   * `true` while the personal environment, grant status, or org-override
+   * lookup is being fetched.
+   */
   readonly isLoading: boolean;
-  /** Error from the personal environment or grant status fetch, or `null`. */
+  /**
+   * Error from the personal environment, grant status, or org-override
+   * fetch, or `null`.
+   */
   readonly error: Error | null;
   /**
    * Save the provided credentials to the user's personal environment.
@@ -131,22 +138,35 @@ export interface UseMcpServerCredentialsReturn {
    */
   readonly isVendorApprovalBlocked: boolean;
   /**
-   * Where the effective OAuth app was resolved from for the caller's org.
+   * Where the effective OAuth app is resolved from for the caller's org
+   * — the same source the connect flow will use.
    *
-   * Enriched at query time by the backend — no additional RPC needed.
-   * `UNSPECIFIED` when `authMode` is `"manual"` or enrichment has not
-   * been performed yet.
+   * Resolved client-side from the `getOrgOAuthApp` RPC keyed on this
+   * hook's `org` parameter. It cannot come from the fetched McpServer:
+   * the caller's active org is client-side context the read RPCs never
+   * carry, so `status.oauth_status` fields 3-4 are never populated by
+   * any backend (see the OAuthStatus proto).
+   *
+   * `UNSPECIFIED` when `authMode` is `"manual"` or while the override
+   * lookup has not yet resolved.
    */
   readonly effectiveOAuthSource: OAuthAppSource;
   /**
-   * `true` when an org-level BYOA override is active for this server.
-   * Derived from `effectiveOAuthSource === OAUTH_APP_SOURCE_ORG_OVERRIDE`.
+   * `true` when an org-level BYOA override is active for this server
+   * and org. Derived from the `getOrgOAuthApp` lookup.
    */
   readonly isOrgOAuthApp: boolean;
   /**
    * `true` when the BYOA option is relevant for this server: the server
-   * uses vendor OAuth (`authMode === "oauth"` with an `oauth_app_ref`)
-   * and no org override is currently active.
+   * uses vendor OAuth (`authMode === "oauth"` with an `oauth_app_ref`),
+   * no org override is currently active, AND the backend supports the
+   * org-override surface at all.
+   *
+   * The last condition is an edition capability, confirmed by probing
+   * `getOrgOAuthApp` (see {@link useOrgOAuthApp}): the surface is
+   * hosted-only, so on OSS deployments — where the submit could only
+   * answer UNIMPLEMENTED — this stays `false` and no BYOA affordance
+   * renders (stigmer/stigmer#558).
    *
    * When `true`, the UI should offer "Use your own OAuth app" as either
    * a primary action (when vendor approval is blocked) or a secondary
@@ -201,6 +221,15 @@ export interface UseMcpServerCredentialsReturn {
  * form. Additional non-OAuth vars still appear in `missingVariables`
  * (mixed mode).
  *
+ * **Org-override-aware**: for vendor-OAuth servers with an
+ * `oauth_app_ref`, the hook also composes {@link useOrgOAuthApp} to
+ * resolve which OAuth app the connect flow will use for `org`
+ * (`effectiveOAuthSource` / `isOrgOAuthApp` / `canBringOwnApp`).
+ * The `org` parameter must therefore be the caller's ACTIVE org — the
+ * org credentials are stored in and the org whose BYOA override
+ * applies — not necessarily the org that owns the MCP server (they
+ * differ when browsing another org's public server).
+ *
  * Unlike {@link useMcpServerSetup} which manages multi-server setup
  * for session creation, this hook is scoped to a single server and
  * always persists to the personal environment (no one-time option).
@@ -281,14 +310,51 @@ export function useMcpServerCredentials(
       oauthStatus?.vendorApprovalStatus === VendorApprovalStatus.REJECTED);
   const vendorApprovalDocsUrl = oauthStatus?.vendorApprovalDocsUrl || null;
 
-  const effectiveOAuthSource =
-    oauthStatus?.effectiveOauthSource ??
-    OAuthAppSource.OAUTH_APP_SOURCE_UNSPECIFIED;
-  const isOrgOAuthApp =
-    effectiveOAuthSource === OAuthAppSource.OAUTH_APP_SOURCE_ORG_OVERRIDE;
   const hasOAuthAppRef = Boolean(auth?.oauthAppRef?.slug);
+
+  // Org-override lookup, two duties in one fetch (shared cross-mount via
+  // the hook's fetch cache):
+  //  1. Capability probe (`isSupported`) — the org-override surface is
+  //     hosted-only, so BYOA affordances must hide on OSS (#558).
+  //  2. The override signal (`hasOverride`) — which OAuthApp the connect
+  //     flow will actually use for this org. Resolved client-side because
+  //     the caller's active org is client-side context the read RPCs never
+  //     carry (get has no org; getByReference's org is the server's OWNING
+  //     org, which differs from the caller's org when browsing another
+  //     org's public server), so the fetched McpServer cannot answer this
+  //     (stigmer-cloud#401).
+  // Scoped to vendor-OAuth servers with a platform app ref — the only
+  // shape an override can exist for — so manual/DCR servers pay no RPC.
+  const orgOverride = useOrgOAuthApp(
+    authMode === "oauth" && hasOAuthAppRef
+      ? (mcpServer?.metadata?.id ?? null)
+      : null,
+    org,
+  );
+
+  const isOrgOAuthApp = orgOverride.hasOverride;
+  // While the lookup is in flight, failed, or unposable (an app ref exists
+  // but no org to resolve an override for), the override state is unknown —
+  // report UNSPECIFIED rather than guessing PLATFORM, matching the
+  // documented "not yet resolved" contract. UNSUPPORTED is not unknown:
+  // on OSS the platform-ref app is truthfully the effective source.
+  const overrideUnknown =
+    orgOverride.isLoading ||
+    orgOverride.error !== null ||
+    (hasOAuthAppRef && !org);
+  const effectiveOAuthSource =
+    authMode !== "oauth" || overrideUnknown
+      ? OAuthAppSource.OAUTH_APP_SOURCE_UNSPECIFIED
+      : isOrgOAuthApp
+        ? OAuthAppSource.OAUTH_APP_SOURCE_ORG_OVERRIDE
+        : hasOAuthAppRef
+          ? OAuthAppSource.OAUTH_APP_SOURCE_PLATFORM
+          : OAuthAppSource.OAUTH_APP_SOURCE_NONE;
   const canBringOwnApp =
-    authMode === "oauth" && hasOAuthAppRef && !isOrgOAuthApp;
+    authMode === "oauth" &&
+    hasOAuthAppRef &&
+    !isOrgOAuthApp &&
+    orgOverride.isSupported;
 
   const grantStatus = useOAuthGrantStatus(
     authMode === "oauth" ? (mcpServer?.metadata?.id ?? null) : null,
@@ -339,7 +405,8 @@ export function useMcpServerCredentials(
   const refetch = useCallback(() => {
     personalEnv.refetch();
     grantStatus.refetch();
-  }, [personalEnv, grantStatus]);
+    orgOverride.refetch();
+  }, [personalEnv, grantStatus, orgOverride]);
 
   return {
     authMode,
@@ -358,8 +425,9 @@ export function useMcpServerCredentials(
     manualEntrySupported,
     missingVariables,
     isReady,
-    isLoading: personalEnv.isLoading || grantStatus.isLoading,
-    error: personalEnv.error ?? grantStatus.error,
+    isLoading:
+      personalEnv.isLoading || grantStatus.isLoading || orgOverride.isLoading,
+    error: personalEnv.error ?? grantStatus.error ?? orgOverride.error,
     saveCredentials,
     isSaving: personalEnv.isMutating,
     refetch,

package/src/mcp-server/useMcpServerDefinitionDrift.ts

@@ -0,0 +1,95 @@
+"use client";
+
+import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
+import { useStigmer } from "../hooks.js";
+import { useFetch } from "../internal/useFetch.js";
+import {
+  computeDefinitionDrift,
+  type DriftFieldId,
+} from "./internal/definitionDrift.js";
+
+/** A detected divergence from the marketplace definition. */
+export interface McpServerDefinitionDrift {
+  /** The marketplace definition the comparison ran against. */
+  readonly template: McpServer;
+  /** Connection-defining field groups that differ. Never empty. */
+  readonly changedFields: readonly DriftFieldId[];
+}
+
+/** Return value of {@link useMcpServerDefinitionDrift}. */
+export interface UseMcpServerDefinitionDriftReturn {
+  /**
+   * The detected drift, or `null` — which covers all of: still checking,
+   * no marketplace counterpart, ambiguous counterpart, configurations
+   * match, or the check failed. Consumers need no other state: this is an
+   * advisory affordance, not page data.
+   */
+  readonly drift: McpServerDefinitionDrift | null;
+}
+
+/**
+ * Detects when an org-owned MCP server's connection-defining
+ * configuration has drifted from the marketplace definition it mirrors
+ * (stigmer/stigmer#228: a template fix — e.g. monday.com's OAuth header —
+ * never reached servers copied before the fix, stranding them on a
+ * configuration that can never connect).
+ *
+ * **How the marketplace counterpart is found.** Connected copies carry no
+ * reference back to their template, so the hook uses the platform's own
+ * client-side definition of "marketplace": the search RPC's
+ * `crossOrgPublic` scope (what the library's "All" tab shows). A public
+ * row with the exact same slug from a different org is treated as the
+ * template. Zero or multiple candidates means there is nothing
+ * trustworthy to compare against — the hook stays quiet.
+ *
+ * **Fail-quiet by design.** Drift detection is advisory. No network
+ * error, missing template, or ambiguity may ever degrade the detail page,
+ * so every failure path resolves to `null` rather than an error state.
+ *
+ * Pass `null` to skip (stable no-op) — callers gate on editability, since
+ * the paired refresh action writes to the resource and the notice is
+ * meaningless to viewers who cannot act on it.
+ */
+export function useMcpServerDefinitionDrift(
+  mcpServer: McpServer | null,
+): UseMcpServerDefinitionDriftReturn {
+  const stigmer = useStigmer();
+
+  const org = mcpServer?.metadata?.org ?? null;
+  const slug = mcpServer?.metadata?.slug ?? null;
+
+  const { data: drift } = useFetch<McpServerDefinitionDrift | null>(
+    mcpServer && org && slug
+      ? async () => {
+          try {
+            const result = await stigmer.mcpServer.list({
+              org,
+              query: slug,
+              crossOrgPublic: true,
+            });
+            const candidateOrgs = [
+              ...new Set(
+                result.entries
+                  .filter((e) => e.slug === slug && e.org && e.org !== org)
+                  .map((e) => e.org),
+              ),
+            ];
+            if (candidateOrgs.length !== 1) return null;
+
+            const template = await stigmer.mcpServer.getByReference({
+              org: candidateOrgs[0],
+              slug,
+            });
+            const changedFields = computeDefinitionDrift(mcpServer, template);
+            return changedFields ? { template, changedFields } : null;
+          } catch {
+            return null;
+          }
+        }
+      : null,
+    [mcpServer, org, slug, stigmer],
+    null,
+  );
+
+  return { drift };
+}

package/src/mcp-server/useOrgOAuthApp.ts

@@ -8,11 +8,26 @@ import {
   DeleteOrgOAuthAppInputSchema,
 } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/io_pb";
 import { useStigmer } from "../hooks.js";
+import { isUnimplemented } from "../internal/isUnimplemented.js";
 import { toError } from "../internal/toError.js";
 import { useFetch } from "../internal/useFetch.js";
 
 /** Return value of {@link useOrgOAuthApp}. */
 export interface UseOrgOAuthAppReturn {
+  /**
+   * Whether the backend supports the org-OAuth-app override surface at all.
+   *
+   * The surface is hosted-only by design: the OSS server answers
+   * UNIMPLEMENTED for all three org-override RPCs because its flat
+   * OAuthApp store has no override binding (stigmer/stigmer#558 — the
+   * self-hosted equivalent is applying an OAuthApp resource and
+   * referencing it from `spec.auth.oauth_app_ref`). The fetch doubles
+   * as the capability probe: `isSupported` is `false` until the first
+   * successful response confirms the surface exists, so BYOA
+   * affordances gated on it never flash on deployments where the
+   * submit could only fail.
+   */
+  readonly isSupported: boolean;
   /** Whether an org-level BYOA override exists for this resource + org. */
   readonly hasOverride: boolean;
   /** System-generated ID of the override's OAuthApp, or `null` when absent. */
@@ -72,12 +87,25 @@ export interface UseOrgOAuthAppReturn {
 }
 
 interface OrgOAuthAppData {
+  isSupported: boolean;
   hasOverride: boolean;
   oauthAppId: string | null;
   clientId: string | null;
 }
 
 const IDLE_DATA: OrgOAuthAppData = {
+  isSupported: false,
+  hasOverride: false,
+  oauthAppId: null,
+  clientId: null,
+};
+
+/**
+ * The UNIMPLEMENTED answer resolved into data rather than an error:
+ * the backend is healthy, it just doesn't have this edition capability.
+ */
+const UNSUPPORTED_DATA: OrgOAuthAppData = {
+  isSupported: false,
   hasOverride: false,
   oauthAppId: null,
   clientId: null,
@@ -110,6 +138,14 @@ const IDLE: UseOrgOAuthAppReturn = {
  * mutations bound to the hook's resource + org context, eliminating
  * parameter repetition at call sites.
  *
+ * **Edition awareness**: the fetch doubles as a capability probe. The
+ * org-override surface is hosted-only; the OSS server answers
+ * UNIMPLEMENTED for it, which this hook resolves into
+ * `isSupported: false` with no error. Gate every BYOA affordance on
+ * `isSupported` (as {@link useMcpServerCredentials} does for
+ * `canBringOwnApp`) — the mutations can only fail where the probe
+ * reports the surface absent.
+ *
  * Pass `null` for either parameter to skip fetching (stable no-op).
  *
  * @example
@@ -136,18 +172,28 @@ export function useOrgOAuthApp(
   const { data, isLoading, isRefetching, error, refetch } = useFetch<OrgOAuthAppData>(
     resourceId && org
       ? async () => {
-          const result = await stigmer.mcpServer.getOrgOAuthApp(
-            create(GetOrgOAuthAppInputSchema, { resourceId, org }),
-          );
-          return {
-            hasOverride: result.hasOverride,
-            oauthAppId: result.oauthAppId || null,
-            clientId: result.clientId || null,
-          };
+          try {
+            const result = await stigmer.mcpServer.getOrgOAuthApp(
+              create(GetOrgOAuthAppInputSchema, { resourceId, org }),
+            );
+            return {
+              isSupported: true,
+              hasOverride: result.hasOverride,
+              oauthAppId: result.oauthAppId || null,
+              clientId: result.clientId || null,
+            };
+          } catch (err) {
+            if (isUnimplemented(err)) return UNSUPPORTED_DATA;
+            throw err;
+          }
         }
       : null,
     [resourceId, org, stigmer],
     IDLE_DATA,
+    // Cross-mount cache: the credentials hook composes this fetch as its
+    // capability probe, so a detail page mounts two instances — the cache
+    // lets the second render from the first's result.
+    { cacheKey: `org-oauth-app:${org}:${resourceId}` },
   );
 
   const [isSetting, setIsSetting] = useState(false);

package/src/models/ModelRegistryContext.ts

@@ -1,11 +1,17 @@
 "use client";
 
 import { createContext, useContext } from "react";
-import type { ModelInfo } from "./registry.js";
+import type { ModelInfo, VisionLimits } from "./registry.js";
 
 /** Internal state held by the model registry context provider. */
 export interface ModelRegistryState {
   readonly models: readonly ModelInfo[];
+  /**
+   * Document-level vision byte budget (stigmer/stigmer#365).
+   * `undefined` while loading or when the served document predates the
+   * `limits` block — consumers stay silent rather than assume a budget.
+   */
+  readonly visionLimits?: VisionLimits;
   readonly isLoading: boolean;
   readonly error: Error | null;
   /** Retry fetching the model registry. No-op while a fetch is in flight. */

package/src/models/ModelSelector.tsx

@@ -629,6 +629,17 @@ function ModelRow({
       <div className="stg:flex stg:w-full stg:items-center stg:gap-2">
         <span className="stg:flex-1 stg:truncate stg:text-left stg:font-medium">{model.displayName}</span>
 
+        {/* Explicit vision:false only (stigmer/stigmer#386) — an unassessed
+            model (absent capabilities block) shows nothing, per the
+            registry's tri-state convention. Visible text, not a tooltip:
+            keyboard and touch users must see it before picking the model. */}
+        {model.visionCapability === false && (
+          <span className="stg:flex stg:shrink-0 stg:items-center stg:gap-0.5 stg:text-[0.6rem] stg:text-muted-foreground">
+            <NoImageInputIcon />
+            No image input
+          </span>
+        )}
+
         <span className="stg:shrink-0 stg:text-[0.6rem] stg:text-muted-foreground">
           {showSpeedBadge
             ? `${SPEED_TIER_LABEL[model.speedTier]} ${COST_TIER_LABEL[model.costTier]}`
@@ -683,6 +694,32 @@ function CheckIcon({ className }: { className?: string }) {
   );
 }
 
+/**
+ * "Image with a slash" glyph for models explicitly assessed as unable to
+ * see images. Decorative (`aria-hidden`) — the wrapping span carries the
+ * accessible text.
+ */
+function NoImageInputIcon() {
+  return (
+    <svg
+      width="11"
+      height="11"
+      viewBox="0 0 12 12"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="1.2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      aria-hidden
+    >
+      <rect x="1.5" y="2" width="9" height="8" rx="1.2" />
+      <path d="M1.5 8L4.2 5.6L6.4 7.6" />
+      <circle cx="7.6" cy="4.6" r="0.8" fill="currentColor" stroke="none" />
+      <path d="M1 1L11 11" />
+    </svg>
+  );
+}
+
 function BoltIcon() {
   return (
     <svg

package/src/models/__tests__/ModelSelector-visionIndicator.test.tsx

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, afterEach, beforeAll } from "vitest";
+import { render, screen, cleanup, fireEvent } from "@testing-library/react";
+import { ModelSelector } from "../ModelSelector";
+import { ModelRegistryContext } from "../ModelRegistryContext";
+import type { ModelInfo } from "../registry";
+
+// Shim ResizeObserver for Base UI's positioner (the
+// scheduleCreation.test.tsx pattern).
+beforeAll(() => {
+  if (!("ResizeObserver" in globalThis)) {
+    (globalThis as unknown as { ResizeObserver: unknown }).ResizeObserver =
+      class {
+        observe() {}
+        unobserve() {}
+        disconnect() {}
+      };
+  }
+});
+
+/**
+ * "No image input" indicator on model rows (stigmer/stigmer#386).
+ *
+ * Tri-state contract: the indicator renders ONLY for models the registry
+ * explicitly assessed as blind (`visionCapability === false`). A sighted
+ * model shows nothing, and — the load-bearing case — an UNASSESSED model
+ * (absent capabilities block) also shows nothing: most registry entries
+ * were never capability-assessed, and flagging them all as blind would
+ * be wrong for nearly every one.
+ */
+
+const BLIND: ModelInfo = {
+  modelId: "kimi-k3",
+  provider: "moonshot",
+  displayName: "Kimi K3",
+  shortDescription: "Text-only economy model",
+  speedTier: "fast",
+  costTier: "economy",
+  harness: "cursor",
+  featured: true,
+  serviceTiers: [],
+  visionCapability: false,
+};
+
+const SIGHTED: ModelInfo = {
+  modelId: "composer-2.5",
+  provider: "cursor",
+  displayName: "Composer 2.5",
+  shortDescription: "Fast agentic model",
+  speedTier: "fastest",
+  costTier: "economy",
+  harness: "cursor",
+  featured: true,
+  serviceTiers: [],
+  visionCapability: true,
+};
+
+const UNASSESSED: ModelInfo = {
+  modelId: "mystery-model",
+  provider: "cursor",
+  displayName: "Mystery Model",
+  shortDescription: "Never capability-assessed",
+  speedTier: "fast",
+  costTier: "standard",
+  harness: "cursor",
+  featured: true,
+  serviceTiers: [],
+};
+
+function renderSelector() {
+  return render(
+    <ModelRegistryContext.Provider
+      value={{
+        models: [BLIND, SIGHTED, UNASSESSED],
+        isLoading: false,
+        error: null,
+        refetch: vi.fn(),
+      }}
+    >
+      <ModelSelector
+        value="composer-2.5"
+        onValueChange={vi.fn()}
+        harness="cursor"
+      />
+    </ModelRegistryContext.Provider>,
+  );
+}
+
+async function openPopover(triggerLabel: string) {
+  fireEvent.click(screen.getByRole("button", { name: new RegExp(triggerLabel) }));
+  await screen.findByPlaceholderText("Search models…");
+}
+
+/** A model row inside the popup list (never matches the trigger). */
+function modelOption(displayName: string): HTMLElement {
+  const option = screen
+    .getAllByText(displayName)
+    .map((el) => el.closest<HTMLElement>("[data-model-option]"))
+    .find((el) => el != null);
+  if (!option) throw new Error(`No popup option for "${displayName}"`);
+  return option;
+}
+
+afterEach(cleanup);
+
+describe("ModelSelector — no-image-input indicator", () => {
+  it("marks an explicitly blind model with visible badge text", async () => {
+    renderSelector();
+    await openPopover("Composer 2.5");
+
+    // Visible text, not a tooltip — keyboard and touch users must see it
+    // before picking the model (stigmer/no-native-title).
+    const row = modelOption("Kimi K3");
+    expect(row.textContent).toContain("No image input");
+  });
+
+  it("shows nothing on an explicitly sighted model", async () => {
+    renderSelector();
+    await openPopover("Composer 2.5");
+
+    expect(modelOption("Composer 2.5").textContent).not.toContain("No image input");
+  });
+
+  it("shows nothing on an unassessed model (tri-state: absent is not false)", async () => {
+    renderSelector();
+    await openPopover("Composer 2.5");
+
+    expect(modelOption("Mystery Model").textContent).not.toContain("No image input");
+  });
+});

package/src/models/__tests__/resolveDefaultModel.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect } from "vitest";
+import {
+  DEFAULT_CURSOR_MODEL_ID,
+  DEFAULT_MODEL_ID,
+  resolveDefaultModelId,
+  type ModelInfo,
+} from "../registry";
+
+/**
+ * The harness-default arm is a contract, not a suggestion
+ * (stigmer/stigmer#663): this resolution feeds the composer's pill, and
+ * the submission adopts what the pill displays — so the default must be
+ * what the platform actually runs for an unpinned execution:
+ *
+ * - cursor → the registry's Auto entry (the runner coerces an empty
+ *   model_name to "default")
+ * - native → the runner's getDefaultModel() rule (featured + standard
+ *   cost, then any standard cost)
+ */
+
+function model(overrides: Partial<ModelInfo> & { modelId: string }): ModelInfo {
+  return {
+    provider: "anthropic",
+    displayName: overrides.modelId,
+    shortDescription: "",
+    speedTier: "fast",
+    costTier: "standard",
+    harness: "native",
+    featured: false,
+    serviceTiers: [],
+    ...overrides,
+  };
+}
+
+describe("resolveDefaultModelId — cursor harness", () => {
+  it("prefers the Auto entry over featured models listed before it (the production order that caused #663)", () => {
+    // Mirrors the live registry: featured premium models precede Auto.
+    const models = [
+      model({ modelId: "claude-opus-4-8", harness: "cursor", featured: true, costTier: "premium" }),
+      model({ modelId: DEFAULT_CURSOR_MODEL_ID, harness: "cursor", featured: true }),
+    ];
+    expect(resolveDefaultModelId("cursor", models)).toEqual({
+      modelId: DEFAULT_CURSOR_MODEL_ID,
+      source: "harness_default",
+    });
+  });
+
+  it("falls back to the first featured cursor model when the registry has no Auto entry", () => {
+    const models = [
+      model({ modelId: "composer-2.5", harness: "cursor", featured: true }),
+    ];
+    expect(resolveDefaultModelId("cursor", models).modelId).toBe("composer-2.5");
+  });
+
+  it("falls back to the hardcoded cursor id on an empty registry", () => {
+    expect(resolveDefaultModelId("cursor", [])).toEqual({
+      modelId: DEFAULT_CURSOR_MODEL_ID,
+      source: "platform_fallback",
+    });
+  });
+
+  it("lets an explicit user preference win over Auto", () => {
+    const models = [
+      model({ modelId: DEFAULT_CURSOR_MODEL_ID, harness: "cursor", featured: true }),
+      model({ modelId: "composer-2.5", harness: "cursor", featured: true }),
+    ];
+    expect(
+      resolveDefaultModelId("cursor", models, { userPreference: "composer-2.5" }),
+    ).toEqual({ modelId: "composer-2.5", source: "user_preference" });
+  });
+});
+
+describe("resolveDefaultModelId — native harness", () => {
+  it("skips a featured premium model for the featured standard-cost one (the runner's own rule)", () => {
+    const models = [
+      model({ modelId: "claude-opus-4.6", featured: true, costTier: "premium" }),
+      model({ modelId: "claude-sonnet-4.6", featured: true, costTier: "standard" }),
+    ];
+    expect(resolveDefaultModelId("native", models)).toEqual({
+      modelId: "claude-sonnet-4.6",
+      source: "harness_default",
+    });
+  });
+
+  it("falls back to any standard-cost model when no featured one is standard", () => {
+    const models = [
+      model({ modelId: "claude-opus-4.6", featured: true, costTier: "premium" }),
+      model({ modelId: "gpt-4o", featured: false, costTier: "standard" }),
+    ];
+    expect(resolveDefaultModelId("native", models).modelId).toBe("gpt-4o");
+  });
+
+  it("falls back to the first featured model when the registry lists no standard-cost model at all", () => {
+    const models = [
+      model({ modelId: "claude-opus-4.6", featured: true, costTier: "premium" }),
+      model({ modelId: "ollama-local", featured: false, costTier: "economy" }),
+    ];
+    expect(resolveDefaultModelId("native", models).modelId).toBe("claude-opus-4.6");
+  });
+
+  it("falls back to the hardcoded native id on an empty registry", () => {
+    expect(resolveDefaultModelId("native", [])).toEqual({
+      modelId: DEFAULT_MODEL_ID,
+      source: "platform_fallback",
+    });
+  });
+
+  it("never resolves across harnesses (a cursor Auto entry is invisible to native)", () => {
+    const models = [
+      model({ modelId: DEFAULT_CURSOR_MODEL_ID, harness: "cursor", featured: true }),
+      model({ modelId: "claude-sonnet-4.6", featured: true, costTier: "standard" }),
+    ];
+    expect(resolveDefaultModelId("native", models).modelId).toBe("claude-sonnet-4.6");
+  });
+});