diff --git a/.pr/prd-198/01-org-marketplace-legacy-default.png b/.pr/prd-198/01-org-marketplace-legacy-default.png
new file mode 100644
index 000000000..4602fd35b
Binary files /dev/null and b/.pr/prd-198/01-org-marketplace-legacy-default.png differ
diff --git a/.pr/prd-198/03-org-marketplace-prefer-organization-saved-reopened.png b/.pr/prd-198/03-org-marketplace-prefer-organization-saved-reopened.png
new file mode 100644
index 000000000..8cf90c0cc
Binary files /dev/null and b/.pr/prd-198/03-org-marketplace-prefer-organization-saved-reopened.png differ
diff --git a/.pr/prd-198/README.md b/.pr/prd-198/README.md
new file mode 100644
index 000000000..e94825d90
--- /dev/null
+++ b/.pr/prd-198/README.md
@@ -0,0 +1,26 @@
+# PRD-198 review evidence
+
+Temporary review artifacts. The `.pr/` directory is removed when the PR is approved.
+
+## Screenshots
+
+Both are 1280x860 captures of this branch's frontend in headless Chromium, driven by Playwright. All data is synthetic (`Example Org (synthetic)`, `github:example-org/approved-skills`). The repo's MSW mocks stood in for the backend, plus a small in-memory store for organization marketplaces and settings readback.
+
+- `01-org-marketplace-legacy-default.png`: an organization marketplace with no saved preference. The new selector shows **Use existing behavior**, which saves `null` and keeps today's merge order.
+- `03-org-marketplace-prefer-organization-saved-reopened.png`: the same marketplace after choosing **Use this marketplace's skill**, saving, refetching settings and reopening the editor. The saved `"marketplace"` value reappears.
+
+Assertions checked during the same run:
+- An unrelated edit on a legacy registration sends `public_skill_precedence: null`.
+- Choosing the marketplace option sends `"marketplace"`, and the settings readback and the reopened editor both return `"marketplace"`.
+
+## Matched-version probe
+
+`test_prd198_matched.py` runs Enterprise and the patched SDK/Agent Server in one process, with no network. It checks the effective `github` skill content under each preference with public skills on and off, and checks that the plugin catalog reports `disabled` when the catalog setting is off. 7 cases passed.
+
+To reproduce:
+1. Install the companion SDK change (`openhands-sdk` and `openhands-agent-server`, built from the SDK PR branch) into this repo's environment in place of the pinned 1.60.1.
+2. Copy `tests/public_extension_fixtures.py` from the SDK PR branch into this repo's `tests/` (the probe imports `tests.public_extension_fixtures`).
+3. Run `uv run --no-sync pytest .pr/prd-198/test_prd198_matched.py` so uv keeps the patched packages installed for the probe.
+4. Delete the copied fixture and restore the pinned versions with `uv sync --frozen`.
+
+Not covered here: live deployment, warm-claimed or resumed sandboxes, and automation-triggered conversations.
diff --git a/.pr/prd-198/test_prd198_matched.py b/.pr/prd-198/test_prd198_matched.py
new file mode 100644
index 000000000..f871f94be
--- /dev/null
+++ b/.pr/prd-198/test_prd198_matched.py
@@ -0,0 +1,163 @@
+"""Enterprise -> patched agent-server/SDK, same process, no network."""
+
+import httpx
+import pytest
+from fastapi.testclient import TestClient
+
+from openhands.agent_server.api import create_app
+from openhands.agent_server.config import Config
+from openhands.app_server.app_conversation import skill_loader
+from openhands.app_server.app_conversation.live_status_app_conversation_service import (
+    _to_sdk_marketplace_registrations,
+)
+from openhands.app_server.sandbox.sandbox_spec_service import get_agent_server_env
+from openhands.app_server.settings.settings_models import (
+    MarketplaceRegistration,
+    MarketplaceScope,
+)
+from openhands.sdk import LLM, Agent, AgentContext
+from openhands.sdk.conversation.impl.local_conversation import LocalConversation
+from openhands.sdk.skills.skill import _invalidate_public_skills_cache
+from tests.public_extension_fixtures import (
+    ORG_GITHUB,
+    PLUGIN_GITHUB,
+    PUBLIC_GITHUB,
+    make_plugin_marketplace,
+    make_public_repo,
+    make_standalone_marketplace,
+)
+
+
+@pytest.fixture
+def env(tmp_path, monkeypatch):
+    monkeypatch.setenv('EXTENSIONS_PATH', str(make_public_repo(tmp_path / 'pub')))
+    for k in ('OH_PUBLIC_SKILLS_ENABLED', 'OH_PUBLIC_PLUGIN_CATALOG_ENABLED'):
+        monkeypatch.delenv(k, raising=False)
+    _invalidate_public_skills_cache()
+    yield
+    _invalidate_public_skills_cache()
+
+
+def _org(tmp_path, factory, precedence):
+    # Production sources are remote; local fixtures bypass the source validator.
+    return [
+        MarketplaceRegistration.model_construct(
+            name='acme',
+            source=str(factory(tmp_path / 'org')),
+            ref=None,
+            repo_path=None,
+            auto_load=True,
+            public_skill_precedence=precedence,
+            scope=MarketplaceScope.ORG,
+        )
+    ]
+
+
+def _apply_sandbox_env(monkeypatch):
+    """What a cold, warm-claimed or resumed sandbox receives from Enterprise."""
+    for k, v in get_agent_server_env().items():
+        if k.startswith('OH_PUBLIC_'):
+            monkeypatch.setenv(k, v)
+
+
+async def _discover(monkeypatch, registrations, load_public):
+    client = TestClient(create_app(Config(session_api_keys=[])))
+
+    class _Async:
+        def __init__(self, *a, **k):
+            pass
+
+        async def __aenter__(self):
+            return self
+
+        async def __aexit__(self, *a):
+            return False
+
+        async def post(self, url, json, headers=None, timeout=None):
+            r = client.post('/api/skills', json=json)
+            return httpx.Response(
+                r.status_code, json=r.json(), request=httpx.Request('POST', url)
+            )
+
+    monkeypatch.setattr(skill_loader.httpx, 'AsyncClient', _Async)
+    skills = await skill_loader.load_skills_from_agent_server(
+        agent_server_url='http://sandbox',
+        session_api_key=None,
+        project_dir='/nonexistent',
+        load_public=load_public,
+        load_user=False,
+        load_project=False,
+        load_org=False,
+        registered_marketplaces=registrations,
+        load_registered_marketplaces=True,
+    )
+    return skills
+
+
+def _by_name(skills):
+    return {s.name: s.content.strip() for s in skills}
+
+
+def _runtime(tmp_path, registrations, skills):
+    agent = Agent(
+        llm=LLM(model='test/m', api_key='k'),
+        tools=[],
+        agent_context=AgentContext(
+            skills=skills,
+            registered_marketplaces=_to_sdk_marketplace_registrations(registrations),
+        ),
+    )
+    ws = tmp_path / 'ws'
+    ws.mkdir(exist_ok=True)
+    conv = LocalConversation(agent=agent, workspace=ws, visualizer=None)
+    conv._ensure_plugins_loaded()
+    ctx = conv.agent.agent_context
+    conv.close()
+    return _by_name(ctx.skills)
+
+
+@pytest.mark.usefixtures('env')
+@pytest.mark.parametrize(
+    ('public_on', 'factory', 'precedence', 'expected'),
+    [
+        (True, make_standalone_marketplace, None, PUBLIC_GITHUB),
+        (True, make_standalone_marketplace, 'marketplace', ORG_GITHUB),
+        (True, make_plugin_marketplace, 'public', PUBLIC_GITHUB),
+        (True, make_plugin_marketplace, 'marketplace', PLUGIN_GITHUB),
+        (False, make_standalone_marketplace, None, ORG_GITHUB),
+        (False, make_plugin_marketplace, 'public', PLUGIN_GITHUB),
+    ],
+)
+async def test_discovery_then_runtime(
+    tmp_path, monkeypatch, public_on, factory, precedence, expected
+):
+    monkeypatch.setenv('OH_PUBLIC_SKILLS_ENABLED', str(public_on).lower())
+    _apply_sandbox_env(monkeypatch)
+    regs = _org(tmp_path, factory, precedence)
+    from openhands.app_server.utils.public_extension_policy import public_skills_enabled
+
+    returned = await _discover(monkeypatch, regs, public_skills_enabled())
+    discovered = _by_name(returned)
+    assert discovered['github'] == expected
+    github = next(s for s in returned if s.name == 'github')
+    assert github.source  # provenance survives the launch handoff
+    assert ('public-only' in discovered) is public_on
+
+    # Enterprise hands the returned Skill objects (with source) to the
+    # conversation as explicit skills; the runtime then activates marketplaces.
+    effective = _runtime(tmp_path, regs, returned)
+    assert effective['github'] == expected
+    assert ('public-only' in effective) is public_on
+    if not public_on:
+        assert PUBLIC_GITHUB not in ''.join(effective.values())
+
+
+@pytest.mark.usefixtures('env')
+def test_catalog_off_on_sandbox(monkeypatch):
+    monkeypatch.setenv('OH_PUBLIC_PLUGIN_CATALOG_ENABLED', '0')
+    _apply_sandbox_env(monkeypatch)
+    client = TestClient(create_app(Config(session_api_keys=[])))
+    assert client.get('/api/plugins/marketplace').json() == {
+        'plugins': [],
+        'disabled': True,
+    }
diff --git a/frontend/__tests__/components/features/settings/marketplace-modal.test.tsx b/frontend/__tests__/components/features/settings/marketplace-modal.test.tsx
index e58d03769..14508a84c 100644
--- a/frontend/__tests__/components/features/settings/marketplace-modal.test.tsx
+++ b/frontend/__tests__/components/features/settings/marketplace-modal.test.tsx
@@ -546,13 +546,17 @@ describe("MarketplaceModal", () => {
   });
 
   it("renders scope selector when scope selection is allowed (add mode)", () => {
-    renderWithProviders(<MarketplaceModal {...baseProps} allowScopeSelection />);
+    renderWithProviders(
+      <MarketplaceModal {...baseProps} allowScopeSelection />,
+    );
 
     expect(screen.getByTestId("marketplace-scope-select")).toBeInTheDocument();
   });
 
   it("includes the chosen scope in onSave when scope selection is allowed", async () => {
-    renderWithProviders(<MarketplaceModal {...baseProps} allowScopeSelection />);
+    renderWithProviders(
+      <MarketplaceModal {...baseProps} allowScopeSelection />,
+    );
     const user = userEvent.setup();
 
     await user.type(screen.getByPlaceholderText("e.g., my-skills"), "team");
@@ -610,4 +614,73 @@ describe("MarketplaceModal", () => {
       screen.getByText("SETTINGS$MARKETPLACE_SOURCE_READONLY"),
     ).toBeInTheDocument();
   });
+
+  describe("public skill precedence (org marketplaces)", () => {
+    const orgMarketplace = {
+      name: "acme",
+      source: "github:acme/skills",
+      scope: "org" as const,
+      auto_load: true,
+    };
+
+    const renderEdit = (precedence?: "public" | "marketplace" | null) =>
+      renderWithProviders(
+        <MarketplaceModal
+          {...baseProps}
+          mode="edit"
+          marketplace={{
+            ...orgMarketplace,
+            public_skill_precedence: precedence,
+          }}
+        />,
+      );
+
+    it("keeps an unset preference as legacy (null) on an unrelated edit", async () => {
+      renderEdit(undefined);
+      const user = userEvent.setup();
+
+      const select = screen.getByLabelText(
+        "SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_LABEL",
+      );
+      expect(select).toHaveValue("legacy");
+
+      await user.click(screen.getByTestId("marketplace-save-button"));
+      await waitFor(() => expect(onSave).toHaveBeenCalled());
+      expect(onSave.mock.calls[0][0].public_skill_precedence).toBeNull();
+    });
+
+    it("saves an explicit choice and can return to legacy", async () => {
+      renderEdit("public");
+      const user = userEvent.setup();
+      const select = screen.getByLabelText(
+        "SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_LABEL",
+      );
+      expect(select).toHaveValue("public");
+
+      await user.selectOptions(select, "marketplace");
+      await user.click(screen.getByTestId("marketplace-save-button"));
+      await waitFor(() => expect(onSave).toHaveBeenCalledTimes(1));
+      expect(onSave.mock.calls[0][0].public_skill_precedence).toBe(
+        "marketplace",
+      );
+
+      await user.selectOptions(select, "legacy");
+      await user.click(screen.getByTestId("marketplace-save-button"));
+      await waitFor(() => expect(onSave).toHaveBeenCalledTimes(2));
+      expect(onSave.mock.calls[1][0].public_skill_precedence).toBeNull();
+    });
+
+    it("is not offered for personal marketplaces", () => {
+      renderWithProviders(
+        <MarketplaceModal
+          {...baseProps}
+          mode="edit"
+          marketplace={{ ...orgMarketplace, scope: "personal" }}
+        />,
+      );
+      expect(
+        screen.queryByTestId("marketplace-precedence-select"),
+      ).not.toBeInTheDocument();
+    });
+  });
 });
