@stigmer/react 3.12.3 → 3.12.5

package/src/session/useNewSessionFlow.ts

@@ -1,7 +1,8 @@
 "use client";
 
-import { useCallback, useEffect, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { getUserMessage, type McpServerUsageInput, type ResourceRef } from "@stigmer/sdk";
+import type { AccountExecutionDefaults } from "../identity-account/useAccountExecutionDefaults.js";
 import type { AgentResolution } from "../agent/index.js";
 import { useDefaultAgent } from "../agent/index.js";
 import { useModelRegistry } from "../models/index.js";
@@ -102,6 +103,26 @@ export interface UseNewSessionFlowOptions {
    * @default DEFAULT_HARNESS ("native")
    */
   readonly defaultHarness?: HarnessOption;
+  /**
+   * The user's account-level execution defaults
+   * (`IdentityAccountPreferences.default_*`), typically from
+   * `useAccountExecutionDefaults()`. A SEED in the layered precedence —
+   * explicit device-local choices always outrank it:
+   *
+   * - harness: stored choice > `accountDefaults.harness` >
+   *   {@link defaultHarness} > platform default. May arrive after mount
+   *   (whoAmI resolves async); a late value still seeds unless the user
+   *   has already picked a harness this mount.
+   * - model: stored per-harness choice > the account's model for the
+   *   active harness (validated against the registry; a stale model
+   *   silently falls through) > the harness default.
+   *
+   * Seeded values are never persisted to localStorage — the account
+   * preference keeps applying until the user decides. Ignored for the
+   * `"guest"` audience (platform share policy owns guest config), and
+   * consumers must not fetch identity for guest/embed surfaces.
+   */
+  readonly accountDefaults?: AccountExecutionDefaults;
   /**
    * Who this flow serves. `"guest"` adapts the orchestration to the
    * guest principal's permission model: the org default-agent lookup
@@ -162,7 +183,12 @@ export interface UseNewSessionFlowReturn {
   /** Switch the harness. Resets the model if invalid for the new harness. */
   readonly setHarness: (harness: HarnessOption) => void;
 
-  /** Currently selected model ID (persisted per-harness to localStorage). */
+  /**
+   * The model an untouched send will run: the explicit device pick when
+   * one exists (persisted per-harness to localStorage), else the account
+   * default for the active harness. `undefined` resolves to the harness
+   * default downstream.
+   */
   readonly modelId: string | undefined;
   /** Update the selected model. Automatically persists to localStorage. */
   readonly setModelId: (id: string) => void;
@@ -269,6 +295,10 @@ export function useNewSessionFlow(
     sessionContext,
   } = options;
   const isGuest = options.audience === "guest";
+  // Guests never inherit account defaults — the platform share policy owns
+  // guest execution config (GUEST_HARNESS reasoning), and identity-derived
+  // preferences must never shape a share/embed surface.
+  const accountDefaults = isGuest ? undefined : options.accountDefaults;
   // Guests never carry a client pin: guest execution config is owned by
   // the server-side share policy (GUEST_HARNESS reasoning). Validated at
   // render so a statically-wrong pin (fast tier, no model) fails in the
@@ -293,13 +323,30 @@ export function useNewSessionFlow(
     // touch localStorage: a browser previously used in the Console must not
     // leak its stored harness into a share/embed session.
     if (isGuest) return GUEST_HARNESS;
-    if (typeof window === "undefined") return defaultHarness ?? DEFAULT_HARNESS;
+    if (typeof window === "undefined")
+      return accountDefaults?.harness ?? defaultHarness ?? DEFAULT_HARNESS;
     // Only explicit user choices are persisted (see setHarness), so a
-    // stored value always outranks the embedder's defaultHarness.
+    // stored value always outranks the account default and the embedder's
+    // defaultHarness.
     const stored = localStorage.getItem(STORAGE_KEY_HARNESS);
     if (stored === "native" || stored === "cursor") return stored;
-    return defaultHarness ?? DEFAULT_HARNESS;
+    return accountDefaults?.harness ?? defaultHarness ?? DEFAULT_HARNESS;
   });
+  // Set once the user picks a harness this mount — a late-arriving account
+  // default must never override an explicit choice (the composer's
+  // userOverrodeModel idiom).
+  const harnessTouchedRef = useRef(false);
+
+  // Account defaults resolve async (whoAmI): when the harness seed arrives
+  // after mount, apply it once — unless the user has picked or a stored
+  // choice exists. Never persisted: seeding must not masquerade as a user
+  // choice, or the account preference would stop applying elsewhere.
+  useEffect(() => {
+    const seed = accountDefaults?.harness;
+    if (isGuest || harnessTouchedRef.current || !seed) return;
+    if (typeof window !== "undefined" && localStorage.getItem(STORAGE_KEY_HARNESS)) return;
+    setHarnessRaw(seed);
+  }, [isGuest, accountDefaults?.harness]);
 
   const stigmer = useStigmer();
   const { getModel, isLoading: isModelsLoading } = useModelRegistry({ harness });
@@ -326,8 +373,26 @@ export function useNewSessionFlow(
 
   const validModelId = modelId && getModel(modelId) ? modelId : undefined;
 
+  // The account's model for the active harness, registry-validated the same
+  // way as the stored choice (a stale/removed preference silently falls
+  // through to the harness default — self-healing). Derived, never written
+  // into `modelId` state: the persist effect below stores only explicit
+  // choices, and a derived seed cannot leak into localStorage.
+  const accountModelForHarness =
+    harness === "cursor" ? accountDefaults?.cursorModel : accountDefaults?.nativeModel;
+  const accountModelId =
+    accountModelForHarness && getModel(accountModelForHarness)
+      ? accountModelForHarness
+      : undefined;
+
+  // Layered precedence: explicit device pick > account default. The result
+  // feeds the composer's model pill AND the submit path, so the pill always
+  // shows what an untouched send will run (#663).
+  const effectiveModelId = validModelId ?? accountModelId;
+
   const setHarness = useCallback(
     (h: HarnessOption) => {
+      harnessTouchedRef.current = true;
       setHarnessRaw(h);
       // Guests have no harness picker; if a caller invokes this anyway, the
       // guest surface must never write into the Console's preference keys.
@@ -415,8 +480,10 @@ export function useNewSessionFlow(
           // The owner pin wins over the composer and the restored
           // preference (#664); the pinned tier is stamped only as
           // "fast" — standard stays off the wire, preserving the #357
-          // UNSPECIFIED-vs-explicit telemetry distinction.
-          modelName: pinnedModelName ?? selectedModel ?? validModelId,
+          // UNSPECIFIED-vs-explicit telemetry distinction. The effective
+          // model carries the account-default seed explicitly (DD-003:
+          // the preference is a seed; the execution spec is the record).
+          modelName: pinnedModelName ?? selectedModel ?? effectiveModelId,
           runtimeEnv,
           attachments: context?.attachments,
           interactionMode: context?.interactionMode,
@@ -514,7 +581,7 @@ export function useNewSessionFlow(
       autoApproveAll,
       adapter,
       getRuntimeEnv,
-      validModelId,
+      effectiveModelId,
       pinnedModelName,
       pinnedServiceTier,
       workspace,
@@ -539,7 +606,7 @@ export function useNewSessionFlow(
   return {
     harness,
     setHarness,
-    modelId: validModelId,
+    modelId: effectiveModelId,
     setModelId,
     agentRef,
     setAgentRef,

package/src/session/useSessionUsage.ts

@@ -41,6 +41,25 @@ export interface ModelCostEntry {
   readonly callCount: number;
 }
 
+/**
+ * Per-execution model provenance from billing records (stigmer/stigmer#362).
+ */
+export interface ExecutionUsageEntry {
+  /** Execution identifier (`metadata.id`). */
+  readonly executionId: string;
+  /**
+   * Billing-resolved primary model — what the provider actually served.
+   * For a Cursor Auto execution this is the after-the-fact answer to
+   * "which model did Auto pick", which the requested model (empty by
+   * definition there) can never give.
+   */
+  readonly resolvedModel: string;
+  /** Billable cost in USD for this execution. */
+  readonly billableCostUsd: number;
+  /** `true` while this execution's records are still provisional. */
+  readonly isEstimated: boolean;
+}
+
 /** Return value of {@link useSessionUsage}. */
 export interface UseSessionUsageReturn {
   /** Aggregate estimated cost in USD across all models. */
@@ -59,6 +78,13 @@ export interface UseSessionUsageReturn {
   readonly llmCallCount: number;
   /** Per-model cost and token breakdown. */
   readonly modelBreakdown: readonly ModelCostEntry[];
+  /**
+   * Per-execution resolved model + cost, chronological, from billing
+   * records (#362). Empty until the first authoritative record lands —
+   * the streaming fallback deliberately contributes none, because the
+   * runner only knows what it REQUESTED, never what the provider served.
+   */
+  readonly executionBreakdown: readonly ExecutionUsageEntry[];
   /** Model with the highest usage in this session. */
   readonly primaryModel: string;
   /** Provider of the primary model. */
@@ -82,6 +108,7 @@ const EMPTY: UseSessionUsageReturn = {
   cacheCreationTokens: 0,
   llmCallCount: 0,
   modelBreakdown: [],
+  executionBreakdown: [],
   primaryModel: "",
   primaryProvider: "",
   hasUsage: false,
@@ -122,6 +149,12 @@ function mapReport(report: GetSessionUsageReportOutput): UseSessionUsageReturn {
     cacheCreationTokens: Number(agg.cacheCreationInputTokens),
     llmCallCount,
     modelBreakdown: report.modelBreakdown.map(mapModelUsage),
+    executionBreakdown: report.executions.map((e) => ({
+      executionId: e.executionId,
+      resolvedModel: e.primaryModel,
+      billableCostUsd: microsToUsd(e.billableCostMicros),
+      isEstimated: e.isEstimated,
+    })),
     primaryModel: agg.primaryModel,
     primaryProvider: agg.primaryProvider,
     hasUsage: llmCallCount > 0 || totalTokens > 0 || billableCost > 0,
@@ -169,6 +202,10 @@ function aggregateStreamingUsage(
     cacheReadTokens,
     cacheCreationTokens,
     llmCallCount: turnCount,
+    // No executionBreakdown here on purpose: the runner only knows the
+    // REQUESTED model; resolved-model rows exist only once billing
+    // records land (#362).
+    executionBreakdown: [],
     modelBreakdown: model
       ? [
           {

package/src/settings/AccountPreferencesSection.tsx

@@ -0,0 +1,25 @@
+"use client";
+
+import { useId } from "react";
+import { AccountPreferencesPanel } from "../identity-account/AccountPreferencesPanel.js";
+
+/** Settings section for editing the current user's declared preferences. */
+export function AccountPreferencesSection() {
+  const headingId = useId();
+
+  return (
+    <section aria-labelledby={headingId}>
+      <h2
+        id={headingId}
+        className="stg:text-foreground stg:mb-1 stg:text-sm stg:font-semibold"
+      >
+        Account Preferences
+      </h2>
+      <p className="stg:text-muted-foreground stg:mb-6 stg:text-xs">
+        Personal standing context shared with agents on executions you run.
+      </p>
+
+      <AccountPreferencesPanel />
+    </section>
+  );
+}

package/src/settings/OrgPreferencesSection.tsx

@@ -0,0 +1,35 @@
+"use client";
+
+import { useId } from "react";
+import { OrgPreferencesPanel } from "../organization/OrgPreferencesPanel.js";
+import { useOrg } from "../organization/OrgProvider.js";
+
+/** Settings section for editing the active organization's declared preferences. */
+export function OrgPreferencesSection() {
+  const headingId = useId();
+  const { activeOrg } = useOrg();
+  const orgId = activeOrg?.metadata?.id ?? "";
+
+  return (
+    <section aria-labelledby={headingId}>
+      <h2
+        id={headingId}
+        className="stg:text-foreground stg:mb-1 stg:text-sm stg:font-semibold"
+      >
+        Organization Preferences
+      </h2>
+      <p className="stg:text-muted-foreground stg:mb-6 stg:text-xs">
+        Standing context shared with agents on every execution run by this
+        organization&apos;s members.
+      </p>
+
+      {!orgId ? (
+        <p className="stg:text-muted-foreground stg:py-4 stg:text-center stg:text-xs">
+          Select an organization to view its preferences.
+        </p>
+      ) : (
+        <OrgPreferencesPanel orgId={orgId} />
+      )}
+    </section>
+  );
+}

package/src/settings/__tests__/settings-nav.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from "vitest";
+import { SETTINGS_NAV_GROUPS } from "../settings-nav";
+
+// The nav model is the single source for the sidebar AND both client-app
+// landing grids — these entries disappearing would silently orphan the
+// preference pages everywhere at once.
+describe("SETTINGS_NAV_GROUPS preference entries", () => {
+  it("lists org preferences in the Organization group", () => {
+    const organization = SETTINGS_NAV_GROUPS.find(
+      (g) => g.label === "Organization",
+    );
+    expect(organization).toBeDefined();
+    expect(
+      organization!.items.find((i) => i.href === "/settings/org-preferences")
+        ?.label,
+    ).toBe("Preferences");
+  });
+
+  it("lists account preferences in the Account group", () => {
+    const account = SETTINGS_NAV_GROUPS.find((g) => g.label === "Account");
+    expect(account).toBeDefined();
+    expect(
+      account!.items.find((i) => i.href === "/settings/account-preferences")
+        ?.label,
+    ).toBe("Preferences");
+  });
+});

package/src/settings/__tests__/useSettingsNavGroups.test.tsx

@@ -48,6 +48,7 @@ describe("useSettingsNavGroups", () => {
     verdicts = {
       can_manage_model_pricing: true,
       can_manage_cursor_accounts: true,
+      can_view_provider_standing: true,
     };
     render(<GroupsProbe />);
 
@@ -56,7 +57,7 @@ describe("useSettingsNavGroups", () => {
       `${BASE_LABELS},${PLATFORM_SETTINGS_NAV_GROUP.label}`,
     );
     expect(el.getAttribute("data-platform-items")).toBe(
-      "Pricing Governance,Cursor Accounts",
+      "Pricing Governance,Cursor Accounts,Provider Standing",
     );
   });
 
@@ -78,6 +79,15 @@ describe("useSettingsNavGroups", () => {
     );
   });
 
+  it("filters per item: standing-only operator sees only Provider Standing", () => {
+    verdicts = { can_view_provider_standing: true };
+    render(<GroupsProbe />);
+
+    expect(screen.getByTestId("groups").getAttribute("data-platform-items")).toBe(
+      "Provider Standing",
+    );
+  });
+
   it("returns exactly the base groups when not authorized", () => {
     function IdentityProbe() {
       const groups = useSettingsNavGroups();

package/src/settings/index.ts

@@ -10,6 +10,8 @@ export { BillingSection } from "./BillingSection.js";
 export type { BillingSectionProps } from "./BillingSection.js";
 export { MembersSection } from "./MembersSection.js";
 export { OrgProfileSection } from "./OrgProfileSection.js";
+export { OrgPreferencesSection } from "./OrgPreferencesSection.js";
+export { AccountPreferencesSection } from "./AccountPreferencesSection.js";
 export { EnvironmentsSection } from "./EnvironmentsSection.js";
 export { InvitationsSection } from "./InvitationsSection.js";
 export { IdentityProvidersSection } from "./IdentityProvidersSection.js";

package/src/settings/settings-nav.ts

@@ -1,5 +1,6 @@
 import type { ComponentType } from "react";
 import {
+  Activity,
   AppWindow,
   BarChart3,
   Box,
@@ -12,6 +13,8 @@ import {
   Plug,
   Scale,
   ShieldCheck,
+  SlidersHorizontal,
+  UserCog,
   Users,
 } from "lucide-react";
 
@@ -54,6 +57,11 @@ export const SETTINGS_NAV_GROUPS: readonly SettingsNavGroup[] = [
       "Manage your team, organization identity, and identity providers.",
     items: [
       { href: "/settings/org-profile", label: "Org Profile", icon: Building2 },
+      {
+        href: "/settings/org-preferences",
+        label: "Preferences",
+        icon: SlidersHorizontal,
+      },
       { href: "/settings/members", label: "Members", icon: Users },
       { href: "/settings/invitations", label: "Invitations", icon: Link },
       {
@@ -91,6 +99,17 @@ export const SETTINGS_NAV_GROUPS: readonly SettingsNavGroup[] = [
       { href: "/settings/usage", label: "Usage", icon: BarChart3 },
     ],
   },
+  {
+    label: "Account",
+    description: "Personal settings that apply to you across the platform.",
+    items: [
+      {
+        href: "/settings/account-preferences",
+        label: "Preferences",
+        icon: UserCog,
+      },
+    ],
+  },
 ];
 
 /**
@@ -123,5 +142,11 @@ export const PLATFORM_SETTINGS_NAV_GROUP: SettingsNavGroup = {
       icon: MousePointerClick,
       requiredPermission: "can_manage_cursor_accounts",
     },
+    {
+      href: "/settings/provider-standing",
+      label: "Provider Standing",
+      icon: Activity,
+      requiredPermission: "can_view_provider_standing",
+    },
   ],
 };

package/src/settings/useSettingsNavGroups.ts

@@ -52,14 +52,21 @@ export function useSettingsNavGroups(): readonly SettingsNavGroup[] {
     "can_manage_cursor_accounts",
     { fail: "closed" },
   );
+  const providerStanding = useCheckPermission(
+    PLATFORM_RESOURCE,
+    "can_view_provider_standing",
+    { fail: "closed" },
+  );
 
   const pricingAllowed = pricing.allowed;
   const cursorAccountsAllowed = cursorAccounts.allowed;
+  const providerStandingAllowed = providerStanding.allowed;
 
   return useMemo(() => {
     const verdicts: Record<string, boolean> = {
       can_manage_model_pricing: pricingAllowed,
       can_manage_cursor_accounts: cursorAccountsAllowed,
+      can_view_provider_standing: providerStandingAllowed,
     };
 
     const visibleItems = PLATFORM_SETTINGS_NAV_GROUP.items.filter(
@@ -77,5 +84,5 @@ export function useSettingsNavGroups(): readonly SettingsNavGroup[] {
       ...SETTINGS_NAV_GROUPS,
       { ...PLATFORM_SETTINGS_NAV_GROUP, items: visibleItems },
     ];
-  }, [pricingAllowed, cursorAccountsAllowed]);
+  }, [pricingAllowed, cursorAccountsAllowed, providerStandingAllowed]);
 }

package/src/sharing/ShareAgentDialog.tsx

@@ -3,6 +3,7 @@
 import { useCallback, useId, useMemo, useRef, useState, type FormEvent } from "react";
 import { cn } from "@stigmer/theme";
 import { DialogShell } from "../internal/DialogShell.js";
+import { UNSTYLED_LIST } from "../internal/element-resets.js";
 import {
   MAX_ALLOWED_ORIGINS,
   StigmerError,
@@ -1316,7 +1317,7 @@ function OriginsEditor({
       </p>
 
       {draft.allowedOrigins.length > 0 && (
-        <ul className="stg:mt-2 stg:flex stg:flex-col stg:divide-y stg:divide-border stg:rounded-md stg:border stg:border-border">
+        <ul className={cn(UNSTYLED_LIST, "stg:mt-2 stg:flex stg:flex-col stg:divide-y stg:divide-border stg:rounded-md stg:border stg:border-border")}>
           {draft.allowedOrigins.map((origin) => (
             <li
               key={origin}

package/src/sidebar/WorkspaceSidebar.tsx

@@ -15,6 +15,7 @@ import type { RecentActivityEntry, RecentActivityGroup } from "../activity/types
 import { groupRecentActivityByTime } from "../activity/group-activity.js";
 import { formatRelativeTime } from "../activity/format-relative-time.js";
 import { recentActivityStatusBadge } from "../activity/entry-status-badge.js";
+import { UNSTYLED_LIST } from "../internal/element-resets.js";
 import { ScrollArea } from "../internal/scroll-area.js";
 import {
   Tooltip,
@@ -313,7 +314,7 @@ function ActivityGroupList({
             <p className="stg:text-sidebar-muted-foreground stg:mb-1 stg:px-2 stg:text-[10px] stg:font-medium stg:tracking-wider stg:uppercase">
               {group.label}
             </p>
-            <ul className="stg:space-y-0.5" role="list">
+            <ul className={`${UNSTYLED_LIST} stg:space-y-0.5`} role="list">
               {group.entries.map((entry) => (
                 <ActivityEntry
                   key={entry.id}

package/src/skill/SkillFileBrowser.tsx

@@ -3,6 +3,7 @@
 import { useMemo, useState } from "react";
 import Markdown from "react-markdown";
 import { cn } from "@stigmer/theme";
+import { UNSTYLED_LIST } from "../internal/element-resets.js";
 import { MARKDOWN_COMPONENTS, REMARK_PLUGINS, stripFrontmatter } from "../internal/markdown-components.js";
 import { buildFileTree, FileTreeNode } from "../internal/file-tree/index.js";
 import { useSkillArtifact } from "./useSkillArtifact.js";
@@ -132,7 +133,7 @@ export function SkillFileBrowser({
           className="stg:border-b stg:border-border stg:md:border-b-0 stg:md:border-r stg:overflow-y-auto"
           aria-label="Skill package file tree"
         >
-          <ul className="stg:py-1" role="tree">
+          <ul className={cn(UNSTYLED_LIST, "stg:py-1")} role="tree">
             {treeNodes.map((node) => (
               <FileTreeNode
                 key={node.path}

package/src/skill/__tests__/SkillFileBrowser.test.tsx

@@ -2,7 +2,7 @@ import { describe, it, expect, vi, afterEach } from "vitest";
 import { render, screen, fireEvent } from "@testing-library/react";
 import type { ReactNode } from "react";
 import { zipSync, strToU8 } from "fflate";
-import type { Stigmer } from "@stigmer/sdk";
+import { StigmerError, type Stigmer } from "@stigmer/sdk";
 import { StigmerContext } from "../../context";
 import { SkillFileBrowser } from "../SkillFileBrowser";
 
@@ -12,14 +12,22 @@ function wrapperFor(stigmer: Stigmer) {
   );
 }
 
+/** Connect's Unimplemented code — what a pre-transfer-lane server answers. */
+const CODE_UNIMPLEMENTED = 12;
+
 /**
  * Builds a real ZIP (via fflate, the same library the unpacker uses) and a
  * Stigmer client whose `skill.getArtifact` serves it — so tests exercise the
  * genuine fetch → unzip → browse path instead of stubbing the unpacker.
+ * The download-URL mint answers Unimplemented (a pre-transfer-lane server),
+ * pinning that the browser degrades to the unary lane it always used.
  */
 function makeStigmerServing(files: Record<string, Uint8Array>) {
   const getArtifact = vi.fn().mockResolvedValue({ artifact: zipSync(files) });
-  return { skill: { getArtifact } } as unknown as Stigmer;
+  const getArtifactDownloadUrl = vi
+    .fn()
+    .mockRejectedValue(new StigmerError("unknown", "unimplemented", CODE_UNIMPLEMENTED));
+  return { skill: { getArtifact, getArtifactDownloadUrl } } as unknown as Stigmer;
 }
 
 function renderBrowser(stigmer: Stigmer) {

package/src/skill/__tests__/fetchAndUnpackArtifact.test.ts

@@ -0,0 +1,90 @@
+// Pins for the artifact fetch lane selection (stigmer#701): URL-first via
+// getArtifactDownloadUrl, with the two deliberate browser degrade arms —
+// Unimplemented mint (pre-lane server) and a failed URL fetch (the shape a
+// missing bucket CORS policy takes in a browser).
+import { describe, expect, it, vi } from "vitest";
+import { strToU8, zipSync } from "fflate";
+import { StigmerError, type Stigmer } from "@stigmer/sdk";
+import { fetchAndUnpackArtifact } from "../internal/fetchAndUnpackArtifact.js";
+
+const CODE_UNIMPLEMENTED = 12;
+const ZIP = zipSync({ "SKILL.md": strToU8("# hi") });
+
+function stigmerWith(overrides: {
+  mint?: ReturnType<typeof vi.fn>;
+  unary?: ReturnType<typeof vi.fn>;
+  fetch?: unknown;
+}): Stigmer {
+  return {
+    skill: {
+      getArtifactDownloadUrl: overrides.mint,
+      getArtifact: overrides.unary,
+    },
+    fetch: overrides.fetch,
+  } as unknown as Stigmer;
+}
+
+describe("fetchAndUnpackArtifact lane selection", () => {
+  it("fetches via the minted download URL, never the unary lane", async () => {
+    const mint = vi.fn().mockResolvedValue({ url: "https://r2.example/skills/get" });
+    const unary = vi.fn();
+    const fetchImpl = vi.fn(async () => new Response(new Uint8Array(ZIP).buffer, { status: 200 }));
+
+    const result = await fetchAndUnpackArtifact(
+      stigmerWith({ mint, unary, fetch: fetchImpl }),
+      "skills/org/skill/hash.zip",
+    );
+
+    expect(fetchImpl).toHaveBeenCalledWith("https://r2.example/skills/get");
+    expect(unary).not.toHaveBeenCalled();
+    expect(result.contentMap.get("SKILL.md")).toBe("# hi");
+  });
+
+  it("degrades to the unary lane when the mint answers Unimplemented (pre-lane server)", async () => {
+    const mint = vi
+      .fn()
+      .mockRejectedValue(new StigmerError("unknown", "unimplemented", CODE_UNIMPLEMENTED));
+    const unary = vi.fn().mockResolvedValue({ artifact: ZIP });
+
+    const result = await fetchAndUnpackArtifact(
+      stigmerWith({ mint, unary }),
+      "skills/org/skill/hash.zip",
+    );
+
+    expect(unary).toHaveBeenCalledTimes(1);
+    expect(result.contentMap.get("SKILL.md")).toBe("# hi");
+  });
+
+  it("degrades to the unary lane when the URL fetch itself fails (browser CORS shape), warning once", async () => {
+    const mint = vi.fn().mockResolvedValue({ url: "https://r2.example/skills/get" });
+    const unary = vi.fn().mockResolvedValue({ artifact: ZIP });
+    const fetchImpl = vi.fn(async () => {
+      throw new TypeError("Failed to fetch");
+    });
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    try {
+      const result = await fetchAndUnpackArtifact(
+        stigmerWith({ mint, unary, fetch: fetchImpl }),
+        "skills/org/skill/hash.zip",
+      );
+      expect(unary).toHaveBeenCalledTimes(1);
+      expect(warn).toHaveBeenCalledTimes(1);
+      expect(result.contentMap.get("SKILL.md")).toBe("# hi");
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("propagates a non-Unimplemented mint failure — a real error must not be masked", async () => {
+    const mint = vi
+      .fn()
+      .mockRejectedValue(new StigmerError("not-found", "no such artifact", 5));
+    const unary = vi.fn();
+
+    await expect(
+      fetchAndUnpackArtifact(stigmerWith({ mint, unary }), "skills/org/skill/hash.zip"),
+    ).rejects.toThrow(/no such artifact/);
+    expect(unary).not.toHaveBeenCalled();
+  });
+});