diff --git a/frontend/__tests__/routes/skills-settings.test.tsx b/frontend/__tests__/routes/skills-settings.test.tsx
index 7f03308ed..747760e94 100644
--- a/frontend/__tests__/routes/skills-settings.test.tsx
+++ b/frontend/__tests__/routes/skills-settings.test.tsx
@@ -15,7 +15,7 @@ import SkillsService from "#/api/skills-service";
 import OptionService from "#/api/option-service/option-service.api";
 import * as orgStore from "#/stores/selected-organization-store";
 import { organizationService } from "#/api/organization-service/organization-service.api";
-import { MOCK_PERSONAL_ORG, MOCK_TEAM_ORG_ACME } from "#/mocks/org-handlers";
+import { MOCK_TEAM_ORG_ACME } from "#/mocks/org-handlers";
 import { MOCK_DEFAULT_USER_SETTINGS } from "#/mocks/handlers";
 import type { WebClientConfig } from "#/api/option-service/option.types";
 
@@ -469,3 +469,62 @@ describe("skill descriptions", () => {
     expect(screen.queryByText("Code review helpers")).not.toBeInTheDocument();
   });
 });
+
+describe("org marketplace public skill precedence", () => {
+  it("passes the saved preference into the edit modal", async () => {
+    vi.spyOn(OptionService, "getConfig").mockResolvedValue({
+      ...mockConfig,
+      app_mode: "saas",
+    });
+    orgStore.useSelectedOrganizationStore.setState({
+      organizationId: MOCK_TEAM_ORG_ACME.id,
+    });
+    vi.spyOn(organizationService, "getMe").mockResolvedValue({
+      org_id: MOCK_TEAM_ORG_ACME.id,
+      user_id: "user-1",
+      email: "test@example.com",
+      role: "admin",
+      llm_api_key: "",
+      max_iterations: 100,
+      llm_model: "gpt-4",
+      llm_base_url: "",
+      status: "active",
+      permissions: ["edit_org_settings"],
+    });
+    vi.spyOn(organizationService, "getOrganizations").mockResolvedValue({
+      items: [MOCK_TEAM_ORG_ACME],
+      currentOrgId: MOCK_TEAM_ORG_ACME.id,
+    });
+    vi.spyOn(SettingsService, "getSettings").mockResolvedValue({
+      ...MOCK_DEFAULT_USER_SETTINGS,
+      registered_marketplaces: [],
+      inherited_marketplaces: [
+        {
+          name: "example-org-skills",
+          source: "github:example-org/approved-skills",
+          scope: "org",
+          public_skill_precedence: "marketplace",
+        },
+      ],
+    });
+    vi.spyOn(SkillsService, "getSkills").mockResolvedValue([]);
+    vi.spyOn(SkillsService, "getMarketplaceSkills").mockResolvedValue({
+      skills: [],
+      plugins: [],
+      marketplace_skills: {},
+      errors: [],
+    });
+
+    renderSkillsSettings();
+    const user = userEvent.setup();
+    const editButton = await screen.findByRole("button", {
+      name: "BUTTON$EDIT example-org-skills",
+    });
+    await waitFor(() => expect(editButton).toBeEnabled());
+    await user.click(editButton);
+
+    expect(
+      await screen.findByTestId("marketplace-precedence-select"),
+    ).toHaveValue("marketplace");
+  });
+});
diff --git a/frontend/src/components/features/settings/marketplace-modal.tsx b/frontend/src/components/features/settings/marketplace-modal.tsx
index 93ff66200..6f30a118c 100644
--- a/frontend/src/components/features/settings/marketplace-modal.tsx
+++ b/frontend/src/components/features/settings/marketplace-modal.tsx
@@ -57,6 +57,12 @@ export function deriveMarketplaceName(source: string): string {
     .replace(/-+$/g, "");
 }
 
+type PrecedenceChoice = "legacy" | "public" | "marketplace";
+
+const toPrecedenceChoice = (
+  value: "public" | "marketplace" | null | undefined,
+): PrecedenceChoice => value ?? "legacy";
+
 interface MarketplaceModalProps {
   isOpen: boolean;
   mode: "add" | "edit";
@@ -73,6 +79,7 @@ interface MarketplaceModalProps {
     ref?: string;
     repo_path?: string;
     auto_load?: boolean;
+    public_skill_precedence?: "public" | "marketplace" | null;
     scope?: "org" | "personal";
   }) => void;
   isSaving?: boolean;
@@ -94,6 +101,9 @@ export function MarketplaceModal({
   const [repoPath, setRepoPath] = React.useState(marketplace?.repo_path || "");
   const [autoLoad, setAutoLoad] = React.useState(!!marketplace?.auto_load);
   const [scope, setScope] = React.useState<"org" | "personal">("personal");
+  const [precedence, setPrecedence] = React.useState<PrecedenceChoice>(
+    toPrecedenceChoice(marketplace?.public_skill_precedence),
+  );
   // Tracks whether the user has hand-edited Name, so auto-derivation from the
   // repository stops clobbering an intentional name.
   const [nameEdited, setNameEdited] = React.useState(false);
@@ -122,6 +132,7 @@ export function MarketplaceModal({
       setAutoLoad(!!marketplace?.auto_load);
       // Default new marketplaces to personal; admins can opt into org.
       setScope(marketplace?.scope === "org" ? "org" : "personal");
+      setPrecedence(toPrecedenceChoice(marketplace?.public_skill_precedence));
       // An existing (edit) name counts as user-owned; a fresh add starts clean.
       setNameEdited(Boolean(marketplace?.name));
       setNameError(null);
@@ -133,6 +144,9 @@ export function MarketplaceModal({
 
   // Scope selection only applies when adding and the caller allows it.
   const showScopeSelector = mode === "add" && allowScopeSelection;
+  const isOrgScoped = showScopeSelector
+    ? scope === "org"
+    : marketplace?.scope === "org";
 
   const handleSave = () => {
     // Validate name on click
@@ -172,6 +186,12 @@ export function MarketplaceModal({
       ref: ref.trim() || undefined,
       repo_path: trimmedRepoPath || undefined,
       auto_load: autoLoad,
+      // "legacy" saves null so an unrelated edit keeps the existing winner.
+      public_skill_precedence: isOrgScoped
+        ? precedence === "legacy"
+          ? null
+          : precedence
+        : undefined,
       scope: showScopeSelector ? scope : undefined,
     };
     if (pluginWithoutMarketplace) {
@@ -396,6 +416,36 @@ export function MarketplaceModal({
           </div>
         )}
 
+        {isOrgScoped && (
+          <div className="flex flex-col gap-2">
+            <label
+              htmlFor="marketplace-precedence-select"
+              className="text-sm font-medium text-tertiary-alt"
+            >
+              {t(I18nKey.SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_LABEL)}
+            </label>
+            <select
+              id="marketplace-precedence-select"
+              data-testid="marketplace-precedence-select"
+              value={precedence}
+              onChange={(e) =>
+                setPrecedence(e.target.value as PrecedenceChoice)
+              }
+              className={formControlNativeSelectClassName}
+            >
+              <option value="legacy">
+                {t(I18nKey.SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_LEGACY)}
+              </option>
+              <option value="public">
+                {t(I18nKey.SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_PUBLIC)}
+              </option>
+              <option value="marketplace">
+                {t(I18nKey.SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_MARKETPLACE)}
+              </option>
+            </select>
+          </div>
+        )}
+
         {/* Ref field (optional) */}
         <div className="flex flex-col gap-2">
           <label className="text-sm font-medium text-tertiary-alt">
diff --git a/frontend/src/i18n/declaration.ts b/frontend/src/i18n/declaration.ts
index 253f59d53..2f3a045e2 100644
--- a/frontend/src/i18n/declaration.ts
+++ b/frontend/src/i18n/declaration.ts
@@ -1844,6 +1844,10 @@ export enum I18nKey {
   SETTINGS$MARKETPLACE_SCOPE_INSTANCE = "SETTINGS$MARKETPLACE_SCOPE_INSTANCE",
   SETTINGS$MARKETPLACE_SCOPE_PERSONAL = "SETTINGS$MARKETPLACE_SCOPE_PERSONAL",
   SETTINGS$MARKETPLACE_SCOPE_ORG = "SETTINGS$MARKETPLACE_SCOPE_ORG",
+  SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_LABEL = "SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_LABEL",
+  SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_LEGACY = "SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_LEGACY",
+  SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_PUBLIC = "SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_PUBLIC",
+  SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_MARKETPLACE = "SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_MARKETPLACE",
   SETTINGS$MARKETPLACE_SCOPE_LABEL = "SETTINGS$MARKETPLACE_SCOPE_LABEL",
   SETTINGS$MARKETPLACE_ADD_TITLE = "SETTINGS$MARKETPLACE_ADD_TITLE",
   SETTINGS$MARKETPLACE_EDIT_TITLE = "SETTINGS$MARKETPLACE_EDIT_TITLE",
diff --git a/frontend/src/i18n/translation.json b/frontend/src/i18n/translation.json
index 655522c64..1cd5849c5 100644
--- a/frontend/src/i18n/translation.json
+++ b/frontend/src/i18n/translation.json
@@ -31347,6 +31347,74 @@
     "tr": "Kuruluş",
     "uk": "Організація"
   },
+  "SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_LABEL": {
+    "en": "When a skill name matches a public OpenHands skill",
+    "ja": "When a skill name matches a public OpenHands skill",
+    "zh-CN": "When a skill name matches a public OpenHands skill",
+    "zh-TW": "When a skill name matches a public OpenHands skill",
+    "ko-KR": "When a skill name matches a public OpenHands skill",
+    "no": "When a skill name matches a public OpenHands skill",
+    "ar": "When a skill name matches a public OpenHands skill",
+    "de": "When a skill name matches a public OpenHands skill",
+    "fr": "When a skill name matches a public OpenHands skill",
+    "it": "When a skill name matches a public OpenHands skill",
+    "pt": "When a skill name matches a public OpenHands skill",
+    "es": "When a skill name matches a public OpenHands skill",
+    "ca": "When a skill name matches a public OpenHands skill",
+    "tr": "When a skill name matches a public OpenHands skill",
+    "uk": "When a skill name matches a public OpenHands skill"
+  },
+  "SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_LEGACY": {
+    "en": "Use existing behavior",
+    "ja": "Use existing behavior",
+    "zh-CN": "Use existing behavior",
+    "zh-TW": "Use existing behavior",
+    "ko-KR": "Use existing behavior",
+    "no": "Use existing behavior",
+    "ar": "Use existing behavior",
+    "de": "Use existing behavior",
+    "fr": "Use existing behavior",
+    "it": "Use existing behavior",
+    "pt": "Use existing behavior",
+    "es": "Use existing behavior",
+    "ca": "Use existing behavior",
+    "tr": "Use existing behavior",
+    "uk": "Use existing behavior"
+  },
+  "SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_PUBLIC": {
+    "en": "Use the public skill",
+    "ja": "Use the public skill",
+    "zh-CN": "Use the public skill",
+    "zh-TW": "Use the public skill",
+    "ko-KR": "Use the public skill",
+    "no": "Use the public skill",
+    "ar": "Use the public skill",
+    "de": "Use the public skill",
+    "fr": "Use the public skill",
+    "it": "Use the public skill",
+    "pt": "Use the public skill",
+    "es": "Use the public skill",
+    "ca": "Use the public skill",
+    "tr": "Use the public skill",
+    "uk": "Use the public skill"
+  },
+  "SETTINGS$MARKETPLACE_PUBLIC_PRECEDENCE_MARKETPLACE": {
+    "en": "Use this marketplace's skill",
+    "ja": "Use this marketplace's skill",
+    "zh-CN": "Use this marketplace's skill",
+    "zh-TW": "Use this marketplace's skill",
+    "ko-KR": "Use this marketplace's skill",
+    "no": "Use this marketplace's skill",
+    "ar": "Use this marketplace's skill",
+    "de": "Use this marketplace's skill",
+    "fr": "Use this marketplace's skill",
+    "it": "Use this marketplace's skill",
+    "pt": "Use this marketplace's skill",
+    "es": "Use this marketplace's skill",
+    "ca": "Use this marketplace's skill",
+    "tr": "Use this marketplace's skill",
+    "uk": "Use this marketplace's skill"
+  },
   "SETTINGS$MARKETPLACE_SCOPE_LABEL": {
     "en": "Scope",
     "ja": "スコープ",
diff --git a/frontend/src/routes/skills-settings.tsx b/frontend/src/routes/skills-settings.tsx
index 6969a5f1f..768ad1c8b 100644
--- a/frontend/src/routes/skills-settings.tsx
+++ b/frontend/src/routes/skills-settings.tsx
@@ -374,6 +374,7 @@ function SkillsSettingsScreen() {
       ref: mp.ref,
       repo_path: mp.repo_path,
       auto_load: mp.auto_load,
+      public_skill_precedence: mp.public_skill_precedence,
     });
 
     // Only persist a scope whose toggles actually changed, so a personal edit
@@ -444,6 +445,7 @@ function SkillsSettingsScreen() {
       ref?: string;
       repo_path?: string;
       auto_load?: boolean;
+      public_skill_precedence?: "public" | "marketplace" | null;
       scope?: "org" | "personal";
     }) => {
       // Edit keeps the item's existing scope; add uses the chosen scope
@@ -459,6 +461,8 @@ function SkillsSettingsScreen() {
         ref: data.ref,
         repo_path: data.repo_path,
         auto_load: data.auto_load,
+        public_skill_precedence:
+          targetScope === "org" ? data.public_skill_precedence : undefined,
         scope: targetScope,
       };
 
@@ -469,6 +473,7 @@ function SkillsSettingsScreen() {
         ref: mp.ref,
         repo_path: mp.repo_path,
         auto_load: mp.auto_load,
+        public_skill_precedence: mp.public_skill_precedence,
       });
 
       const scopeList = allMarketplaces.filter(
@@ -692,6 +697,8 @@ function SkillsSettingsScreen() {
                 ref: selectedMarketplace.ref,
                 repo_path: selectedMarketplace.repo_path,
                 auto_load: selectedMarketplace.auto_load,
+                public_skill_precedence:
+                  selectedMarketplace.public_skill_precedence,
                 scope: selectedMarketplace.scope,
               }
             : null
diff --git a/frontend/src/types/settings.ts b/frontend/src/types/settings.ts
index bacbb6419..71af12fe4 100644
--- a/frontend/src/types/settings.ts
+++ b/frontend/src/types/settings.ts
@@ -159,6 +159,9 @@ export type MarketplaceRegistration = {
   ref?: string;
   repo_path?: string;
   auto_load?: boolean;
+  // Org/instance only: which source wins a same-name conflict with a default
+  // public skill. Unset keeps the legacy merge order.
+  public_skill_precedence?: "public" | "marketplace" | null;
   // Backend-derived; present on reads, omitted from write payloads (the backend
   // sets scope per storage layer). Optional so save payloads need not include it.
   scope?: "instance" | "org" | "personal";
diff --git a/openhands/app_server/app_conversation/app_conversation_service_base.py b/openhands/app_server/app_conversation/app_conversation_service_base.py
index 7c8a30423..345180096 100644
--- a/openhands/app_server/app_conversation/app_conversation_service_base.py
+++ b/openhands/app_server/app_conversation/app_conversation_service_base.py
@@ -54,6 +54,7 @@
     configure_git_user_settings,
     ensure_valid_git_branch_name,
 )
+from openhands.app_server.utils.public_extension_policy import public_skills_enabled
 from openhands.sdk import Agent, LLMSummarizingCondenser
 from openhands.sdk.context import AgentContext
 from openhands.sdk.llm import LLM
@@ -404,13 +405,14 @@ async def load_and_merge_all_skills(
                 project_dir=project_dir,
                 org_configs=org_configs,
                 sandbox_config=sandbox_config,
-                load_public=True,
+                load_public=public_skills_enabled(),
                 load_user=True,
                 # Without a primary the project folder is the parent of the
                 # clones; their skills load per repository below instead.
                 load_project=bool(selected_repository) or not additional_repositories,
                 load_org=True,
                 registered_marketplaces=registered_marketplaces,
+                load_registered_marketplaces=True,
             )
 
             cloned = [
diff --git a/openhands/app_server/app_conversation/live_status_app_conversation_service.py b/openhands/app_server/app_conversation/live_status_app_conversation_service.py
index f80b4ee42..3e1365f40 100644
--- a/openhands/app_server/app_conversation/live_status_app_conversation_service.py
+++ b/openhands/app_server/app_conversation/live_status_app_conversation_service.py
@@ -524,13 +524,11 @@ def _to_sdk_marketplace_registrations(
 ) -> list[SDKMarketplaceRegistration]:
     if not registrations:
         return []
+    # model_validate keeps public_skill_precedence on SDKs that define it and
+    # drops it on older ones.
     return [
-        SDKMarketplaceRegistration(
-            name=registration.name,
-            source=registration.source,
-            ref=registration.ref,
-            repo_path=registration.repo_path,
-            auto_load=registration.auto_load,
+        SDKMarketplaceRegistration.model_validate(
+            registration.model_dump(exclude={'scope'}, exclude_none=True)
         )
         for registration in registrations
     ]
diff --git a/openhands/app_server/app_conversation/skill_loader.py b/openhands/app_server/app_conversation/skill_loader.py
index 7551952db..6b6572b17 100644
--- a/openhands/app_server/app_conversation/skill_loader.py
+++ b/openhands/app_server/app_conversation/skill_loader.py
@@ -792,6 +792,7 @@ async def load_skills_from_agent_server(
     load_project: bool = True,
     load_org: bool = True,
     registered_marketplaces: list[MarketplaceRegistration] | None = None,
+    load_registered_marketplaces: bool | None = None,
 ) -> list[Skill]:
     """Load all skills from the agent-server.
 
@@ -830,6 +831,8 @@ async def load_skills_from_agent_server(
             'org_config': org_configs[0].model_dump() if org_configs else None,
             'sandbox_config': sandbox_config.model_dump() if sandbox_config else None,
         }
+        if load_registered_marketplaces is not None:
+            payload['load_registered_marketplaces'] = load_registered_marketplaces
 
         # Only include ``registered_marketplaces`` when we actually have a value.
         # The agent-server field is a non-Optional ``list`` with a default, so an
diff --git a/openhands/app_server/sandbox/sandbox_spec_service.py b/openhands/app_server/sandbox/sandbox_spec_service.py
index f8f3f21d8..92c0744aa 100644
--- a/openhands/app_server/sandbox/sandbox_spec_service.py
+++ b/openhands/app_server/sandbox/sandbox_spec_service.py
@@ -12,6 +12,9 @@
     SandboxSpecInfoPage,
 )
 from openhands.app_server.services.injector import Injector
+from openhands.app_server.utils.public_extension_policy import (
+    public_extension_policy_env,
+)
 from openhands.sdk.utils.models import DiscriminatedUnionMixin
 
 _DEFAULT_REPOSITORY = 'ghcr.io/openhands/agent-server'
@@ -236,4 +239,8 @@ def get_agent_server_env() -> dict[str, str]:
     explicit_env = env_parser.from_env(dict[str, str], 'OH_AGENT_SERVER_ENV')
     result.update(explicit_env)
 
+    # Step 3: Apply the instance policy after explicit environment overrides.
+    # It takes effect when this environment is delivered to the agent server.
+    result.update(public_extension_policy_env())
+
     return result
diff --git a/openhands/app_server/settings/marketplace_composition.py b/openhands/app_server/settings/marketplace_composition.py
index 2cd59e628..543468942 100644
--- a/openhands/app_server/settings/marketplace_composition.py
+++ b/openhands/app_server/settings/marketplace_composition.py
@@ -247,7 +247,10 @@ def _stamp(
                 "User marketplace '%s' shadows an inherited one; ignoring", reg.name
             )
             continue
-        personal[reg.name] = _stamp(reg, MarketplaceScope.PERSONAL)
+        # Only administrators may let a marketplace replace public skills.
+        personal[reg.name] = _stamp(reg, MarketplaceScope.PERSONAL).model_copy(
+            update={'public_skill_precedence': None}
+        )
 
     return ComposedMarketplaces(
         inherited=list(inherited.values()),
diff --git a/openhands/app_server/settings/settings_models.py b/openhands/app_server/settings/settings_models.py
index dda387872..583edd61d 100644
--- a/openhands/app_server/settings/settings_models.py
+++ b/openhands/app_server/settings/settings_models.py
@@ -98,7 +98,8 @@ class MarketplaceRegistration(BaseModel):
     Wire-compatible with ``openhands.sdk.marketplace.MarketplaceRegistration``
     (the model the agent-server ``/api/skills`` endpoint consumes): dumping this
     model with ``exclude={'scope'}`` yields exactly the SDK model's fields
-    (``name``/``source``/``ref``/``repo_path``/``auto_load``), and our ``bool``
+    (``name``/``source``/``ref``/``repo_path``/``auto_load``/
+    ``public_skill_precedence``), and our ``bool``
     ``auto_load`` and stricter field validators are a subset of what the SDK
     accepts, so any value we produce validates upstream.
 
@@ -155,6 +156,14 @@ class MarketplaceRegistration(BaseModel):
             'False = registered for resolution but not auto-loaded.'
         ),
     )
+    public_skill_precedence: Literal['public', 'marketplace'] | None = Field(
+        default=None,
+        description=(
+            "Which source wins when one of this marketplace's skills has the same "
+            'name as a default public skill. None keeps the legacy behavior. '
+            'Honored for instance and org registrations only.'
+        ),
+    )
     scope: 'MarketplaceScope | None' = Field(
         default=None,
         description=(
diff --git a/openhands/app_server/user/skills_router.py b/openhands/app_server/user/skills_router.py
index 7e1c6121f..3a11f62cd 100644
--- a/openhands/app_server/user/skills_router.py
+++ b/openhands/app_server/user/skills_router.py
@@ -38,6 +38,7 @@
 from openhands.app_server.user.user_context import UserContext
 from openhands.app_server.utils.dependencies import get_dependencies
 from openhands.app_server.utils.logger import openhands_logger as logger
+from openhands.app_server.utils.public_extension_policy import public_skills_enabled
 from openhands.sdk.marketplace import Marketplace
 from openhands.sdk.plugin.format.claude_code import (
     PLUGIN_MANIFEST_DIRS,
@@ -245,6 +246,8 @@ async def _load_global_skills() -> list[SkillInfo]:
     not re-read the clone. Returns no skills, rather than failing, when the
     repository can't be reached and no clone is cached.
     """
+    if not public_skills_enabled():
+        return []
     try:
         skills = await asyncio.to_thread(load_public_skills)
     except Exception as e:
diff --git a/openhands/app_server/utils/public_extension_policy.py b/openhands/app_server/utils/public_extension_policy.py
new file mode 100644
index 000000000..60cd9eacc
--- /dev/null
+++ b/openhands/app_server/utils/public_extension_policy.py
@@ -0,0 +1,30 @@
+"""Instance policy for the default OpenHands public extensions repository."""
+
+import os
+
+# Instance policy for the default public extensions repository. The names match
+# the agent-server's so one value governs discovery here and is forwarded to
+# every sandbox. Unset or empty means enabled.
+PUBLIC_SKILLS_ENABLED_ENV = 'OH_PUBLIC_SKILLS_ENABLED'
+PUBLIC_PLUGIN_CATALOG_ENABLED_ENV = 'OH_PUBLIC_PLUGIN_CATALOG_ENABLED'
+
+
+def _env_flag_enabled(name: str) -> bool:
+    raw = os.environ.get(name, '').strip().lower()
+    return not raw or raw in ('1', 'true', 'yes', 'on')
+
+
+def public_skills_enabled() -> bool:
+    return _env_flag_enabled(PUBLIC_SKILLS_ENABLED_ENV)
+
+
+def public_plugin_catalog_enabled() -> bool:
+    return _env_flag_enabled(PUBLIC_PLUGIN_CATALOG_ENABLED_ENV)
+
+
+def public_extension_policy_env() -> dict[str, str]:
+    """The normalized policy to forward to agent-server sandboxes."""
+    return {
+        PUBLIC_SKILLS_ENABLED_ENV: str(public_skills_enabled()).lower(),
+        PUBLIC_PLUGIN_CATALOG_ENABLED_ENV: str(public_plugin_catalog_enabled()).lower(),
+    }
diff --git a/tests/unit/app_server/test_marketplace_composition.py b/tests/unit/app_server/test_marketplace_composition.py
index efd4df386..3f899801c 100644
--- a/tests/unit/app_server/test_marketplace_composition.py
+++ b/tests/unit/app_server/test_marketplace_composition.py
@@ -52,6 +52,7 @@ def test_hash_format_parses_all_fields_and_auto_loads(self, monkeypatch):
                 'ref': 'main',
                 'repo_path': 'marketplaces/internal',
                 'auto_load': True,
+                'public_skill_precedence': None,
                 'scope': None,
             }
         ]
diff --git a/tests/unit/app_server/test_public_extension_policy.py b/tests/unit/app_server/test_public_extension_policy.py
new file mode 100644
index 000000000..3d0d4a3f6
--- /dev/null
+++ b/tests/unit/app_server/test_public_extension_policy.py
@@ -0,0 +1,107 @@
+"""PRD-198: instance public-extensions policy and org conflict preference."""
+
+import pytest
+
+from openhands.app_server.app_conversation.live_status_app_conversation_service import (
+    _to_sdk_marketplace_registrations,
+)
+from openhands.app_server.sandbox.sandbox_spec_service import get_agent_server_env
+from openhands.app_server.settings.marketplace_composition import compose_marketplaces
+from openhands.app_server.settings.settings_models import MarketplaceRegistration
+from openhands.app_server.user import skills_router
+from openhands.app_server.utils.public_extension_policy import (
+    PUBLIC_PLUGIN_CATALOG_ENABLED_ENV,
+    PUBLIC_SKILLS_ENABLED_ENV,
+    public_extension_policy_env,
+)
+
+
+@pytest.fixture(autouse=True)
+def _clean_env(monkeypatch):
+    for env in (PUBLIC_SKILLS_ENABLED_ENV, PUBLIC_PLUGIN_CATALOG_ENABLED_ENV):
+        monkeypatch.delenv(env, raising=False)
+    monkeypatch.delenv('OH_AGENT_SERVER_ENV', raising=False)
+
+
+def test_defaults_are_enabled():
+    assert public_extension_policy_env() == {
+        PUBLIC_SKILLS_ENABLED_ENV: 'true',
+        PUBLIC_PLUGIN_CATALOG_ENABLED_ENV: 'true',
+    }
+
+
+@pytest.mark.parametrize('value', ['false', '0', 'off'])
+def test_controls_are_independent(monkeypatch, value):
+    monkeypatch.setenv(PUBLIC_SKILLS_ENABLED_ENV, value)
+    assert public_extension_policy_env() == {
+        PUBLIC_SKILLS_ENABLED_ENV: 'false',
+        PUBLIC_PLUGIN_CATALOG_ENABLED_ENV: 'true',
+    }
+
+
+@pytest.mark.parametrize('value', ['1', 'true'])
+def test_truthy_values(monkeypatch, value):
+    monkeypatch.setenv(PUBLIC_PLUGIN_CATALOG_ENABLED_ENV, value)
+    assert public_extension_policy_env()[PUBLIC_PLUGIN_CATALOG_ENABLED_ENV] == 'true'
+
+
+def test_sandbox_env_carries_policy_and_overrides_cannot_reenable(monkeypatch):
+    monkeypatch.setenv(PUBLIC_SKILLS_ENABLED_ENV, 'false')
+    monkeypatch.setenv(PUBLIC_PLUGIN_CATALOG_ENABLED_ENV, 'false')
+    monkeypatch.setenv(
+        'OH_AGENT_SERVER_ENV',
+        f'{{"{PUBLIC_SKILLS_ENABLED_ENV}": "true", "OTHER": "x"}}',
+    )
+    env = get_agent_server_env()
+    assert env[PUBLIC_SKILLS_ENABLED_ENV] == 'false'
+    assert env[PUBLIC_PLUGIN_CATALOG_ENABLED_ENV] == 'false'
+    assert env['OTHER'] == 'x'
+
+
+def test_precedence_kept_for_org_and_stripped_for_personal():
+    composed = compose_marketplaces(
+        instance_marketplaces=[],
+        org_marketplaces=[
+            {
+                'name': 'org',
+                'source': 'github:acme/org',
+                'auto_load': True,
+                'public_skill_precedence': 'marketplace',
+            }
+        ],
+        user_marketplaces=[
+            {
+                'name': 'mine',
+                'source': 'github:me/mine',
+                'public_skill_precedence': 'marketplace',
+            }
+        ],
+    )
+    assert composed.inherited[0].public_skill_precedence == 'marketplace'
+    assert composed.personal[0].public_skill_precedence is None
+
+
+def test_precedence_reaches_sdk_registration():
+    registration = MarketplaceRegistration(
+        name='org',
+        source='github:acme/org',
+        auto_load=True,
+        public_skill_precedence='marketplace',
+    )
+    (sdk,) = _to_sdk_marketplace_registrations([registration])
+    assert sdk.name == 'org' and sdk.auto_load is True
+    assert getattr(sdk, 'public_skill_precedence', 'marketplace') == 'marketplace'
+
+
+async def test_global_skill_listing_respects_policy(monkeypatch):
+    called = False
+
+    def _load():
+        nonlocal called
+        called = True
+        return []
+
+    monkeypatch.setattr(skills_router, 'load_public_skills', _load)
+    monkeypatch.setenv(PUBLIC_SKILLS_ENABLED_ENV, 'false')
+    assert await skills_router._load_global_skills() == []
+    assert called is False