From beeb6472a2d8e5393037b8544d27abe8d1aedd11 Mon Sep 17 00:00:00 2001
From: Lan_zhijiang <lanzhijiang@foxmail.com>
Date: Mon, 17 Aug 2026 14:47:59 +0800
Subject: [PATCH 1/9] feat(extension): add Twitter setup wizard

- add extension-owned multi-step setup popup
- restore peer registration and settings lifecycle
- support per-peer extension control and registry overrides
---
 .../extension/extensionCard/extensionCard.md  |   7 +-
 .../extensionCard/extensionCard.spec.ts       | 113 +++++
 .../extension/extensionCard/extensionCard.ts  |   6 +-
 .../extension/extensionCard/extensionCard.vue |  45 +-
 apps/client-web/src/core.ts                   |  75 ++-
 .../src/extension-peer-control.spec.ts        | 106 +++++
 apps/client-web/src/extension-peer-control.ts |  64 +++
 apps/client-web/src/locales/messages/en.json  |  12 +
 .../src/locales/messages/zh-CN.json           |  12 +
 apps/client-web/src/main.ts                   |  15 +-
 apps/client-web/src/twitter-setup-api.spec.ts | 130 ++++++
 .../src/twitter-setup-wizard.spec.ts          |  91 ++++
 .../src/views/extensions/extensions.scss      |  11 +
 .../src/views/extensions/extensions.spec.ts   | 122 +++++
 .../src/views/extensions/extensions.vue       | 114 ++++-
 .../src/views/settings/settings.scss          |   7 +-
 .../src/views/settings/settings.spec.ts       | 140 ++++++
 .../src/views/settings/settings.vue           |  99 +++-
 .../twitterSetupWizard/twitterSetupWizard.md  |  10 +
 .../twitterSetupWizard.scss                   | 124 +++++
 .../twitterSetupWizard/twitterSetupWizard.ts  |  10 +
 .../twitterSetupWizard/twitterSetupWizard.vue | 428 ++++++++++++++++++
 extensions/twitter/src/index.ts               |   5 +
 extensions/twitter/src/setup-api.ts           | 207 +++++++++
 packages/core/package.json                    |   2 +-
 packages/core/src/base/db-api.ts              |   6 +-
 packages/core/src/config/schema.ts            |  34 +-
 packages/core/src/config/store.test.ts        |  82 ++++
 packages/core/src/config/store.ts             |  39 +-
 packages/core/src/extension/host.ts           |  14 +-
 packages/core/src/extension/index.ts          |   8 +
 packages/core/src/extension/model.ts          |   7 +
 .../core/src/extension/postgrest-state.ts     |  36 +-
 .../src/extension/registry-origin.test.ts     |  71 +++
 .../core/src/extension/registry-origin.ts     |  66 +++
 packages/core/src/extension/registry.ts       |  27 +-
 packages/core/src/index.ts                    |   4 +
 packages/core/src/peer/index.ts               |   1 +
 packages/core/src/peer/runtime.test.ts        | 104 +++++
 packages/core/src/peer/runtime.ts             | 107 +++++
 scripts/check-local-runtime-contract.mjs      |   2 +
 41 files changed, 2474 insertions(+), 89 deletions(-)
 create mode 100644 apps/client-web/src/components/extension/extensionCard/extensionCard.spec.ts
 create mode 100644 apps/client-web/src/extension-peer-control.spec.ts
 create mode 100644 apps/client-web/src/extension-peer-control.ts
 create mode 100644 apps/client-web/src/twitter-setup-api.spec.ts
 create mode 100644 apps/client-web/src/twitter-setup-wizard.spec.ts
 create mode 100644 apps/client-web/src/views/extensions/extensions.spec.ts
 create mode 100644 apps/client-web/src/views/settings/settings.spec.ts
 create mode 100644 extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.md
 create mode 100644 extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.scss
 create mode 100644 extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.ts
 create mode 100644 extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.vue
 create mode 100644 extensions/twitter/src/setup-api.ts
 create mode 100644 packages/core/src/config/store.test.ts
 create mode 100644 packages/core/src/extension/registry-origin.test.ts
 create mode 100644 packages/core/src/extension/registry-origin.ts
 create mode 100644 packages/core/src/peer/runtime.test.ts
 create mode 100644 packages/core/src/peer/runtime.ts

diff --git a/apps/client-web/src/components/extension/extensionCard/extensionCard.md b/apps/client-web/src/components/extension/extensionCard/extensionCard.md
index 2911d00..ec13f24 100644
--- a/apps/client-web/src/components/extension/extensionCard/extensionCard.md
+++ b/apps/client-web/src/components/extension/extensionCard/extensionCard.md
@@ -5,11 +5,12 @@ A component that displays extension information and provides controls for toggli
 ## Props
 
 - `extension` (InstalledExtension, required): the canonical installed row
-- `enabled` (boolean, required): whether the current Web Peer UUID is in `enabled[]`
+- `enabled` (boolean, required): whether the selected Client's Peer UUID is in `enabled[]`
+- `controlsCurrentWebRuntime` (boolean, required): whether the switch owns this browser's runtime
+- `setEnabled` (function, required): application-level selected-Client control operation
 
 ## Emits
 
-- `changed`: Emitted after current-Peer enablement changes and the list should be refreshed
 - `updated`: Emitted with the canonical row after configuration or version changes
 - `uninstalled`: Emitted after the canonical row is removed
 
@@ -17,6 +18,8 @@ A component that displays extension information and provides controls for toggli
 
 - Display canonical Extension Name, exact version, and optional nickname
 - Toggle enable/disable status with a switch
+- Mount an Extension-owned setup contribution from this browser's running Web Distribution
+- Keep setup availability independent of which Client is selected for enablement control
 - Edit extension configuration via JSON editor in a dialog
 - Change the exact shared version only while every Peer is disabled
 - Auto-formats configuration as JSON for easier editing
diff --git a/apps/client-web/src/components/extension/extensionCard/extensionCard.spec.ts b/apps/client-web/src/components/extension/extensionCard/extensionCard.spec.ts
new file mode 100644
index 0000000..e8a604c
--- /dev/null
+++ b/apps/client-web/src/components/extension/extensionCard/extensionCard.spec.ts
@@ -0,0 +1,113 @@
+import { defineComponent } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import ExtensionCard from './extensionCard.vue'
+
+const SetupComponent = defineComponent({
+  template: '<p data-test="twitter-setup">Twitter setup</p>',
+})
+const host = {
+  getSetupContribution: vi.fn((): { component: typeof SetupComponent } | null => ({
+    component: SetupComponent,
+  })),
+  changeVersion: vi.fn(),
+  updateConfig: vi.fn(),
+  uninstall: vi.fn(),
+}
+
+vi.mock('@/core', () => ({ getExtensionHost: () => host }))
+vi.mock('vue-i18n', () => ({ useI18n: () => ({ t: (key: string) => key }) }))
+
+const extension = {
+  name: 'inkcre/twitter',
+  version: '0.2.0',
+  enabled: ['00000000-0000-4000-8000-000000000001'],
+  nickname: 'Twitter',
+  config: {},
+  config_schema: null,
+}
+
+const stubs = {
+  InkButton: defineComponent({
+    props: ['text'],
+    emits: ['click'],
+    template: '<button @click="$emit(\'click\')">{{ text }}</button>',
+  }),
+  InkSwitch: defineComponent({
+    props: ['modelValue'],
+    emits: ['update:modelValue'],
+    template: '<button data-test="switch" @click="$emit(\'update:modelValue\', false)" />',
+  }),
+  InkDialog: defineComponent({ template: '<section><slot /></section>' }),
+  InkInput: true,
+  InkJsonEditor: true,
+}
+
+describe('ExtensionCard setup contribution', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('mounts setup from the current Web runtime independently of selected Client state', async () => {
+    const wrapper = mount(ExtensionCard, {
+      props: {
+        extension,
+        enabled: false,
+        controlsCurrentWebRuntime: false,
+        setEnabled: vi.fn(async () => ({ ...extension, enabled: [] })),
+      },
+      global: { stubs },
+    })
+
+    const setup = wrapper.findAll('button').find((button) => button.text() === 'extension.setup')
+    expect(setup).toBeDefined()
+    await setup?.trigger('click')
+
+    expect(host.getSetupContribution).toHaveBeenCalledWith('inkcre/twitter')
+    expect(wrapper.get('[data-test="twitter-setup"]').text()).toBe('Twitter setup')
+  })
+
+  it('does not offer setup without a running Web contribution', () => {
+    host.getSetupContribution.mockReturnValueOnce(null)
+    const wrapper = mount(ExtensionCard, {
+      props: {
+        extension: { ...extension, enabled: [] },
+        enabled: false,
+        controlsCurrentWebRuntime: false,
+        setEnabled: vi.fn(async () => ({ ...extension, enabled: [] })),
+      },
+      global: { stubs },
+    })
+
+    expect(wrapper.text()).not.toContain('extension.setup')
+  })
+
+  it('unmounts contributed setup before disabling its current Web runtime', async () => {
+    const setEnabled = vi.fn(async () => {
+      expect(wrapper.find('[data-test="twitter-setup"]').exists()).toBe(false)
+      return { ...extension, enabled: [] }
+    })
+    const wrapper = mount(ExtensionCard, {
+      props: { extension, enabled: true, controlsCurrentWebRuntime: true, setEnabled },
+      global: { stubs },
+    })
+    const setup = wrapper.findAll('button').find((button) => button.text() === 'extension.setup')
+    await setup?.trigger('click')
+    await wrapper.get('[data-test="switch"]').trigger('click')
+    await flushPromises()
+
+    expect(setEnabled).toHaveBeenCalledWith(false)
+  })
+
+  it('keeps current Web setup mounted when controlling another selected Client', async () => {
+    const setEnabled = vi.fn(async () => ({ ...extension, enabled: [] }))
+    const wrapper = mount(ExtensionCard, {
+      props: { extension, enabled: true, controlsCurrentWebRuntime: false, setEnabled },
+      global: { stubs },
+    })
+    const setup = wrapper.findAll('button').find((button) => button.text() === 'extension.setup')
+    await setup?.trigger('click')
+    await wrapper.get('[data-test="switch"]').trigger('click')
+    await flushPromises()
+
+    expect(wrapper.find('[data-test="twitter-setup"]').exists()).toBe(true)
+  })
+})
diff --git a/apps/client-web/src/components/extension/extensionCard/extensionCard.ts b/apps/client-web/src/components/extension/extensionCard/extensionCard.ts
index 9643960..5713e30 100644
--- a/apps/client-web/src/components/extension/extensionCard/extensionCard.ts
+++ b/apps/client-web/src/components/extension/extensionCard/extensionCard.ts
@@ -5,11 +5,15 @@ import type { InstalledExtension } from '@inkcre/core'
 export const extensionCardProps = {
   extension: { type: Object as PropType<InstalledExtension>, required: true },
   enabled: { type: Boolean, required: true },
+  controlsCurrentWebRuntime: { type: Boolean, required: true },
+  setEnabled: {
+    type: Function as PropType<(enabled: boolean) => Promise<InstalledExtension>>,
+    required: true,
+  },
 } as const
 
 // --- Emits ---
 export const extensionCardEmits = {
-  changed: () => true,
   updated: (_extension: InstalledExtension) => true,
   uninstalled: () => true,
 } as const
diff --git a/apps/client-web/src/components/extension/extensionCard/extensionCard.vue b/apps/client-web/src/components/extension/extensionCard/extensionCard.vue
index f72f738..2f9bd6b 100644
--- a/apps/client-web/src/components/extension/extensionCard/extensionCard.vue
+++ b/apps/client-web/src/components/extension/extensionCard/extensionCard.vue
@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { ref, computed, watch } from 'vue'
+import { ref, computed, nextTick, shallowRef, watch, type Component } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { InkButton, InkSwitch, InkDialog, InkInput, InkJsonEditor } from '@inkcre/ui-web'
 import { getExtensionHost } from '@/core'
@@ -12,6 +12,9 @@ const { t } = useI18n()
 // --- data ---
 const configPopupOpen = ref<boolean | Promise<boolean>>(false)
 const versionPopupOpen = ref<boolean | Promise<boolean>>(false)
+const setupPopupOpen = ref(false)
+const setupComponent = shallowRef<Component | null>(null)
+const setupContribution = shallowRef(getExtensionHost().getSetupContribution(props.extension.name))
 const togglePromise = ref<Promise<boolean> | null>(null)
 const isUninstalling = ref(false)
 const operationError = ref<string | null>(null)
@@ -28,6 +31,11 @@ watch(
 )
 
 const canUninstall = computed(() => props.extension.enabled.length === 0 && !isUninstalling.value)
+const closeSetup = async () => {
+  setupPopupOpen.value = false
+  setupComponent.value = null
+  await nextTick()
+}
 
 const toggleModel = computed({
   get: () => (togglePromise.value ? togglePromise.value : props.enabled),
@@ -35,17 +43,15 @@ const toggleModel = computed({
     operationError.value = null
     togglePromise.value = (async () => {
       try {
-        if (enabled) {
-          await getExtensionHost().enable(props.extension.name)
-        } else {
-          await getExtensionHost().disable(props.extension.name)
-        }
-        emit('changed')
+        if (!enabled && props.controlsCurrentWebRuntime) await closeSetup()
+        const updated = await props.setEnabled(enabled)
+        emit('updated', updated)
         return enabled
       } catch (error) {
         operationError.value = error instanceof Error ? error.message : String(error)
         return props.enabled
       } finally {
+        setupContribution.value = getExtensionHost().getSetupContribution(props.extension.name)
         togglePromise.value = null
       }
     })()
@@ -56,6 +62,13 @@ const onEditConfigClick = () => {
   configPopupOpen.value = true
 }
 
+const onSetupClick = () => {
+  const contribution = setupContribution.value
+  if (!contribution) return
+  setupComponent.value = contribution.component
+  setupPopupOpen.value = true
+}
+
 const onChangeVersionClick = () => {
   versionModel.value = props.extension.version
   versionPopupOpen.value = true
@@ -123,6 +136,13 @@ const onUninstall = async () => {
     </div>
 
     <div class="extension-card__actions">
+      <InkButton
+        v-if="setupContribution"
+        :text="t('extension.setup')"
+        theme="primary"
+        size="sm"
+        @click="onSetupClick"
+      />
       <InkButton @click="onEditConfigClick" :text="t('extension.editConfig')" size="sm" />
       <InkButton
         @click="onChangeVersionClick"
@@ -146,6 +166,17 @@ const onUninstall = async () => {
     </p>
     <p v-if="operationError" class="extension-card__error">{{ operationError }}</p>
 
+    <InkDialog
+      v-model="setupPopupOpen"
+      :title="t('extension.setupTitle', { name: extension.nickname ?? extension.name })"
+      :show-cancel="false"
+      :show-confirm="false"
+      :close-on-scrim="false"
+      @update:model-value="(open) => !open && closeSetup()"
+    >
+      <component :is="setupComponent" v-if="setupComponent" @close="closeSetup" />
+    </InkDialog>
+
     <InkDialog
       v-model="configPopupOpen"
       :title="t('extension.editConfigTitle')"
diff --git a/apps/client-web/src/core.ts b/apps/client-web/src/core.ts
index 525f2f9..b8e8964 100644
--- a/apps/client-web/src/core.ts
+++ b/apps/client-web/src/core.ts
@@ -7,6 +7,7 @@
 
 import {
   configStore,
+  ExtensionRegistryOriginResolver,
   getMFImplementation,
   localStorageAdapter,
   PostgrestExtensionStatePort,
@@ -23,6 +24,7 @@ import {
   HtmlResolver,
   ZipResolver,
   PeerManager,
+  WebPeerRuntime,
   JobManager,
   WebExtensionHost,
   type ExtensionStatePort,
@@ -79,13 +81,19 @@ export function setupResolvers(): void {
 // ============================================================================
 
 let extensionHost: WebExtensionHost | null = null
+let extensionHostStartup: Promise<void> | null = null
+let extensionState: ExtensionStatePort | null = null
+let webPeerRuntime: WebPeerRuntime | null = null
 
 export function initializeExtensionHost(state: ExtensionStatePort): WebExtensionHost {
+  extensionHostStartup = null
+  extensionState = state
+  const registryOrigin = new ExtensionRegistryOriginResolver(
+    () => configStore.peerConfig.extension_registry_url
+  )
   extensionHost = new WebExtensionHost({
     state,
-    releases: new RegistryExtensionReleaseReader(
-      () => configStore.peerConfig.extension_registry_url
-    ),
+    releases: new RegistryExtensionReleaseReader(() => registryOrigin.resolve()),
     moduleFederation: getMFImplementation,
     currentPeerId: () => configStore.metaConfig.INKCRE_PEER_ID,
     hostSdkVersion: corePackageJson.version,
@@ -93,6 +101,22 @@ export function initializeExtensionHost(state: ExtensionStatePort): WebExtension
   return extensionHost
 }
 
+export function getExtensionState(): ExtensionStatePort {
+  if (!extensionState) throw new Error('Web Extension state port has not been initialized.')
+  return extensionState
+}
+
+/** Share one initial runtime restore across the app shell and management view. */
+export function startExtensionHost(): Promise<void> {
+  if (extensionHostStartup) return extensionHostStartup
+  const startup = getExtensionHost().startup()
+  extensionHostStartup = startup.catch((error: unknown) => {
+    extensionHostStartup = null
+    throw error
+  })
+  return extensionHostStartup
+}
+
 export function getExtensionHost(): WebExtensionHost {
   if (!extensionHost) {
     throw new Error('Web Extension Host state port has not been initialized.')
@@ -100,6 +124,30 @@ export function getExtensionHost(): WebExtensionHost {
   return extensionHost
 }
 
+/** Replace the browser-owned lease runtime after a validated Settings cutover. */
+export function adoptWebPeerRuntime(runtime: WebPeerRuntime): void {
+  webPeerRuntime?.stop()
+  webPeerRuntime = runtime
+}
+
+export function stopWebPeerRuntime(): void {
+  webPeerRuntime?.stop()
+  webPeerRuntime = null
+}
+
+/** Start the lease after Settings has mounted and loaded recovery configuration. */
+export async function startConfiguredWebPeerRuntime(): Promise<void> {
+  if (!configStore.metaConfig.INKCRE_PGREST_URL || !configStore.metaConfig.INKCRE_JWT_SECRET) return
+  const candidate = new WebPeerRuntime(configStore.metaConfig.INKCRE_PEER_ID)
+  try {
+    await candidate.start()
+    adoptWebPeerRuntime(candidate)
+  } catch (error) {
+    candidate.stop()
+    throw error
+  }
+}
+
 // ============================================================================
 // Module Federation
 // ============================================================================
@@ -196,17 +244,34 @@ export function shouldLoadPeerConfigAtBootstrap(pathname: string): boolean {
 
 export async function initializeCore(options: { loadPeerConfig?: boolean } = {}): Promise<void> {
   await configStore.initializeMeta(localStorageAdapter)
-  if (options.loadPeerConfig ?? true) {
-    await configStore.loadPeerConfig()
+  await configStore.saveMeta()
+  const requirePeerConnection = options.loadPeerConfig ?? true
+  if (
+    requirePeerConnection &&
+    configStore.metaConfig.INKCRE_PGREST_URL &&
+    configStore.metaConfig.INKCRE_JWT_SECRET
+  ) {
+    const candidate = new WebPeerRuntime(configStore.metaConfig.INKCRE_PEER_ID)
+    try {
+      await candidate.register()
+      await configStore.loadPeerConfig()
+      await candidate.start()
+      adoptWebPeerRuntime(candidate)
+    } catch (error) {
+      candidate.stop()
+      throw error
+    }
   }
   PeerManager.setupBuiltinOutbounds()
   JobManager.startWorker()
   setupResolvers()
   initializeModuleFederation()
   initializeExtensionHost(new PostgrestExtensionStatePort())
+  if (webPeerRuntime) await webPeerRuntime.start()
   console.log('[Core] Initialization complete')
 }
 
 export function shutdownCore(): void {
+  stopWebPeerRuntime()
   JobManager.stopWorker()
 }
diff --git a/apps/client-web/src/extension-peer-control.spec.ts b/apps/client-web/src/extension-peer-control.spec.ts
new file mode 100644
index 0000000..fa9d293
--- /dev/null
+++ b/apps/client-web/src/extension-peer-control.spec.ts
@@ -0,0 +1,106 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  Peer,
+  PeerManager,
+  type ExtensionStatePort,
+  type InstalledExtension,
+  type WebExtensionHost,
+} from '@inkcre/core'
+import {
+  EXTENSION_MANAGEMENT_CAPABILITY,
+  extensionPeerControlMode,
+  setExtensionPeerEnabled,
+} from './extension-peer-control'
+
+const currentPeerId = '00000000-0000-4000-8000-000000000001'
+const remotePeerId = '00000000-0000-4000-8000-000000000002'
+const installed: InstalledExtension = {
+  name: 'inkcre/twitter',
+  version: '0.2.0',
+  enabled: [],
+  nickname: 'Twitter',
+  config: {},
+  config_schema: null,
+}
+
+function peer(id: string, options: { live?: boolean; management?: boolean } = {}): Peer {
+  return Peer.parse({
+    id,
+    name: 'Client',
+    labels: [],
+    config: {},
+    config_schema: {},
+    capabilities: options.management
+      ? [
+          {
+            id: EXTENSION_MANAGEMENT_CAPABILITY,
+            inbound: { protocol: 'core.peer.protocol.http.v1', parameters: {} },
+          },
+        ]
+      : [],
+    lease_expires_at: options.live === false ? new Date(0) : new Date('2099-01-01'),
+    created_at: new Date('2026-01-01'),
+    updated_at: new Date('2026-01-01'),
+  })
+}
+
+describe('Extension Peer control', () => {
+  afterEach(() => vi.restoreAllMocks())
+
+  it('uses the local Web Host for this browser Client', async () => {
+    const enable = vi.fn(async () => ({ ...installed, enabled: [currentPeerId] }))
+    const state = { setPeerEnabled: vi.fn() }
+
+    await expect(
+      setExtensionPeerEnabled({
+        name: installed.name,
+        peer: peer(currentPeerId),
+        currentPeerId,
+        enabled: true,
+        webHost: { enable } as never,
+        state: state as never,
+      })
+    ).resolves.toMatchObject({ enabled: [currentPeerId] })
+    expect(enable).toHaveBeenCalledWith(installed.name)
+    expect(state.setPeerEnabled).not.toHaveBeenCalled()
+  })
+
+  it('delegates to an exact live Client that advertises runtime management', async () => {
+    const delegate = vi.spyOn(PeerManager, 'delegate').mockResolvedValue({
+      status: 200,
+      body: { ...installed, enabled: [remotePeerId] },
+    } as never)
+
+    await setExtensionPeerEnabled({
+      name: installed.name,
+      peer: peer(remotePeerId, { management: true }),
+      currentPeerId,
+      enabled: true,
+      webHost: {} as WebExtensionHost,
+      state: {} as ExtensionStatePort,
+    })
+
+    expect(delegate).toHaveBeenCalledWith(
+      EXTENSION_MANAGEMENT_CAPABILITY,
+      { body: { action: 'enable', extension: installed.name } },
+      remotePeerId
+    )
+  })
+
+  it('updates durable desired state for any Client without a live management endpoint', async () => {
+    const target = peer(remotePeerId, { live: false })
+    const setPeerEnabled = vi.fn(async () => ({ ...installed, enabled: [remotePeerId] }))
+
+    expect(extensionPeerControlMode(target, currentPeerId)).toBe('desired-state')
+    await setExtensionPeerEnabled({
+      name: installed.name,
+      peer: target,
+      currentPeerId,
+      enabled: true,
+      webHost: {} as WebExtensionHost,
+      state: { setPeerEnabled } as unknown as ExtensionStatePort,
+    })
+
+    expect(setPeerEnabled).toHaveBeenCalledWith(installed.name, remotePeerId, true)
+  })
+})
diff --git a/apps/client-web/src/extension-peer-control.ts b/apps/client-web/src/extension-peer-control.ts
new file mode 100644
index 0000000..637a93d
--- /dev/null
+++ b/apps/client-web/src/extension-peer-control.ts
@@ -0,0 +1,64 @@
+import {
+  InstalledExtensionSchema,
+  Peer,
+  PeerManager,
+  PeerProtocolResponseSchema,
+  type ExtensionStatePort,
+  type InstalledExtension,
+  type WebExtensionHost,
+} from '@inkcre/core'
+
+export const EXTENSION_MANAGEMENT_CAPABILITY = 'core.extension.management.v1'
+export type ExtensionPeerControlMode = 'current-runtime' | 'remote-host' | 'desired-state'
+
+export function peerAdvertises(peer: Peer, capability: string): boolean {
+  try {
+    return peer.capabilitySnapshot().some((candidate) => candidate.id === capability)
+  } catch {
+    return false
+  }
+}
+
+export function extensionPeerControlMode(
+  peer: Peer,
+  currentPeerId: string
+): ExtensionPeerControlMode {
+  if (peer.id === currentPeerId) return 'current-runtime'
+  const live = peer.lease_expires_at !== null && peer.lease_expires_at.getTime() > Date.now()
+  return live && peerAdvertises(peer, EXTENSION_MANAGEMENT_CAPABILITY)
+    ? 'remote-host'
+    : 'desired-state'
+}
+
+export async function setExtensionPeerEnabled(input: {
+  name: string
+  peer: Peer
+  currentPeerId: string
+  enabled: boolean
+  webHost: WebExtensionHost
+  state: ExtensionStatePort
+}): Promise<InstalledExtension> {
+  const mode = extensionPeerControlMode(input.peer, input.currentPeerId)
+  if (mode === 'current-runtime') {
+    return input.enabled ? input.webHost.enable(input.name) : input.webHost.disable(input.name)
+  }
+  if (mode === 'desired-state') {
+    return input.state.setPeerEnabled(input.name, input.peer.id, input.enabled)
+  }
+
+  const delegated = await PeerManager.delegate(
+    EXTENSION_MANAGEMENT_CAPABILITY,
+    {
+      body: {
+        action: input.enabled ? 'enable' : 'disable',
+        extension: input.name,
+      },
+    },
+    input.peer.id
+  )
+  const response = PeerProtocolResponseSchema.parse(delegated)
+  if (response.status !== 200 || response.body === undefined) {
+    throw new Error(`Extension management Peer returned HTTP ${response.status} for ${input.name}.`)
+  }
+  return InstalledExtensionSchema.parse(response.body)
+}
diff --git a/apps/client-web/src/locales/messages/en.json b/apps/client-web/src/locales/messages/en.json
index ed37a27..f1e7939 100644
--- a/apps/client-web/src/locales/messages/en.json
+++ b/apps/client-web/src/locales/messages/en.json
@@ -29,6 +29,10 @@
     "extensionRegistryUrl": "Extension Registry URL",
     "jwtSecret": "JWT Secret",
     "clientId": "Client ID",
+    "peerId": "Client ID",
+    "peerIdGenerated": "Generated and persisted for this browser origin.",
+    "peerConfig": "Client Settings",
+    "peerConfigNotice": "Saved for this client and shared with every browser session using this Client ID.",
     "languageLabel": "Language",
     "languageDescription": "Select your preferred language",
     "saveConfig": "Save",
@@ -83,6 +87,14 @@
     "changeVersion": "Change Version",
     "changeVersionTitle": "Change Exact Extension Version",
     "uninstall": "Uninstall",
+    "setup": "Setup",
+    "setupTitle": "Set up {name}",
+    "peerSelector": "Control Extension on Client",
+    "peerSelectorPlaceholder": "Select a Client",
+    "peerNotFound": "The selected Client no longer exists.",
+    "currentBrowser": "This browser",
+    "desiredStateOnly": "This Client has no live management endpoint. Changes update its durable enabled state and take effect when that Client next reconciles it.",
+    "peerListUnavailable": "The Client list could not be loaded: {error}",
     "enabledPeerCount": "Enabled on {count} Peer(s).",
     "uninstallDisabled": "Disable every Peer before uninstalling or changing the shared version."
   },
diff --git a/apps/client-web/src/locales/messages/zh-CN.json b/apps/client-web/src/locales/messages/zh-CN.json
index 8fd0894..7bda22b 100644
--- a/apps/client-web/src/locales/messages/zh-CN.json
+++ b/apps/client-web/src/locales/messages/zh-CN.json
@@ -29,6 +29,10 @@
     "extensionRegistryUrl": "扩展注册表地址",
     "jwtSecret": "JWT 密钥",
     "clientId": "客户端 ID",
+    "peerId": "客户端 ID",
+    "peerIdGenerated": "由当前浏览器来源自动生成并持久保存。",
+    "peerConfig": "客户端设置",
+    "peerConfigNotice": "配置存储在当前客户端上，并由使用同一客户端 ID 的浏览器会话共享。",
     "languageLabel": "语言",
     "languageDescription": "选择您的首选语言",
     "saveConfig": "保存",
@@ -83,6 +87,14 @@
     "changeVersion": "变更版本",
     "changeVersionTitle": "变更扩展的精确版本",
     "uninstall": "卸载",
+    "setup": "设置",
+    "setupTitle": "设置 {name}",
+    "peerSelector": "控制扩展的客户端",
+    "peerSelectorPlaceholder": "选择客户端",
+    "peerNotFound": "所选客户端已不存在。",
+    "currentBrowser": "当前浏览器",
+    "desiredStateOnly": "此客户端没有在线管理端点；操作只更新其持久启用状态，并在该客户端下次协调状态时生效。",
+    "peerListUnavailable": "无法加载客户端列表：{error}",
     "enabledPeerCount": "已在 {count} 个 Peer 上启用。",
     "uninstallDisabled": "卸载或变更共享版本前，必须先禁用所有 Peer。"
   },
diff --git a/apps/client-web/src/main.ts b/apps/client-web/src/main.ts
index 58a026d..a905d48 100644
--- a/apps/client-web/src/main.ts
+++ b/apps/client-web/src/main.ts
@@ -20,18 +20,21 @@ setInfoBaseRouter(createInfoBaseRouterAdapter(router))
 // Initialize core package
 import { initializeCore, shutdownCore } from './core'
 import { shouldLoadPeerConfigAtBootstrap } from './core'
+const loadPeerConfigAtBootstrap = shouldLoadPeerConfigAtBootstrap(window.location.pathname)
 await initializeCore({
   // Settings is the recovery surface for invalid or incomplete bootstrap
-  // credentials. It must mount without first contacting the configured Peer.
-  loadPeerConfig: shouldLoadPeerConfigAtBootstrap(window.location.pathname),
+  // credentials. It mounts before contacting the configured Peer.
+  loadPeerConfig: loadPeerConfigAtBootstrap,
 })
 app.mount('#app')
 
-import { getExtensionHost } from './core'
+import { getExtensionHost, startExtensionHost } from './core'
 const extensionHost = getExtensionHost()
-extensionHost.startup().catch((error) => {
-  console.error('[Web Extension Host] Startup failed:', error)
-})
+if (loadPeerConfigAtBootstrap) {
+  startExtensionHost().catch((error) => {
+    console.error('[Web Extension Host] Startup failed:', error)
+  })
+}
 
 window.addEventListener('beforeunload', () => {
   shutdownCore()
diff --git a/apps/client-web/src/twitter-setup-api.spec.ts b/apps/client-web/src/twitter-setup-api.spec.ts
new file mode 100644
index 0000000..85c1c1b
--- /dev/null
+++ b/apps/client-web/src/twitter-setup-api.spec.ts
@@ -0,0 +1,130 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { Peer, PeerManager, type ExtensionStatePort, type InstalledExtension } from '@inkcre/core'
+import {
+  discoverCoreCandidates,
+  OAuthTransactionSchema,
+  TwitterSetupAPI,
+  TwitterSetupStatusSchema,
+} from '../../../extensions/twitter/src/setup-api'
+
+const corePeerId = '00000000-0000-4000-8000-000000000002'
+const installed: InstalledExtension = {
+  name: 'inkcre/twitter',
+  version: '0.2.0',
+  enabled: [corePeerId],
+  nickname: 'Twitter',
+  config: {},
+  config_schema: null,
+}
+const corePeer = Peer.parse({
+  id: corePeerId,
+  name: 'Core Preview',
+  labels: [],
+  config: {},
+  config_schema: {},
+  capabilities: [
+    {
+      id: 'core.extension.management.v1',
+      inbound: { protocol: 'core.peer.protocol.http.v1', parameters: {} },
+    },
+    {
+      id: 'inkcre.twitter.setup.v1',
+      inbound: { protocol: 'core.peer.protocol.http.v1', parameters: {} },
+    },
+  ],
+  lease_expires_at: new Date('2099-01-01'),
+  created_at: new Date('2026-01-01'),
+  updated_at: new Date('2026-01-01'),
+})
+
+describe('Twitter Peer setup API', () => {
+  afterEach(() => vi.restoreAllMocks())
+
+  it('discovers setup against one shared installation and live capability snapshots', async () => {
+    vi.spyOn(PeerManager, 'listLive').mockResolvedValue([corePeer])
+    const get = vi.fn(async () => installed)
+
+    await expect(
+      discoverCoreCandidates(undefined, { get } as unknown as ExtensionStatePort)
+    ).resolves.toEqual([
+      expect.objectContaining({
+        peer: corePeer,
+        extension: installed,
+        enabled: true,
+        setupAvailable: true,
+      }),
+    ])
+    expect(get).toHaveBeenCalledWith('inkcre/twitter')
+  })
+
+  it('executes setup only through the exact selected Core Peer capability', async () => {
+    const delegate = vi.spyOn(PeerManager, 'delegate').mockResolvedValue({
+      status: 200,
+      body: {
+        backend: 'oauth2',
+        callback_url: 'https://core.example/twitter/oauth/callback',
+        oauth_app_configured: false,
+        client_id: null,
+        connected: false,
+        user_id: null,
+        handle: null,
+        scopes: [],
+        reconnect_required: false,
+        bookmark_source_id: null,
+        bookmark_cron_id: null,
+        bookmark_sources: [],
+        collect_at: { day_of_week: null, hour: 0, minute: 0 },
+        bookmark_source_ready: false,
+        ready: false,
+      },
+    })
+
+    await new TwitterSetupAPI(corePeer).status()
+
+    expect(delegate).toHaveBeenCalledWith(
+      'inkcre.twitter.setup.v1',
+      { body: { action: 'get_status' } },
+      corePeerId
+    )
+  })
+
+  it('rejects non-HTTP callback and non-HTTPS authorization URLs from a Peer', () => {
+    expect(() =>
+      TwitterSetupStatusSchema.parse({
+        backend: 'oauth2',
+        callback_url: 'javascript:alert(1)',
+        oauth_app_configured: false,
+        client_id: null,
+        connected: false,
+        user_id: null,
+        handle: null,
+        scopes: [],
+        reconnect_required: false,
+        bookmark_source_id: null,
+        bookmark_cron_id: null,
+        bookmark_sources: [],
+        collect_at: { day_of_week: null, hour: 0, minute: 0 },
+        bookmark_source_ready: false,
+        ready: false,
+      })
+    ).toThrow('HTTP or HTTPS')
+    expect(() =>
+      OAuthTransactionSchema.parse({
+        id: '00000000-0000-4000-8000-000000000003',
+        status: 'pending',
+        authorize_url: 'javascript:alert(1)',
+        expires_at: '2099-01-01T00:00:00Z',
+        error: null,
+      })
+    ).toThrow('HTTPS')
+    expect(() =>
+      OAuthTransactionSchema.parse({
+        id: '00000000-0000-4000-8000-000000000004',
+        status: 'pending',
+        authorize_url: 'https://user:secret@x.example/authorize',
+        expires_at: '2099-01-01T00:00:00Z',
+        error: null,
+      })
+    ).toThrow('embedded credentials')
+  })
+})
diff --git a/apps/client-web/src/twitter-setup-wizard.spec.ts b/apps/client-web/src/twitter-setup-wizard.spec.ts
new file mode 100644
index 0000000..337bbaf
--- /dev/null
+++ b/apps/client-web/src/twitter-setup-wizard.spec.ts
@@ -0,0 +1,91 @@
+import { defineComponent } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import TwitterSetupWizard from '../../../extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.vue'
+
+const fixtures = vi.hoisted(() => {
+  const peerId = '00000000-0000-4000-8000-000000000002'
+  const extension = {
+    name: 'inkcre/twitter',
+    version: '0.2.0',
+    enabled: [] as string[],
+    nickname: 'Twitter',
+    config: {},
+    config_schema: null,
+  }
+  const candidate = {
+    peer: { id: peerId, name: 'Core Preview' },
+    extension,
+    enabled: false,
+    setupAvailable: false,
+  }
+  const status = {
+    backend: 'official',
+    callback_url: 'https://core.example/twitter/auth/callback',
+    oauth_app_configured: false,
+    client_id: null,
+    connected: false,
+    user_id: null,
+    handle: null,
+    scopes: [],
+    reconnect_required: false,
+    bookmark_source_id: null,
+    bookmark_cron_id: null,
+    bookmark_sources: [],
+    collect_at: { day_of_week: null, hour: 0, minute: 0 },
+    bookmark_source_ready: false,
+    ready: false,
+  }
+  return {
+    peerId,
+    extension,
+    candidate,
+    status,
+    discover: vi.fn(async () => [candidate]),
+    enableCore: vi.fn(async () => ({ ...extension, enabled: [peerId] })),
+    readStatus: vi.fn(async () => status),
+  }
+})
+
+vi.mock('../../../extensions/twitter/src/setup-api', () => ({
+  discoverCoreCandidates: fixtures.discover,
+  TwitterSetupAPI: class {
+    enableCore = fixtures.enableCore
+    status = fixtures.readStatus
+  },
+}))
+
+const stubs = {
+  InkButton: defineComponent({
+    props: ['text'],
+    emits: ['click'],
+    template: '<button @click="$emit(\'click\')">{{ text }}</button>',
+  }),
+  InkInput: true,
+  InkLoading: true,
+}
+
+describe('TwitterSetupWizard', () => {
+  beforeEach(() => {
+    fixtures.candidate.enabled = false
+    fixtures.candidate.extension = fixtures.extension
+    vi.clearAllMocks()
+  })
+
+  it('requires explicit Core enablement before whole-Extension setup commands', async () => {
+    const wrapper = mount(TwitterSetupWizard, { global: { stubs } })
+    await flushPromises()
+
+    const enable = wrapper
+      .findAll('button')
+      .find((button) => button.text() === 'Enable Twitter on this Core Peer')
+    expect(enable).toBeDefined()
+    await enable?.trigger('click')
+    await flushPromises()
+
+    expect(fixtures.enableCore).toHaveBeenCalledOnce()
+    expect(fixtures.readStatus).toHaveBeenCalledOnce()
+    expect(wrapper.text()).toContain('Connect an X account')
+    expect(wrapper.text()).toContain('https://core.example/twitter/auth/callback')
+  })
+})
diff --git a/apps/client-web/src/views/extensions/extensions.scss b/apps/client-web/src/views/extensions/extensions.scss
index fcc75c7..4782420 100644
--- a/apps/client-web/src/views/extensions/extensions.scss
+++ b/apps/client-web/src/views/extensions/extensions.scss
@@ -18,6 +18,17 @@
     overflow-y: auto;
   }
 
+  &__header {
+    display: grid;
+    gap: sys-var(space, sm);
+  }
+
+  &__notice {
+    @include apply-font(body-sm);
+    margin: 0;
+    color: sys-var(color, text, muted);
+  }
+
   &__error {
     @include apply-font(body-sm);
     color: sys-var(color, danger, base);
diff --git a/apps/client-web/src/views/extensions/extensions.spec.ts b/apps/client-web/src/views/extensions/extensions.spec.ts
new file mode 100644
index 0000000..87d0c36
--- /dev/null
+++ b/apps/client-web/src/views/extensions/extensions.spec.ts
@@ -0,0 +1,122 @@
+import { defineComponent, nextTick } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import ExtensionsView from './extensions.vue'
+
+const fixtures = vi.hoisted(() => {
+  const currentPeerId = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'
+  const remotePeerId = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'
+  const peers = [
+    { id: currentPeerId, name: 'Browser A', capabilities: [], lease_expires_at: new Date() },
+    { id: remotePeerId, name: 'Browser B', capabilities: [], lease_expires_at: new Date(0) },
+  ]
+  const extension = {
+    name: 'inkcre/twitter',
+    version: '0.2.0',
+    enabled: [currentPeerId],
+    nickname: 'Twitter',
+    config: {},
+    config_schema: null,
+  }
+  return {
+    currentPeerId,
+    remotePeerId,
+    peers,
+    extension,
+    host: { list: vi.fn(async () => [extension]) },
+    listPeers: vi.fn(async () => peers),
+    setPeerEnabled: vi.fn(),
+  }
+})
+
+vi.mock('@inkcre/core', () => ({
+  Peer: {
+    list: fixtures.listPeers,
+    parse: (value: unknown) => value,
+  },
+  configStore: { metaConfig: { INKCRE_PEER_ID: fixtures.currentPeerId } },
+}))
+vi.mock('@/core', () => ({
+  getExtensionHost: () => fixtures.host,
+  getExtensionState: () => ({ setPeerEnabled: vi.fn() }),
+  startExtensionHost: vi.fn(async () => undefined),
+}))
+vi.mock('@/extension-peer-control', () => ({
+  extensionPeerControlMode: (peer: { id: string }) =>
+    peer.id === fixtures.currentPeerId ? 'current-runtime' : 'desired-state',
+  setExtensionPeerEnabled: fixtures.setPeerEnabled,
+}))
+vi.mock('vue-i18n', () => ({ useI18n: () => ({ t: (key: string) => key }) }))
+
+const ExtensionCardStub = defineComponent({
+  props: ['extension', 'enabled', 'controlsCurrentWebRuntime', 'setEnabled'],
+  template:
+    '<div data-test="extension-card" :data-enabled="String(enabled)" :data-current="String(controlsCurrentWebRuntime)" />',
+})
+const InkDropdownStub = defineComponent({
+  props: ['modelValue', 'options', 'label', 'placeholder'],
+  emits: ['update:modelValue'],
+  template: '<button data-test="client-selector" />',
+})
+
+describe('Extensions Client selector', () => {
+  beforeEach(() => vi.clearAllMocks())
+
+  it('defaults to this browser and projects enabled state for the selected Client', async () => {
+    const wrapper = mount(ExtensionsView, {
+      global: {
+        stubs: {
+          extensionCard: ExtensionCardStub,
+          installExtension: true,
+          InkDropdown: InkDropdownStub,
+          InkLoading: true,
+        },
+      },
+    })
+    await flushPromises()
+
+    const selector = wrapper.getComponent(InkDropdownStub)
+    expect(selector.props('modelValue')).toBe(fixtures.currentPeerId)
+    expect(selector.props('options')[0]).toMatchObject({
+      value: fixtures.currentPeerId,
+      label: 'Browser A (extension.currentBrowser)',
+    })
+    expect(wrapper.get('[data-test="extension-card"]').attributes()).toMatchObject({
+      'data-enabled': 'true',
+      'data-current': 'true',
+    })
+
+    selector.vm.$emit('update:modelValue', fixtures.remotePeerId)
+    await nextTick()
+    expect(wrapper.get('[data-test="extension-card"]').attributes()).toMatchObject({
+      'data-enabled': 'false',
+      'data-current': 'false',
+    })
+    expect(wrapper.text()).toContain('extension.desiredStateOnly')
+  })
+
+  it('keeps this-browser management available when the Client list fails', async () => {
+    fixtures.listPeers.mockRejectedValueOnce(new Error('Peer row could not be parsed'))
+    const wrapper = mount(ExtensionsView, {
+      global: {
+        stubs: {
+          extensionCard: ExtensionCardStub,
+          installExtension: true,
+          InkDropdown: InkDropdownStub,
+          InkLoading: true,
+        },
+      },
+    })
+    await flushPromises()
+
+    const selector = wrapper.getComponent(InkDropdownStub)
+    expect(selector.props('options')).toEqual([
+      {
+        label: 'extension.currentBrowser',
+        value: fixtures.currentPeerId,
+        description: fixtures.currentPeerId,
+      },
+    ])
+    expect(wrapper.text()).toContain('extension.peerListUnavailable')
+  })
+})
diff --git a/apps/client-web/src/views/extensions/extensions.vue b/apps/client-web/src/views/extensions/extensions.vue
index 7bdce78..9e97b52 100644
--- a/apps/client-web/src/views/extensions/extensions.vue
+++ b/apps/client-web/src/views/extensions/extensions.vue
@@ -1,21 +1,76 @@
 <script setup lang="ts">
-import { onMounted, ref } from 'vue'
+import { computed, onMounted, ref } from 'vue'
 import extensionCard from '@/components/extension/extensionCard/extensionCard.vue'
 import installExtension from '@/components/extension/installExtension/installExtension.vue'
-import { InkLoading } from '@inkcre/ui-web'
-import { configStore, type InstalledExtension } from '@inkcre/core'
-import { getExtensionHost } from '@/core'
+import { InkDropdown, InkLoading } from '@inkcre/ui-web'
+import { configStore, Peer, type InstalledExtension } from '@inkcre/core'
+import { getExtensionHost, getExtensionState, startExtensionHost } from '@/core'
+import { extensionPeerControlMode, setExtensionPeerEnabled } from '@/extension-peer-control'
 import { useI18n } from 'vue-i18n'
 
 // --- data ---
 const { t } = useI18n()
 const currentPeerId = configStore.metaConfig.INKCRE_PEER_ID
+const selectedPeerId = ref(currentPeerId)
+const peers = ref<Peer[]>([])
 const extensions = ref<InstalledExtension[]>([])
+const peersLoading = ref(false)
 const extensionsLoading = ref(false)
 const error = ref<string | null>(null)
+const peerError = ref<string | null>(null)
 
-const isEnabledForCurrentPeer = (extension: InstalledExtension) =>
-  currentPeerId ? extension.enabled.includes(currentPeerId) : false
+const currentPeerFallback = Peer.parse({
+  id: currentPeerId,
+  name: t('extension.currentBrowser'),
+  labels: [],
+  config: {},
+  config_schema: {},
+  capabilities: [],
+  lease_expires_at: new Date(Date.now() + 60_000),
+  created_at: new Date(),
+  updated_at: new Date(),
+})
+const selectedPeer = computed(
+  () =>
+    peers.value.find((peer) => peer.id === selectedPeerId.value) ??
+    (selectedPeerId.value === currentPeerId ? currentPeerFallback : null)
+)
+const peerOptions = computed(() => {
+  const options = peers.value.map((peer) => ({
+    label:
+      peer.id === currentPeerId ? `${peer.name} (${t('extension.currentBrowser')})` : peer.name,
+    value: peer.id,
+    description: peer.id,
+  }))
+  return peers.value.some((peer) => peer.id === currentPeerId)
+    ? options
+    : [
+        {
+          label: t('extension.currentBrowser'),
+          value: currentPeerId,
+          description: currentPeerId,
+        },
+        ...options,
+      ]
+})
+const selectedControlMode = computed(() =>
+  selectedPeer.value ? extensionPeerControlMode(selectedPeer.value, currentPeerId) : null
+)
+const isEnabledForSelectedPeer = (extension: InstalledExtension) =>
+  extension.enabled.includes(selectedPeerId.value)
+
+const refreshPeers = async () => {
+  peersLoading.value = true
+  peerError.value = null
+  try {
+    peers.value = await Peer.list()
+  } catch (cause) {
+    peers.value = []
+    peerError.value = cause instanceof Error ? cause.message : String(cause)
+  } finally {
+    peersLoading.value = false
+  }
+}
 
 const refreshExtensions = async () => {
   extensionsLoading.value = true
@@ -29,7 +84,14 @@ const refreshExtensions = async () => {
   }
 }
 
-onMounted(() => void refreshExtensions())
+onMounted(async () => {
+  try {
+    await startExtensionHost()
+  } catch {
+    // The app shell owns runtime-startup reporting; this list remains a recovery surface.
+  }
+  await Promise.all([refreshPeers(), refreshExtensions()])
+})
 
 // --- methods ---
 const onInstallExtension = () => {
@@ -41,6 +103,22 @@ const updExtension = (updatedExtension: InstalledExtension) => {
     extension.name === updatedExtension.name ? updatedExtension : extension
   )
 }
+
+const setEnabledForSelectedPeer = (
+  extension: InstalledExtension,
+  enabled: boolean
+): Promise<InstalledExtension> => {
+  const peer = selectedPeer.value
+  if (!peer) throw new Error(t('extension.peerNotFound'))
+  return setExtensionPeerEnabled({
+    name: extension.name,
+    peer,
+    currentPeerId,
+    enabled,
+    webHost: getExtensionHost(),
+    state: getExtensionState(),
+  })
+}
 </script>
 
 <template>
@@ -48,7 +126,22 @@ const updExtension = (updatedExtension: InstalledExtension) => {
     <installExtension @install="onInstallExtension" />
 
     <div class="extensions-view__list">
-      <div v-if="extensionsLoading" class="flex items-center justify-center">
+      <div class="extensions-view__header">
+        <InkDropdown
+          v-model="selectedPeerId"
+          :label="t('extension.peerSelector')"
+          :placeholder="t('extension.peerSelectorPlaceholder')"
+          :options="peerOptions"
+        />
+        <p v-if="selectedControlMode === 'desired-state'" class="extensions-view__notice">
+          {{ t('extension.desiredStateOnly') }}
+        </p>
+        <p v-if="peerError" class="extensions-view__error">
+          {{ t('extension.peerListUnavailable', { error: peerError }) }}
+        </p>
+      </div>
+
+      <div v-if="extensionsLoading || peersLoading" class="flex items-center justify-center">
         <InkLoading />
       </div>
       <p v-else-if="error" class="extensions-view__error">{{ error }}</p>
@@ -57,8 +150,9 @@ const updExtension = (updatedExtension: InstalledExtension) => {
         v-else
         :key="extension.name"
         :extension="extension"
-        :enabled="isEnabledForCurrentPeer(extension)"
-        @changed="refreshExtensions"
+        :enabled="isEnabledForSelectedPeer(extension)"
+        :controls-current-web-runtime="selectedControlMode === 'current-runtime'"
+        :set-enabled="(enabled) => setEnabledForSelectedPeer(extension, enabled)"
         @updated="updExtension"
         @uninstalled="refreshExtensions"
       />
diff --git a/apps/client-web/src/views/settings/settings.scss b/apps/client-web/src/views/settings/settings.scss
index d8f83b9..bbc1b08 100644
--- a/apps/client-web/src/views/settings/settings.scss
+++ b/apps/client-web/src/views/settings/settings.scss
@@ -25,7 +25,8 @@
   }
 
   &__secret,
-  &__locale {
+  &__locale,
+  &__identity {
     display: flex;
     flex-direction: column;
     gap: sys-var('space', 'xs');
@@ -43,6 +44,10 @@
     }
   }
 
+  &__identity code {
+    overflow-wrap: anywhere;
+  }
+
   &__actions {
     display: flex;
     gap: sys-var('space', 'md');
diff --git a/apps/client-web/src/views/settings/settings.spec.ts b/apps/client-web/src/views/settings/settings.spec.ts
new file mode 100644
index 0000000..64f02ac
--- /dev/null
+++ b/apps/client-web/src/views/settings/settings.spec.ts
@@ -0,0 +1,140 @@
+import { defineComponent, onMounted } from 'vue'
+import { flushPromises, mount } from '@vue/test-utils'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { configStore, MetaConfigSchema, PeerConfigSchema } from '@inkcre/core'
+import Settings from './settings.vue'
+
+const peerListState = vi.hoisted(() => ({ mounts: 0 }))
+const appRuntimeState = vi.hoisted(() => ({
+  adopt: vi.fn(),
+  startConfigured: vi.fn(async () => undefined),
+  stop: vi.fn(),
+}))
+
+vi.mock('@/core', () => ({
+  adoptWebPeerRuntime: appRuntimeState.adopt,
+  startConfiguredWebPeerRuntime: appRuntimeState.startConfigured,
+  stopWebPeerRuntime: appRuntimeState.stop,
+}))
+
+vi.mock('@/components/peer/peerList/peerList.vue', () => ({
+  default: defineComponent({
+    name: 'PeerList',
+    setup() {
+      onMounted(() => {
+        peerListState.mounts += 1
+      })
+    },
+    template: '<section data-test="all-clients" />',
+  }),
+}))
+
+vi.mock('vue-i18n', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('vue-i18n')>()),
+  useI18n: () => ({ t: (key: string) => key }),
+}))
+
+const connectedMeta = MetaConfigSchema.parse({
+  INKCRE_PGREST_URL: 'https://database.example.test/',
+  INKCRE_JWT_SECRET: 'secret',
+  INKCRE_PEER_ID: '00000000-0000-4000-8000-000000000001',
+})
+const originalMeta = { ...configStore.metaConfig }
+const originalPeer = PeerConfigSchema.parse(configStore.peerConfig)
+
+const stubs = {
+  InkForm: defineComponent({ template: '<form><slot /></form>' }),
+  InkInput: true,
+  InkButton: defineComponent({
+    props: ['text'],
+    emits: ['click'],
+    template: '<button type="button" @click="$emit(\'click\')">{{ text }}</button>',
+  }),
+  InkDoubleCheck: defineComponent({ template: '<div><slot /></div>' }),
+}
+
+describe('Settings Client scopes', () => {
+  beforeEach(() => {
+    peerListState.mounts = 0
+    appRuntimeState.adopt.mockReset()
+    appRuntimeState.startConfigured.mockClear()
+    appRuntimeState.stop.mockReset()
+    vi.stubGlobal('alert', vi.fn())
+  })
+
+  afterEach(() => {
+    Object.assign(configStore.metaConfig, originalMeta)
+    Object.assign(configStore.peerConfig, originalPeer)
+    vi.restoreAllMocks()
+    vi.unstubAllGlobals()
+  })
+
+  it('keeps bootstrap recovery available without mounting deployment Clients', async () => {
+    Object.assign(configStore.metaConfig, MetaConfigSchema.parse({}))
+    const loadPeerConfig = vi.spyOn(configStore, 'loadPeerConfig').mockResolvedValue()
+
+    const wrapper = mount(Settings, { global: { stubs } })
+    await flushPromises()
+
+    expect(wrapper.find('[data-test="all-clients"]').exists()).toBe(false)
+    expect(loadPeerConfig).not.toHaveBeenCalled()
+    wrapper.unmount()
+  })
+
+  it('loads Client settings and the complete Client list once connected', async () => {
+    Object.assign(configStore.metaConfig, connectedMeta)
+    vi.spyOn(configStore, 'loadPeerConfig').mockResolvedValue()
+
+    const wrapper = mount(Settings, { global: { stubs } })
+    await flushPromises()
+
+    expect(wrapper.find('[data-test="all-clients"]').exists()).toBe(true)
+    expect(peerListState.mounts).toBe(1)
+    wrapper.unmount()
+  })
+
+  it('refreshes the Client list after validated Client settings are saved', async () => {
+    Object.assign(configStore.metaConfig, connectedMeta)
+    vi.spyOn(configStore, 'loadPeerConfig').mockResolvedValue()
+    const runtime = { stop: vi.fn() }
+    vi.spyOn(configStore, 'connectAndSave').mockImplementation(async (meta, peer) => {
+      Object.assign(configStore.metaConfig, meta)
+      Object.assign(configStore.peerConfig, peer)
+      return runtime as never
+    })
+    const wrapper = mount(Settings, { global: { stubs } })
+    await flushPromises()
+    const save = wrapper.findAll('button').find((button) => button.text() === 'settings.saveConfig')
+
+    await save?.trigger('click')
+    await flushPromises()
+
+    expect(configStore.connectAndSave).toHaveBeenCalledOnce()
+    expect(appRuntimeState.adopt).toHaveBeenCalledWith(runtime)
+    expect(peerListState.mounts).toBe(2)
+    wrapper.unmount()
+  })
+
+  it('does not overwrite Client settings while their initial read is pending', async () => {
+    Object.assign(configStore.metaConfig, connectedMeta)
+    let resolveLoad: (() => void) | undefined
+    vi.spyOn(configStore, 'loadPeerConfig').mockImplementation(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveLoad = resolve
+        })
+    )
+    const connect = vi.spyOn(configStore, 'connectAndSave')
+    const wrapper = mount(Settings, { global: { stubs } })
+    await flushPromises()
+    const save = wrapper.findAll('button').find((button) => button.text() === 'settings.saveConfig')
+
+    expect(save?.attributes('disabled')).toBeDefined()
+    await save?.trigger('click')
+    expect(connect).not.toHaveBeenCalled()
+
+    resolveLoad?.()
+    await flushPromises()
+    wrapper.unmount()
+  })
+})
diff --git a/apps/client-web/src/views/settings/settings.vue b/apps/client-web/src/views/settings/settings.vue
index 6ceb766..c4b6157 100644
--- a/apps/client-web/src/views/settings/settings.vue
+++ b/apps/client-web/src/views/settings/settings.vue
@@ -1,16 +1,33 @@
 <script setup lang="ts">
-import { computed, reactive, ref, watch } from 'vue'
+import { computed, onMounted, reactive, ref, watch } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { InkForm, InkInput, InkButton, InkDoubleCheck } from '@inkcre/ui-web'
-import { configStore, MetaConfigSchema, type MetaConfig } from '@inkcre/core'
+import {
+  configStore,
+  MetaConfigSchema,
+  PeerConfigSchema,
+  type MetaConfig,
+  type PeerConfig,
+} from '@inkcre/core'
 import { setLocale, SUPPORT_LOCALES, LOCALE_NAMES, type SupportLocale } from '@/locales'
 import i18n from '@/locales'
 import PeerList from '@/components/peer/peerList/peerList.vue'
+import { adoptWebPeerRuntime, startConfiguredWebPeerRuntime, stopWebPeerRuntime } from '@/core'
 
 const { t } = useI18n()
 
 // Local reactive copy of metaConfig for form editing
 const metaFormConfig = reactive<MetaConfig>({ ...configStore.metaConfig })
+const peerFormConfig = reactive<PeerConfig>(PeerConfigSchema.parse(configStore.peerConfig))
+const allPeersRevision = ref(0)
+const peerConfigLoading = ref(false)
+const saving = ref(false)
+const hasConnectedConfig = computed(
+  () =>
+    Boolean(configStore.metaConfig.INKCRE_PGREST_URL) &&
+    Boolean(configStore.metaConfig.INKCRE_JWT_SECRET)
+)
+const formBusy = computed(() => peerConfigLoading.value || saving.value)
 
 // Synchronize metaFormConfig with configStore.metaConfig
 watch(
@@ -20,6 +37,25 @@ watch(
   },
   { deep: true }
 )
+watch(
+  () => configStore.peerConfig,
+  (newPeerConfig) => Object.assign(peerFormConfig, PeerConfigSchema.parse(newPeerConfig)),
+  { deep: true }
+)
+
+onMounted(async () => {
+  if (!hasConnectedConfig.value) return
+  peerConfigLoading.value = true
+  try {
+    await configStore.loadPeerConfig()
+    Object.assign(peerFormConfig, PeerConfigSchema.parse(configStore.peerConfig))
+    await startConfiguredWebPeerRuntime()
+  } catch (error) {
+    console.warn('Configured Web Peer could not start from Settings.', error)
+  } finally {
+    peerConfigLoading.value = false
+  }
+})
 
 // Current locale (computed for v-model)
 const currentLocale = computed({
@@ -31,22 +67,31 @@ const currentLocale = computed({
 
 // Save config
 const onSave = async () => {
+  if (formBusy.value) return
+  saving.value = true
   try {
-    const validated = MetaConfigSchema.parse(metaFormConfig)
-    Object.assign(configStore.metaConfig, validated)
-    await configStore.saveMeta()
-    await configStore.loadPeerConfig()
+    const validatedMeta = MetaConfigSchema.parse(metaFormConfig)
+    const validatedPeer = PeerConfigSchema.parse(peerFormConfig)
+    const runtime = await configStore.connectAndSave(validatedMeta, validatedPeer)
+    adoptWebPeerRuntime(runtime)
+    Object.assign(metaFormConfig, configStore.metaConfig)
+    Object.assign(peerFormConfig, PeerConfigSchema.parse(configStore.peerConfig))
+    allPeersRevision.value += 1
     alert(t('settings.saveSuccess'))
   } catch (error) {
     console.error('Failed to save config:', error)
     alert('Failed to save configuration')
+  } finally {
+    saving.value = false
   }
 }
 
 // Reset config
 const onReset = async () => {
   await configStore.resetMeta()
+  stopWebPeerRuntime()
   Object.assign(metaFormConfig, configStore.metaConfig)
+  Object.assign(peerFormConfig, PeerConfigSchema.parse(configStore.peerConfig))
 }
 
 // Export config
@@ -73,16 +118,20 @@ const onExport = () => {
 const fileInput = ref<HTMLInputElement | null>(null)
 
 const onImport = () => {
+  if (formBusy.value) return
   fileInput.value?.click()
 }
 
 const onFileSelected = async (event: Event) => {
+  if (formBusy.value) return
   const input = event.target as HTMLInputElement
   const file = input.files?.[0]
   if (!file) return
 
   const reader = new FileReader()
   reader.onload = async (e) => {
+    if (formBusy.value) return
+    saving.value = true
     try {
       const content = e.target?.result as string
       const imported = JSON.parse(content)
@@ -90,14 +139,20 @@ const onFileSelected = async (event: Event) => {
         ...configStore.metaConfig,
         ...imported.metaConfig,
       })
-      Object.assign(configStore.metaConfig, validated)
-      await configStore.saveMeta()
-      await configStore.loadPeerConfig()
+      const runtime = await configStore.connectAndSave(
+        validated,
+        PeerConfigSchema.parse(peerFormConfig)
+      )
+      adoptWebPeerRuntime(runtime)
       Object.assign(metaFormConfig, configStore.metaConfig)
+      Object.assign(peerFormConfig, PeerConfigSchema.parse(configStore.peerConfig))
+      allPeersRevision.value += 1
       alert(t('settings.saveSuccess'))
     } catch (error) {
       console.error('Failed to import config:', error)
       alert(t('settings.importError'))
+    } finally {
+      saving.value = false
     }
   }
   reader.readAsText(file)
@@ -134,10 +189,18 @@ const onFileSelected = async (event: Event) => {
         <small>{{ t('settings.jwtStoredLocally') }}</small>
       </label>
 
+      <div class="settings-view__identity">
+        <span>{{ t('settings.peerId') }}</span>
+        <code>{{ metaFormConfig.INKCRE_PEER_ID }}</code>
+        <small>{{ t('settings.peerIdGenerated') }}</small>
+      </div>
+
+      <h2 class="settings-view__section-title">{{ t('settings.peerConfig') }}</h2>
+      <p class="settings-view__notice">{{ t('settings.peerConfigNotice') }}</p>
       <InkInput
-        v-model="metaFormConfig.INKCRE_PEER_ID"
-        :label="t('settings.clientId')"
-        placeholder="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
+        v-model="peerFormConfig.extension_registry_url"
+        :label="t('settings.extensionRegistryUrl')"
+        placeholder="https://registry.inkcre.dev"
       />
 
       <!-- Language Selection -->
@@ -154,7 +217,13 @@ const onFileSelected = async (event: Event) => {
 
     <!-- Action Buttons -->
     <div class="settings-view__actions">
-      <InkButton :text="t('settings.saveConfig')" theme="primary" @click="onSave" />
+      <InkButton
+        :text="t('settings.saveConfig')"
+        theme="primary"
+        :disabled="formBusy"
+        :loading="saving"
+        @click="onSave"
+      />
 
       <InkDoubleCheck
         :title="t('settings.resetConfirmTitle')"
@@ -165,11 +234,11 @@ const onFileSelected = async (event: Event) => {
       </InkDoubleCheck>
 
       <InkButton :text="t('settings.exportConfig')" @click="onExport" />
-      <InkButton :text="t('settings.importConfig')" @click="onImport" />
+      <InkButton :text="t('settings.importConfig')" :disabled="formBusy" @click="onImport" />
     </div>
     <p class="settings-view__export-note">{{ t('settings.exportExcludesSecret') }}</p>
 
-    <PeerList />
+    <PeerList v-if="hasConnectedConfig" :key="allPeersRevision" />
 
     <!-- Hidden file input for import -->
     <input
diff --git a/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.md b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.md
new file mode 100644
index 0000000..562325e
--- /dev/null
+++ b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.md
@@ -0,0 +1,10 @@
+# TwitterSetupWizard
+
+Twitter-owned four-step setup contribution mounted by the client-web Extension dialog.
+
+- Discovers live Core Peers through Peer capability advertisements.
+- Requires explicit Core enablement before setup commands are available.
+- Configures the user's X OAuth App, opens the standalone provider flow, and polls only the opaque transaction reference.
+- Selects or creates a Bookmark Source and explicitly starts initial collection.
+- Derives progress from Core setup facts; it does not persist a wizard step.
+- Owns its Close action; client-web only owns the popup surface.
diff --git a/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.scss b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.scss
new file mode 100644
index 0000000..ec1815c
--- /dev/null
+++ b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.scss
@@ -0,0 +1,124 @@
+.twitter-setup {
+  display: grid;
+  gap: 1.25rem;
+  width: min(680px, 80vw);
+
+  &__toolbar {
+    display: flex;
+    justify-content: flex-end;
+  }
+
+  &__steps {
+    display: grid;
+    grid-template-columns: repeat(4, 1fr);
+    gap: 0.5rem;
+    margin: 0;
+    padding: 0;
+    list-style: none;
+
+    li {
+      display: flex;
+      align-items: center;
+      gap: 0.4rem;
+      color: #6b7280;
+      font-size: 0.8rem;
+    }
+
+    span {
+      display: inline-grid;
+      place-items: center;
+      width: 1.5rem;
+      height: 1.5rem;
+      border: 1px solid currentcolor;
+      border-radius: 50%;
+    }
+
+    .is-current,
+    .is-complete {
+      color: #2563eb;
+      font-weight: 600;
+    }
+  }
+
+  &__panel {
+    display: grid;
+    gap: 1rem;
+
+    h3,
+    p {
+      margin: 0;
+    }
+
+    code {
+      display: block;
+      margin-top: 0.5rem;
+      padding: 0.6rem;
+      overflow-wrap: anywhere;
+      background: rgb(0 0 0 / 5%);
+    }
+  }
+
+  &__field,
+  &__schedule label {
+    display: grid;
+    gap: 0.35rem;
+  }
+
+  select,
+  input {
+    min-height: 2.5rem;
+    padding: 0.5rem;
+    border: 1px solid #d1d5db;
+    border-radius: 0.35rem;
+    background: transparent;
+    color: inherit;
+  }
+
+  &__schedule,
+  &__actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.75rem;
+  }
+
+  &__oauth-link {
+    width: fit-content;
+    font-weight: 600;
+  }
+
+  &__loading {
+    display: flex;
+    justify-content: center;
+    min-height: 10rem;
+  }
+
+  &__error {
+    margin: 0;
+    color: #b91c1c;
+  }
+
+  dl {
+    display: grid;
+    grid-template-columns: max-content 1fr;
+    gap: 0.5rem 1rem;
+    margin: 0;
+  }
+
+  dt {
+    font-weight: 600;
+  }
+
+  dd {
+    margin: 0;
+  }
+}
+
+@media (max-width: 640px) {
+  .twitter-setup {
+    width: min(88vw, 680px);
+
+    &__steps {
+      grid-template-columns: 1fr 1fr;
+    }
+  }
+}
diff --git a/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.ts b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.ts
new file mode 100644
index 0000000..aa6288d
--- /dev/null
+++ b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.ts
@@ -0,0 +1,10 @@
+export const twitterSetupWizardEmits = {
+  close: () => true,
+} as const
+
+export const TWITTER_SETUP_STEPS = [
+  'Prepare',
+  'Connect account',
+  'Bookmark Source',
+  'Review and start',
+] as const
diff --git a/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.vue b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.vue
new file mode 100644
index 0000000..d55f0a1
--- /dev/null
+++ b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.vue
@@ -0,0 +1,428 @@
+<script setup lang="ts">
+import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
+import { InkButton, InkInput, InkLoading } from '@inkcre/ui-web'
+import {
+  discoverCoreCandidates,
+  TwitterSetupAPI,
+  type CorePeerCandidate,
+  type OAuthTransaction,
+  type TwitterSetupStatus,
+} from '../../setup-api'
+import { TWITTER_SETUP_STEPS, twitterSetupWizardEmits } from './twitterSetupWizard'
+
+const emit = defineEmits(twitterSetupWizardEmits)
+const candidates = ref<CorePeerCandidate[]>([])
+const selectedPeerId = ref<string | null>(null)
+const status = ref<TwitterSetupStatus | null>(null)
+const currentStep = ref(0)
+const loading = ref(true)
+const busy = ref(false)
+const error = ref<string | null>(null)
+const clientId = ref('')
+const clientSecret = ref('')
+const transaction = ref<OAuthTransaction | null>(null)
+const sourceId = ref<number | null>(null)
+const sourceNickname = ref('Twitter Bookmarks')
+const sourceHour = ref(0)
+const sourceMinute = ref(0)
+let polling: AbortController | null = null
+const lifecycle = new AbortController()
+
+const selectedCandidate = computed(
+  () => candidates.value.find((candidate) => candidate.peer.id === selectedPeerId.value) ?? null
+)
+const api = computed(() =>
+  selectedCandidate.value ? new TwitterSetupAPI(selectedCandidate.value.peer) : null
+)
+const selectedCoreEnabled = computed(() => selectedCandidate.value?.enabled ?? false)
+
+function message(cause: unknown): string {
+  return cause instanceof Error ? cause.message : String(cause)
+}
+
+function deriveStep(next: TwitterSetupStatus): number {
+  if (!next.oauth_app_configured || !next.connected) return 1
+  if (next.bookmark_source_id === null) return 2
+  return 3
+}
+
+function applyStatus(next: TwitterSetupStatus): void {
+  status.value = next
+  clientId.value = next.client_id ?? ''
+  clientSecret.value = ''
+  sourceId.value = next.bookmark_source_id ?? next.bookmark_sources[0]?.source_id ?? null
+  const source = next.bookmark_sources.find((item) => item.source_id === sourceId.value)
+  if (source) sourceNickname.value = source.nickname
+  sourceHour.value = next.collect_at.hour
+  sourceMinute.value = next.collect_at.minute
+  currentStep.value = deriveStep(next)
+}
+
+async function reloadStatus(): Promise<void> {
+  if (!api.value || !selectedCoreEnabled.value) return
+  applyStatus(await api.value.status(lifecycle.signal))
+}
+
+async function initialize(): Promise<void> {
+  loading.value = true
+  error.value = null
+  try {
+    candidates.value = await discoverCoreCandidates(lifecycle.signal)
+    const selected =
+      candidates.value.find((candidate) => candidate.enabled && candidate.setupAvailable) ??
+      candidates.value.find((candidate) => candidate.enabled) ??
+      candidates.value[0]
+    selectedPeerId.value = selected?.peer.id ?? null
+    if (selected?.enabled) await reloadStatus()
+  } catch (cause) {
+    error.value = message(cause)
+  } finally {
+    loading.value = false
+  }
+}
+
+watch(selectedPeerId, async (next, previous) => {
+  if (next === previous || loading.value) return
+  stopPolling()
+  status.value = null
+  transaction.value = null
+  currentStep.value = 0
+  error.value = null
+  try {
+    if (selectedCoreEnabled.value) await reloadStatus()
+  } catch (cause) {
+    error.value = message(cause)
+  }
+})
+
+async function enableSelectedCore(): Promise<void> {
+  if (!api.value || !selectedCandidate.value) return
+  busy.value = true
+  error.value = null
+  try {
+    const extension = await api.value.enableCore(lifecycle.signal)
+    selectedCandidate.value.extension = extension
+    selectedCandidate.value.enabled = extension.enabled.includes(selectedCandidate.value.peer.id)
+    await reloadStatus()
+  } catch (cause) {
+    error.value = message(cause)
+  } finally {
+    busy.value = false
+  }
+}
+
+async function saveOAuthApp(): Promise<void> {
+  if (!api.value) return
+  busy.value = true
+  error.value = null
+  try {
+    try {
+      applyStatus(
+        await api.value.saveOAuthApp(clientId.value, clientSecret.value, false, lifecycle.signal)
+      )
+    } catch (cause) {
+      const causeMessage = message(cause)
+      if (!causeMessage.includes('requires confirmation')) throw cause
+      if (!window.confirm(`${causeMessage}\n\nDisconnect the current account and continue?`)) return
+      applyStatus(
+        await api.value.saveOAuthApp(clientId.value, clientSecret.value, true, lifecycle.signal)
+      )
+    }
+  } catch (cause) {
+    error.value = message(cause)
+  } finally {
+    busy.value = false
+  }
+}
+
+function stopPolling(): void {
+  polling?.abort()
+  polling = null
+}
+
+function close(): void {
+  stopPolling()
+  emit('close')
+}
+
+async function wait(milliseconds: number, signal: AbortSignal): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    if (signal.aborted) {
+      reject(new DOMException('Polling cancelled', 'AbortError'))
+      return
+    }
+    const onAbort = () => {
+      window.clearTimeout(timer)
+      reject(new DOMException('Polling cancelled', 'AbortError'))
+    }
+    const timer = window.setTimeout(() => {
+      signal.removeEventListener('abort', onAbort)
+      resolve()
+    }, milliseconds)
+    signal.addEventListener('abort', onAbort, { once: true })
+  })
+}
+
+async function pollTransaction(id: string): Promise<void> {
+  if (!api.value) return
+  stopPolling()
+  const controller = new AbortController()
+  polling = controller
+  try {
+    while (!controller.signal.aborted) {
+      await wait(2000, controller.signal)
+      const next = await api.value.oauthTransaction(id, controller.signal)
+      transaction.value = next
+      if (!['pending', 'exchanging'].includes(next.status)) {
+        if (next.status === 'succeeded') await reloadStatus()
+        else error.value = next.error ?? 'Twitter authorization did not complete.'
+        return
+      }
+    }
+  } catch (cause) {
+    if (!controller.signal.aborted) error.value = message(cause)
+  } finally {
+    if (polling === controller) polling = null
+  }
+}
+
+async function beginOAuth(): Promise<void> {
+  if (!api.value) return
+  busy.value = true
+  error.value = null
+  try {
+    transaction.value = await api.value.beginOAuth(lifecycle.signal)
+    void pollTransaction(transaction.value.id)
+  } catch (cause) {
+    error.value = message(cause)
+  } finally {
+    busy.value = false
+  }
+}
+
+async function disconnect(): Promise<void> {
+  if (!api.value) return
+  busy.value = true
+  error.value = null
+  try {
+    stopPolling()
+    transaction.value = null
+    applyStatus(await api.value.disconnect(lifecycle.signal))
+  } catch (cause) {
+    error.value = message(cause)
+  } finally {
+    busy.value = false
+  }
+}
+
+async function saveBookmarkSource(): Promise<void> {
+  if (!api.value || busy.value) return
+  busy.value = true
+  error.value = null
+  try {
+    applyStatus(
+      await api.value.configureBookmarkSource(
+        {
+          ...(sourceId.value === null ? {} : { source_id: sourceId.value }),
+          nickname: sourceNickname.value,
+          collect_at: {
+            day_of_week: null,
+            hour: sourceHour.value,
+            minute: sourceMinute.value,
+          },
+        },
+        lifecycle.signal
+      )
+    )
+  } catch (cause) {
+    error.value = message(cause)
+  } finally {
+    busy.value = false
+  }
+}
+
+async function finish(): Promise<void> {
+  if (!api.value || busy.value) return
+  busy.value = true
+  error.value = null
+  try {
+    applyStatus(await api.value.finish(lifecycle.signal))
+  } catch (cause) {
+    error.value = message(cause)
+  } finally {
+    busy.value = false
+  }
+}
+
+onMounted(() => void initialize())
+onBeforeUnmount(() => {
+  lifecycle.abort()
+  stopPolling()
+})
+</script>
+
+<template>
+  <section class="twitter-setup">
+    <ol class="twitter-setup__steps" aria-label="Twitter setup progress">
+      <li
+        v-for="(step, index) in TWITTER_SETUP_STEPS"
+        :key="step"
+        :class="{ 'is-current': currentStep === index, 'is-complete': currentStep > index }"
+      >
+        <span>{{ index + 1 }}</span
+        >{{ step }}
+      </li>
+    </ol>
+
+    <div v-if="loading" class="twitter-setup__loading"><InkLoading /></div>
+    <template v-else>
+      <p v-if="error" class="twitter-setup__error" role="alert">{{ error }}</p>
+
+      <div v-if="currentStep === 0" class="twitter-setup__panel">
+        <h3>Choose a Core Peer</h3>
+        <p>
+          The setup commands run on a Core Peer, but configure Twitter for the whole deployment.
+        </p>
+        <label v-if="candidates.length" class="twitter-setup__field">
+          Core Peer
+          <select v-model="selectedPeerId">
+            <option
+              v-for="candidate in candidates"
+              :key="candidate.peer.id"
+              :value="candidate.peer.id"
+            >
+              {{ candidate.peer.name }}{{ candidate.enabled ? ' — enabled' : '' }}
+            </option>
+          </select>
+        </label>
+        <p v-else>No live Core Peer exposes Extension management for installed Twitter.</p>
+        <InkButton
+          v-if="selectedCandidate && !selectedCoreEnabled"
+          text="Enable Twitter on this Core Peer"
+          theme="primary"
+          :loading="busy"
+          @click="enableSelectedCore"
+        />
+      </div>
+
+      <div v-else-if="currentStep === 1" class="twitter-setup__panel">
+        <h3>Connect an X account</h3>
+        <p>
+          Register your own X OAuth 2.0 application and use this callback URL:
+          <code>{{ status?.callback_url }}</code>
+        </p>
+        <InkInput v-model="clientId" label="Client ID" required />
+        <label class="twitter-setup__field">
+          Client Secret
+          <input v-model="clientSecret" type="password" autocomplete="off" required />
+        </label>
+        <div class="twitter-setup__actions">
+          <InkButton
+            text="Save OAuth App"
+            :loading="busy"
+            :disabled="!clientId || !clientSecret"
+            @click="saveOAuthApp"
+          />
+          <InkButton
+            v-if="status?.oauth_app_configured"
+            text="Create authorization link"
+            theme="primary"
+            :loading="busy"
+            @click="beginOAuth"
+          />
+          <InkButton
+            v-if="status?.connected"
+            text="Disconnect"
+            theme="danger"
+            @click="disconnect"
+          />
+        </div>
+        <a
+          v-if="transaction?.authorize_url"
+          :href="transaction.authorize_url"
+          target="_blank"
+          rel="noopener noreferrer"
+          class="twitter-setup__oauth-link"
+        >
+          Open X authorization
+        </a>
+        <p v-if="transaction && ['pending', 'exchanging'].includes(transaction.status)">
+          Waiting for the standalone Core callback…
+        </p>
+        <p v-if="status?.connected">Connected as @{{ status.handle }}.</p>
+      </div>
+
+      <div v-else-if="currentStep === 2" class="twitter-setup__panel">
+        <h3>Choose a Bookmark Source</h3>
+        <label v-if="status?.bookmark_sources.length" class="twitter-setup__field">
+          Existing Source
+          <select v-model="sourceId">
+            <option :value="null">Create a new Source</option>
+            <option
+              v-for="source in status.bookmark_sources"
+              :key="source.source_id"
+              :value="source.source_id"
+            >
+              {{ source.nickname }}
+            </option>
+          </select>
+        </label>
+        <InkInput v-model="sourceNickname" label="Source nickname" :disabled="sourceId !== null" />
+        <div class="twitter-setup__schedule">
+          <label>
+            Daily hour
+            <input
+              v-model.number="sourceHour"
+              type="number"
+              min="0"
+              max="23"
+              :disabled="sourceId !== null"
+            />
+          </label>
+          <label>
+            Minute
+            <input
+              v-model.number="sourceMinute"
+              type="number"
+              min="0"
+              max="59"
+              :disabled="sourceId !== null"
+            />
+          </label>
+        </div>
+        <p v-if="sourceId !== null">Change an existing Source schedule from the Sources page.</p>
+        <InkButton
+          text="Use this Source"
+          theme="primary"
+          :loading="busy"
+          @click="saveBookmarkSource"
+        />
+      </div>
+
+      <div v-else class="twitter-setup__panel">
+        <h3>{{ status?.ready ? 'Twitter is ready' : 'Review and start' }}</h3>
+        <dl>
+          <dt>Account</dt>
+          <dd>@{{ status?.handle }}</dd>
+          <dt>Bookmark Source</dt>
+          <dd>#{{ status?.bookmark_source_id }}</dd>
+          <dt>Initial collection</dt>
+          <dd>{{ status?.bookmark_source_ready ? 'accepted' : 'not started' }}</dd>
+        </dl>
+        <InkButton
+          v-if="!status?.ready"
+          text="Start collecting bookmarks"
+          theme="primary"
+          :loading="busy"
+          @click="finish"
+        />
+      </div>
+    </template>
+
+    <div class="twitter-setup__toolbar">
+      <InkButton text="Close" theme="subtle" @click="close" />
+    </div>
+  </section>
+</template>
+
+<style lang="scss" scoped src="./twitterSetupWizard.scss" />
diff --git a/extensions/twitter/src/index.ts b/extensions/twitter/src/index.ts
index d685fd2..7bb8264 100644
--- a/extensions/twitter/src/index.ts
+++ b/extensions/twitter/src/index.ts
@@ -12,8 +12,13 @@
 
 import { type ExtensionModule } from '@inkcre/core'
 import './resolver'
+import TwitterSetupWizard from './components/twitterSetupWizard/twitterSetupWizard.vue'
 
 const Extension: ExtensionModule = {
+  setup: {
+    component: TwitterSetupWizard,
+  },
+
   async initialize() {},
 
   async activate() {
diff --git a/extensions/twitter/src/setup-api.ts b/extensions/twitter/src/setup-api.ts
new file mode 100644
index 0000000..0c32749
--- /dev/null
+++ b/extensions/twitter/src/setup-api.ts
@@ -0,0 +1,207 @@
+import {
+  InstalledExtensionSchema,
+  Peer,
+  PeerManager,
+  PeerProtocolResponseSchema,
+  PostgrestExtensionStatePort,
+  type ExtensionStatePort,
+  type InstalledExtension,
+  type JsonValue,
+} from '@inkcre/core'
+import { z } from 'zod'
+
+const EXTENSION_NAME = 'inkcre/twitter'
+const EXTENSION_MANAGEMENT_CAPABILITY = 'core.extension.management.v1'
+const TWITTER_SETUP_CAPABILITY = 'inkcre.twitter.setup.v1'
+
+function hasAuthorityUserInfo(value: string): boolean {
+  return /^[a-z][a-z0-9+.-]*:\/\/[^/?#]*@/i.test(value)
+}
+
+const HttpUrlSchema = z.url().refine((value) => {
+  const protocol = new URL(value).protocol
+  return (protocol === 'http:' || protocol === 'https:') && !hasAuthorityUserInfo(value)
+}, 'URL must use HTTP or HTTPS.')
+
+const HttpsUrlSchema = z
+  .url()
+  .refine(
+    (value) => new URL(value).protocol === 'https:' && !hasAuthorityUserInfo(value),
+    'Authorization URL must use HTTPS without embedded credentials.'
+  )
+
+const CollectAtSchema = z.object({
+  day_of_week: z.number().int().min(0).max(6).nullable(),
+  hour: z.number().int().min(0).max(23),
+  minute: z.number().int().min(0).max(59),
+})
+
+const BookmarkSourceSchema = z.object({
+  source_id: z.number().int().positive(),
+  nickname: z.string(),
+})
+
+export const TwitterSetupStatusSchema = z.object({
+  backend: z.string(),
+  callback_url: HttpUrlSchema,
+  oauth_app_configured: z.boolean(),
+  client_id: z.string().nullable(),
+  connected: z.boolean(),
+  user_id: z.string().nullable(),
+  handle: z.string().nullable(),
+  scopes: z.array(z.string()),
+  reconnect_required: z.boolean(),
+  bookmark_source_id: z.number().int().positive().nullable(),
+  bookmark_cron_id: z.number().int().positive().nullable(),
+  bookmark_sources: z.array(BookmarkSourceSchema),
+  collect_at: CollectAtSchema,
+  bookmark_source_ready: z.boolean(),
+  ready: z.boolean(),
+})
+
+export const OAuthTransactionSchema = z.object({
+  id: z.string().uuid(),
+  status: z.enum(['pending', 'exchanging', 'succeeded', 'failed', 'expired']),
+  authorize_url: HttpsUrlSchema.nullable(),
+  expires_at: z.coerce.date(),
+  error: z.string().nullable(),
+})
+
+export type TwitterSetupStatus = z.infer<typeof TwitterSetupStatusSchema>
+export type OAuthTransaction = z.infer<typeof OAuthTransactionSchema>
+
+export interface CorePeerCandidate {
+  peer: Peer
+  extension: InstalledExtension
+  enabled: boolean
+  setupAvailable: boolean
+}
+
+function advertises(peer: Peer, capability: string): boolean {
+  try {
+    return peer.capabilitySnapshot().some((candidate) => candidate.id === capability)
+  } catch {
+    return false
+  }
+}
+
+export async function discoverCoreCandidates(
+  signal?: AbortSignal,
+  state: ExtensionStatePort = new PostgrestExtensionStatePort()
+): Promise<CorePeerCandidate[]> {
+  signal?.throwIfAborted()
+  const [extension, peers] = await Promise.all([state.get(EXTENSION_NAME), PeerManager.listLive()])
+  signal?.throwIfAborted()
+  if (!extension) return []
+  return peers
+    .filter((peer) => advertises(peer, EXTENSION_MANAGEMENT_CAPABILITY))
+    .map((peer) => ({
+      peer,
+      extension,
+      enabled: extension.enabled.includes(peer.id),
+      setupAvailable: advertises(peer, TWITTER_SETUP_CAPABILITY),
+    }))
+}
+
+export class TwitterSetupAPI {
+  constructor(readonly peer: Peer) {}
+
+  enableCore(signal?: AbortSignal): Promise<InstalledExtension> {
+    return executeCapability(
+      this.peer,
+      EXTENSION_MANAGEMENT_CAPABILITY,
+      { action: 'enable', extension: EXTENSION_NAME },
+      InstalledExtensionSchema,
+      signal
+    )
+  }
+
+  status(signal?: AbortSignal): Promise<TwitterSetupStatus> {
+    return this.setup({ action: 'get_status' }, TwitterSetupStatusSchema, signal)
+  }
+
+  saveOAuthApp(
+    clientId: string,
+    clientSecret: string,
+    confirmAccountReset: boolean,
+    signal?: AbortSignal
+  ): Promise<TwitterSetupStatus> {
+    return this.setup(
+      {
+        action: 'save_oauth_app',
+        client_id: clientId,
+        client_secret: clientSecret,
+        confirm_account_reset: confirmAccountReset,
+      },
+      TwitterSetupStatusSchema,
+      signal
+    )
+  }
+
+  beginOAuth(signal?: AbortSignal): Promise<OAuthTransaction> {
+    return this.setup({ action: 'begin_oauth' }, OAuthTransactionSchema, signal)
+  }
+
+  oauthTransaction(transactionId: string, signal?: AbortSignal): Promise<OAuthTransaction> {
+    return this.setup(
+      { action: 'get_oauth_transaction', transaction_id: transactionId },
+      OAuthTransactionSchema,
+      signal
+    )
+  }
+
+  disconnect(signal?: AbortSignal): Promise<TwitterSetupStatus> {
+    return this.setup({ action: 'disconnect_account' }, TwitterSetupStatusSchema, signal)
+  }
+
+  configureBookmarkSource(
+    input: {
+      source_id?: number
+      nickname: string
+      collect_at: { day_of_week: number | null; hour: number; minute: number }
+    },
+    signal?: AbortSignal
+  ): Promise<TwitterSetupStatus> {
+    return this.setup(
+      { action: 'configure_bookmark_source', ...input },
+      TwitterSetupStatusSchema,
+      signal
+    )
+  }
+
+  finish(signal?: AbortSignal): Promise<TwitterSetupStatus> {
+    return this.setup({ action: 'finish' }, TwitterSetupStatusSchema, signal)
+  }
+
+  private setup<Result>(
+    command: JsonValue,
+    schema: z.ZodType<Result>,
+    signal?: AbortSignal
+  ): Promise<Result> {
+    return executeCapability(this.peer, TWITTER_SETUP_CAPABILITY, command, schema, signal)
+  }
+}
+
+async function executeCapability<Result>(
+  peer: Peer,
+  capability: string,
+  command: JsonValue,
+  schema: z.ZodType<Result>,
+  signal?: AbortSignal
+): Promise<Result> {
+  signal?.throwIfAborted()
+  const delegated = await PeerManager.delegate(capability, { body: command }, peer.id)
+  signal?.throwIfAborted()
+  const response = PeerProtocolResponseSchema.parse(delegated)
+  if (response.status < 200 || response.status >= 300 || response.body === undefined) {
+    const detail =
+      typeof response.body === 'object' &&
+      response.body !== null &&
+      !Array.isArray(response.body) &&
+      typeof response.body.detail === 'string'
+        ? response.body.detail
+        : `Peer capability ${capability} returned HTTP ${response.status}.`
+    throw new Error(detail)
+  }
+  return schema.parse(response.body)
+}
diff --git a/packages/core/package.json b/packages/core/package.json
index 85fc067..a0271c0 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@inkcre/core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "files": [
     "dist"
   ],
diff --git a/packages/core/src/base/db-api.ts b/packages/core/src/base/db-api.ts
index 0ccb677..ec950fb 100644
--- a/packages/core/src/base/db-api.ts
+++ b/packages/core/src/base/db-api.ts
@@ -6,6 +6,7 @@ import type { Database, InkcreSchema, RelationName, RelationRow } from '../datab
 
 type RelationInsert<Relation extends RelationName> = InkcreSchema['Tables'][Relation]['Insert']
 type RelationUpdate<Relation extends RelationName> = InkcreSchema['Tables'][Relation]['Update']
+export type DatabaseTokenProvider = () => Promise<string>
 
 function encodeTransportValue<Value>(value: unknown): Value {
   const encoded = JSON.stringify(value)
@@ -110,13 +111,14 @@ export class DBAPIClient<
     protected relation: Relation,
     protected defSchema?: { parse(input: unknown): DT },
     public schemaName: 'inkcre' = 'inkcre',
-    baseUrl: string = ''
+    baseUrl: string = '',
+    tokenProvider: DatabaseTokenProvider = () => authStore.getToken()
   ) {
     super(normalizePostgrestBaseUrl(baseUrl), {
       schema: schemaName,
       // Custom fetch to dynamically inject auth token on each request
       fetch: async (input, init) => {
-        const token = await authStore.getToken()
+        const token = await tokenProvider()
         const headers = new Headers(init?.headers)
         headers.set('Authorization', `Bearer ${token}`)
         return fetch(input, { ...init, headers })
diff --git a/packages/core/src/config/schema.ts b/packages/core/src/config/schema.ts
index f02c7d7..bac5f56 100644
--- a/packages/core/src/config/schema.ts
+++ b/packages/core/src/config/schema.ts
@@ -35,27 +35,41 @@ export const AIConfigSchema = z.object({
  * Contains URLs and secrets needed to fetch and initialize app config
  */
 const UnconfiguredUrlSchema = z.union([z.literal(''), z.url()])
-const UnconfiguredPeerIdSchema = z.union([z.literal(''), z.uuid()])
+const GeneratedPeerIdSchema = z.preprocess(
+  (value) => (value === '' ? undefined : value),
+  z.uuid().default(() => crypto.randomUUID())
+)
 
-export const MetaConfigSchema = z.object({
+const CurrentMetaConfigSchema = z.object({
   INKCRE_PGREST_URL: UnconfiguredUrlSchema.default(''),
   INKCRE_JWT_SECRET: z.string().default(''),
-  INKCRE_PEER_ID: UnconfiguredPeerIdSchema.default(''),
+  INKCRE_PEER_ID: GeneratedPeerIdSchema,
 })
 
+/** Preserve one browser origin's old technical identity during the Peer cutover. */
+export const MetaConfigSchema = z.preprocess((value) => {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return value
+  const input = value as Record<string, unknown>
+  if (input.INKCRE_PEER_ID !== undefined) return input
+  const priorIdentity = input.client_id ?? input.INKCRE_CLIENT_ID
+  return priorIdentity === undefined ? input : { ...input, INKCRE_PEER_ID: priorIdentity }
+}, CurrentMetaConfigSchema)
+
 export type MetaConfig = z.infer<typeof MetaConfigSchema>
 
 /**
  * App configuration schema (runtime)
  * Contains extension registry URL, AI settings, and runtime app configuration
  */
-export const PeerConfigSchema = z.object({
-  // Deployment-owned Peer configuration supplies this URL. Static artifacts
-  // deliberately keep the unconfigured state instead of embedding an origin.
-  extension_registry_url: UnconfiguredUrlSchema.default(''),
-  peer_http_timeout_ms: z.number().int().positive().default(30_000),
-  ai: AIConfigSchema.default(() => AIConfigSchema.parse({})),
-})
+export const PeerConfigSchema = z
+  .object({
+    // Deployment-owned Peer configuration supplies this URL. Static artifacts
+    // deliberately keep the unconfigured state instead of embedding an origin.
+    extension_registry_url: UnconfiguredUrlSchema.default(''),
+    peer_http_timeout_ms: z.number().int().positive().default(30_000),
+    ai: AIConfigSchema.default(() => AIConfigSchema.parse({})),
+  })
+  .passthrough()
 
 /**
  * Config type
diff --git a/packages/core/src/config/store.test.ts b/packages/core/src/config/store.test.ts
new file mode 100644
index 0000000..8cca16e
--- /dev/null
+++ b/packages/core/src/config/store.test.ts
@@ -0,0 +1,82 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { WebPeerRuntime } from '../peer'
+import { configStore } from './store'
+import type { ConfigAdapterWithWrite } from './types'
+
+const previousPeerId = '00000000-0000-4000-8000-000000000001'
+const nextPeerId = '00000000-0000-4000-8000-000000000002'
+
+function adapter() {
+  const write = vi.fn(async () => undefined)
+  const value: ConfigAdapterWithWrite = {
+    name: 'test',
+    read: async () => ({
+      INKCRE_PGREST_URL: 'https://old-database.example',
+      INKCRE_JWT_SECRET: 'old-secret',
+      INKCRE_PEER_ID: previousPeerId,
+    }),
+    write,
+  }
+  return { value, write }
+}
+
+describe('Config connection transaction', () => {
+  afterEach(() => vi.restoreAllMocks())
+
+  it('does not replace working browser bootstrap when database validation fails', async () => {
+    const storage = adapter()
+    await configStore.initializeMeta(storage.value)
+    vi.spyOn(WebPeerRuntime, 'connect').mockRejectedValue(new Error('wrong database'))
+
+    await expect(
+      configStore.connectAndSave(
+        {
+          INKCRE_PGREST_URL: 'https://new-database.example',
+          INKCRE_JWT_SECRET: 'new-secret',
+          INKCRE_PEER_ID: nextPeerId,
+        },
+        { ...configStore.peerConfig, extension_registry_url: 'https://registry.inkcre.dev' }
+      )
+    ).rejects.toThrow('wrong database')
+
+    expect(storage.write).not.toHaveBeenCalled()
+    expect(configStore.metaConfig.INKCRE_PEER_ID).toBe(previousPeerId)
+  })
+
+  it('persists bootstrap only after registration, config write, and lease validation succeed', async () => {
+    const storage = adapter()
+    await configStore.initializeMeta(storage.value)
+    const runtime = { stop: vi.fn() }
+    const connect = vi.spyOn(WebPeerRuntime, 'connect').mockResolvedValue({
+      peer: {} as never,
+      runtime: runtime as never,
+    })
+    const peerConfig = {
+      ...configStore.peerConfig,
+      extension_registry_url: 'https://registry.inkcre.dev',
+    }
+    const metaConfig = {
+      INKCRE_PGREST_URL: 'https://new-database.example',
+      INKCRE_JWT_SECRET: 'new-secret',
+      INKCRE_PEER_ID: nextPeerId,
+    }
+
+    await expect(configStore.connectAndSave(metaConfig, peerConfig)).resolves.toBe(runtime)
+
+    expect(connect).toHaveBeenCalledWith(metaConfig, peerConfig)
+    expect(storage.write).toHaveBeenCalledWith(metaConfig)
+    expect(configStore.metaConfig).toEqual(metaConfig)
+    expect(configStore.peerConfig.extension_registry_url).toBe('https://registry.inkcre.dev')
+  })
+
+  it('keeps the current bootstrap when reset persistence fails', async () => {
+    const storage = adapter()
+    await configStore.initializeMeta(storage.value)
+    storage.write.mockRejectedValueOnce(new Error('storage unavailable'))
+
+    await expect(configStore.resetMeta()).rejects.toThrow('storage unavailable')
+
+    expect(configStore.metaConfig.INKCRE_PEER_ID).toBe(previousPeerId)
+    expect(configStore.metaConfig.INKCRE_PGREST_URL).toBe('https://old-database.example')
+  })
+})
diff --git a/packages/core/src/config/store.ts b/packages/core/src/config/store.ts
index 9fdd641..754fccf 100644
--- a/packages/core/src/config/store.ts
+++ b/packages/core/src/config/store.ts
@@ -7,6 +7,7 @@ import { loadConfig as zodLoadConfig } from 'zod-config'
 
 // Lazy import Peer to avoid circular imports
 const lazyPeer = async () => (await import('../peer/peer')).Peer
+const lazyWebPeerRuntime = async () => (await import('../peer/runtime')).WebPeerRuntime
 
 const unconfiguredAdapter: ConfigAdapterWithWrite = {
   name: 'unconfigured',
@@ -46,7 +47,7 @@ export const useConfigStore = defineStore('inkcre-config', () => {
   }
 
   async function loadPeerConfig(): Promise<void> {
-    if (!metaConfig.value.INKCRE_PEER_ID) {
+    if (!metaConfig.value.INKCRE_PGREST_URL || !metaConfig.value.INKCRE_JWT_SECRET) {
       peerConfig.value = PeerConfigSchema.parse({})
       return
     }
@@ -72,10 +73,39 @@ export const useConfigStore = defineStore('inkcre-config', () => {
     }
   }
 
+  async function connectAndSave(metaCandidate: MetaConfig, peerCandidate: PeerConfig) {
+    error.value = null
+    const nextMeta = MetaConfigSchema.parse(metaCandidate)
+    const nextPeer = PeerConfigSchema.parse(peerCandidate)
+    let candidateRuntime: InstanceType<Awaited<ReturnType<typeof lazyWebPeerRuntime>>> | null = null
+
+    try {
+      const WebPeerRuntime = await lazyWebPeerRuntime()
+      const connection = await WebPeerRuntime.connect(nextMeta, nextPeer)
+      candidateRuntime = connection.runtime
+      await metaAdapter.value.write(nextMeta)
+      metaConfig.value = nextMeta
+      peerConfig.value = nextPeer
+      return candidateRuntime
+    } catch (err) {
+      candidateRuntime?.stop()
+      error.value = err as Error
+      throw err
+    }
+  }
+
   async function resetMeta(): Promise<void> {
-    metaConfig.value = MetaConfigSchema.parse({})
-    peerConfig.value = PeerConfigSchema.parse({})
-    await saveMeta()
+    const resetMetaConfig = MetaConfigSchema.parse({})
+    const resetPeerConfig = PeerConfigSchema.parse({})
+    error.value = null
+    try {
+      await metaAdapter.value.write(resetMetaConfig)
+      metaConfig.value = resetMetaConfig
+      peerConfig.value = resetPeerConfig
+    } catch (err) {
+      error.value = err as Error
+      throw err
+    }
   }
 
   return {
@@ -86,6 +116,7 @@ export const useConfigStore = defineStore('inkcre-config', () => {
     error,
     initializeMeta,
     loadPeerConfig,
+    connectAndSave,
     saveMeta,
     resetMeta,
   }
diff --git a/packages/core/src/extension/host.ts b/packages/core/src/extension/host.ts
index e95e527..5c75eb4 100644
--- a/packages/core/src/extension/host.ts
+++ b/packages/core/src/extension/host.ts
@@ -84,6 +84,14 @@ export class WebExtensionHost {
     return this.runtimeErrors.get(name) ?? null
   }
 
+  isRunning(name: string): boolean {
+    return this.running.has(name)
+  }
+
+  getSetupContribution(name: string) {
+    return this.running.get(name)?.lifecycle.module?.setup ?? null
+  }
+
   async install(input: InstallExtensionInput): Promise<InstalledExtension> {
     const exact = InstallExtensionInputSchema.parse(input)
     return this.exclusively(async () => {
@@ -275,7 +283,7 @@ export class WebExtensionHost {
       )
     }
 
-    const manifestUrl = this.releases.resolveManifestUrl(distribution.manifest_url)
+    const manifestUrl = distribution.manifest_url
     const remoteName = webExtensionRemoteName(installed.name)
     const lifecycle = new WebExtensionLifecycle(async () => {
       const moduleFederation = this.moduleFederation()
@@ -382,6 +390,10 @@ class WebExtensionLifecycle {
 
   constructor(private readonly load: () => Promise<ExtensionModule>) {}
 
+  get module(): ExtensionModule | null {
+    return this.extensionModule
+  }
+
   async start(): Promise<void> {
     if (this.extensionModule) return
 
diff --git a/packages/core/src/extension/index.ts b/packages/core/src/extension/index.ts
index 02fa927..9afb609 100644
--- a/packages/core/src/extension/index.ts
+++ b/packages/core/src/extension/index.ts
@@ -4,6 +4,7 @@ export {
   InstalledExtensionSchema,
   InstallExtensionInputSchema,
   type ExtensionModule,
+  type ExtensionSetupContribution,
   type InstalledExtension,
   type InstallExtensionInput,
 } from './model'
@@ -27,6 +28,13 @@ export {
   type ExtensionReleaseReader,
 } from './registry'
 
+export {
+  DEFAULT_EXTENSION_REGISTRY_ORIGIN,
+  EXTENSION_REGISTRY_CONFIG_KEY,
+  EXTENSION_REGISTRY_CONFIG_SCHEMA,
+  ExtensionRegistryOriginResolver,
+} from './registry-origin'
+
 export type { ExtensionStatePort } from './state'
 
 export { PostgrestExtensionStatePort, ExtensionStatePersistenceError } from './postgrest-state'
diff --git a/packages/core/src/extension/model.ts b/packages/core/src/extension/model.ts
index 0ee97f1..1d635d5 100644
--- a/packages/core/src/extension/model.ts
+++ b/packages/core/src/extension/model.ts
@@ -1,4 +1,5 @@
 import { parse as parseSemVer } from 'semver'
+import type { Component } from 'vue'
 import { z } from 'zod'
 
 const EXTENSION_NAME_PATTERN =
@@ -36,10 +37,16 @@ export const InstallExtensionInputSchema = InstalledExtensionSchema.pick({
 export type InstalledExtension = z.infer<typeof InstalledExtensionSchema>
 export type InstallExtensionInput = z.infer<typeof InstallExtensionInputSchema>
 
+/** Setup UI contributed by one already-running Web Extension. */
+export interface ExtensionSetupContribution {
+  component: Component
+}
+
 /** Default export exposed by a Web Extension's native Module Federation Remote. */
 export interface ExtensionModule {
   initialize?(): Promise<void>
   activate?(): Promise<void>
   deactivate?(): Promise<void>
   dispose?(): Promise<void>
+  setup?: ExtensionSetupContribution
 }
diff --git a/packages/core/src/extension/postgrest-state.ts b/packages/core/src/extension/postgrest-state.ts
index 9f1c90e..edc4a54 100644
--- a/packages/core/src/extension/postgrest-state.ts
+++ b/packages/core/src/extension/postgrest-state.ts
@@ -2,6 +2,9 @@ import { APIError, DBAPIClient } from '../base'
 import { InstalledExtensionSchema, type InstalledExtension } from './model'
 import type { ExtensionStatePort } from './state'
 
+const EXTENSION_MANAGEMENT_PROJECTION =
+  'name,version,enabled,nickname,config,config_schema' as const
+
 export class ExtensionStatePersistenceError extends Error {
   constructor(operation: string, cause?: unknown) {
     super(
@@ -16,13 +19,20 @@ export class PostgrestExtensionStatePort implements ExtensionStatePort {
   private readonly dbApi = new DBAPIClient<'extensions'>('extensions')
 
   async list(): Promise<InstalledExtension[]> {
-    const response = await this.dbApi.from().select().order('name', { ascending: true })
+    const response = await this.dbApi
+      .from()
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
+      .order('name', { ascending: true })
     assertSuccess(response, 'list')
     return InstalledExtensionSchema.array().parse(response.data ?? [])
   }
 
   async get(name: string): Promise<InstalledExtension | null> {
-    const response = await this.dbApi.from().select().eq('name', name).maybeSingle()
+    const response = await this.dbApi
+      .from()
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
+      .eq('name', name)
+      .maybeSingle()
     assertSuccess(response, 'read')
     return response.data === null ? null : InstalledExtensionSchema.parse(response.data)
   }
@@ -48,14 +58,18 @@ export class PostgrestExtensionStatePort implements ExtensionStatePort {
         config: exact.config,
         config_schema: exact.config_schema,
       })
-      .select()
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
       .single()
     assertSuccess(response, 'install')
     return InstalledExtensionSchema.parse(response.data)
   }
 
   async updateConfig(name: string, config: Record<string, unknown>): Promise<InstalledExtension> {
-    const response = await this.dbApi.update({ config }).eq('name', name).select().single()
+    const response = await this.dbApi
+      .update({ config })
+      .eq('name', name)
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
+      .single()
     assertSuccess(response, 'update config')
     return InstalledExtensionSchema.parse(response.data)
   }
@@ -69,7 +83,7 @@ export class PostgrestExtensionStatePort implements ExtensionStatePort {
       .update({ version, nickname, config_schema: null })
       .eq('name', name)
       .filter('enabled', 'eq', '{}')
-      .select()
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
       .maybeSingle()
     assertSuccess(response, 'change version')
     if (response.data === null) {
@@ -86,11 +100,13 @@ export class PostgrestExtensionStatePort implements ExtensionStatePort {
     peerId: string,
     enabled: boolean
   ): Promise<InstalledExtension> {
-    const response = await this.dbApi.rpc('set_extension_peer_enabled', {
-      p_name: name,
-      p_peer_id: peerId,
-      p_enabled: enabled,
-    })
+    const response = await this.dbApi
+      .rpc('set_extension_peer_enabled', {
+        p_name: name,
+        p_peer_id: peerId,
+        p_enabled: enabled,
+      })
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
     assertSuccess(response, enabled ? 'enable Peer' : 'disable Peer')
     const rows = InstalledExtensionSchema.array().parse(response.data ?? [])
     const updated = rows[0]
diff --git a/packages/core/src/extension/registry-origin.test.ts b/packages/core/src/extension/registry-origin.test.ts
new file mode 100644
index 0000000..b9c8b31
--- /dev/null
+++ b/packages/core/src/extension/registry-origin.test.ts
@@ -0,0 +1,71 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  DEFAULT_EXTENSION_REGISTRY_ORIGIN,
+  EXTENSION_REGISTRY_CONFIG_KEY,
+  EXTENSION_REGISTRY_CONFIG_SCHEMA,
+  ExtensionRegistryOriginResolver,
+} from './registry-origin'
+
+function database(result: { data: unknown; error: null | { message: string }; status?: number }) {
+  const maybeSingle = vi.fn(async () => result)
+  const query = {
+    select: vi.fn(() => query),
+    eq: vi.fn(() => query),
+    maybeSingle,
+  }
+  return { from: vi.fn(() => query), query }
+}
+
+describe('ExtensionRegistryOriginResolver', () => {
+  it('uses the current Peer override without reading deployment state', async () => {
+    const db = database({ data: null, error: null })
+    const resolver = new ExtensionRegistryOriginResolver(
+      () => 'https://peer-registry.example/',
+      db as never
+    )
+
+    await expect(resolver.resolve()).resolves.toBe('https://peer-registry.example')
+    expect(db.from).not.toHaveBeenCalled()
+  })
+
+  it('uses the typed deployment config when the Peer has no override', async () => {
+    const db = database({
+      data: {
+        schema: EXTENSION_REGISTRY_CONFIG_SCHEMA,
+        value: { extension_registry_url: 'https://deployment-registry.example/' },
+      },
+      error: null,
+    })
+    const resolver = new ExtensionRegistryOriginResolver(() => '', db as never)
+
+    await expect(resolver.resolve()).resolves.toBe('https://deployment-registry.example')
+    expect(db.query.eq).toHaveBeenCalledWith('key', EXTENSION_REGISTRY_CONFIG_KEY)
+  })
+
+  it('falls back to the public product Registry only when no override exists', async () => {
+    const resolver = new ExtensionRegistryOriginResolver(
+      () => '',
+      database({ data: null, error: null }) as never
+    )
+
+    await expect(resolver.resolve()).resolves.toBe(DEFAULT_EXTENSION_REGISTRY_ORIGIN)
+  })
+
+  it('does not hide a failed deployment-config read behind the product fallback', async () => {
+    const resolver = new ExtensionRegistryOriginResolver(
+      () => '',
+      database({ data: null, error: { message: 'offline' }, status: 503 }) as never
+    )
+
+    await expect(resolver.resolve()).rejects.toThrow('deployment config failed: offline')
+  })
+
+  it('rejects an origin whose authority contains even empty user information', async () => {
+    const resolver = new ExtensionRegistryOriginResolver(
+      () => 'https://@registry.example',
+      database({ data: null, error: null }) as never
+    )
+
+    await expect(resolver.resolve()).rejects.toThrow('one HTTP(S) origin')
+  })
+})
diff --git a/packages/core/src/extension/registry-origin.ts b/packages/core/src/extension/registry-origin.ts
new file mode 100644
index 0000000..f6ee9c4
--- /dev/null
+++ b/packages/core/src/extension/registry-origin.ts
@@ -0,0 +1,66 @@
+import { z } from 'zod'
+import { APIError, DBAPIClient } from '../base'
+
+export const DEFAULT_EXTENSION_REGISTRY_ORIGIN = 'https://registry.inkcre.dev'
+export const EXTENSION_REGISTRY_CONFIG_KEY = 'extension.registry'
+export const EXTENSION_REGISTRY_CONFIG_SCHEMA = 'extension.registry.config.v1'
+
+const RegistryOriginSchema = z.string().transform((value, context) => {
+  try {
+    const hasAuthorityUserInfo = /^[a-z][a-z0-9+.-]*:\/\/[^/?#]*@/i.test(value)
+    const url = new URL(value)
+    if (
+      !['http:', 'https:'].includes(url.protocol) ||
+      hasAuthorityUserInfo ||
+      url.username ||
+      url.password ||
+      url.pathname !== '/' ||
+      url.search ||
+      url.hash
+    ) {
+      throw new Error('not an HTTP(S) origin')
+    }
+    return url.origin
+  } catch {
+    context.addIssue({
+      code: 'custom',
+      message: 'Extension Registry URL must be one HTTP(S) origin.',
+    })
+    return z.NEVER
+  }
+})
+
+const DeploymentRegistryConfigSchema = z.object({
+  schema: z.literal(EXTENSION_REGISTRY_CONFIG_SCHEMA),
+  value: z.object({ extension_registry_url: RegistryOriginSchema }),
+})
+
+/** Resolve one Registry operation from Peer owner, deployment, then product fallback. */
+export class ExtensionRegistryOriginResolver {
+  constructor(
+    private readonly peerOverride: () => string,
+    private readonly database = new DBAPIClient<'configs'>('configs')
+  ) {}
+
+  async resolve(): Promise<string> {
+    const peerOrigin = this.peerOverride()
+    if (peerOrigin) return RegistryOriginSchema.parse(peerOrigin)
+
+    const response = await this.database
+      .from()
+      .select('schema,value')
+      .eq('key', EXTENSION_REGISTRY_CONFIG_KEY)
+      .maybeSingle()
+    if (response.error) {
+      throw new APIError(
+        `Extension Registry deployment config failed: ${response.error.message}`,
+        response.status,
+        response.error
+      )
+    }
+    if (response.data !== null) {
+      return DeploymentRegistryConfigSchema.parse(response.data).value.extension_registry_url
+    }
+    return DEFAULT_EXTENSION_REGISTRY_ORIGIN
+  }
+}
diff --git a/packages/core/src/extension/registry.ts b/packages/core/src/extension/registry.ts
index 77d281a..af5e4d4 100644
--- a/packages/core/src/extension/registry.ts
+++ b/packages/core/src/extension/registry.ts
@@ -33,16 +33,15 @@ export type ModuleFederationDistribution = z.infer<typeof ModuleFederationDistri
 
 export interface ExtensionReleaseReader {
   get(name: string, version: string): Promise<ExtensionRelease>
-  resolveManifestUrl(manifestUrl: string): string
 }
 
 /** Public exact-Release reader for the Registry control plane. */
 export class RegistryExtensionReleaseReader implements ExtensionReleaseReader {
   private readonly fetchImplementation: typeof globalThis.fetch
-  private readonly registryOrigin: () => string
+  private readonly registryOrigin: () => string | Promise<string>
 
   constructor(
-    registryOrigin: string | (() => string),
+    registryOrigin: string | (() => string | Promise<string>),
     fetchImplementation: typeof globalThis.fetch = globalThis.fetch
   ) {
     this.registryOrigin =
@@ -53,7 +52,7 @@ export class RegistryExtensionReleaseReader implements ExtensionReleaseReader {
   async get(name: string, version: string): Promise<ExtensionRelease> {
     const [namespace, localName] = splitExtensionName(ExtensionNameSchema.parse(name))
     const exactVersion = ExtensionVersionSchema.parse(version)
-    const registryUrl = this.registryUrl()
+    const registryUrl = await this.registryUrl()
     const location = new URL(
       `/v1/extensions/${encodeURIComponent(namespace)}/${encodeURIComponent(localName)}/releases/${encodeURIComponent(exactVersion)}`,
       registryUrl
@@ -69,20 +68,20 @@ export class RegistryExtensionReleaseReader implements ExtensionReleaseReader {
     if (release.name !== name || release.version !== exactVersion) {
       throw new Error('Extension Registry returned a different exact Release coordinate.')
     }
-    return release
-  }
-
-  resolveManifestUrl(manifestUrl: string): string {
-    const registryUrl = this.registryUrl()
-    const resolved = new URL(manifestUrl, registryUrl)
-    if (resolved.origin !== registryUrl.origin) {
+    const distribution = release.module_federation
+    if (!distribution) return release
+    const manifest = new URL(distribution.manifest_url, registryUrl)
+    if (manifest.origin !== registryUrl.origin) {
       throw new Error('Module Federation manifest must be hosted by the configured Registry.')
     }
-    return resolved.href
+    return {
+      ...release,
+      module_federation: { ...distribution, manifest_url: manifest.href },
+    }
   }
 
-  private registryUrl(): URL {
-    const registryOrigin = this.registryOrigin()
+  private async registryUrl(): Promise<URL> {
+    const registryOrigin = await this.registryOrigin()
     if (!registryOrigin) {
       throw new Error('Extension Registry URL is not configured.')
     }
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 32179c5..5e30401 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -21,6 +21,7 @@ export {
   InstalledExtensionSchema,
   InstallExtensionInputSchema,
   type ExtensionModule,
+  type ExtensionSetupContribution,
   type InstalledExtension,
   type InstallExtensionInput,
   setMFImplementation,
@@ -33,6 +34,8 @@ export {
   type MFImplementation,
   ExtensionReleaseSchema,
   RegistryExtensionReleaseReader,
+  ExtensionRegistryOriginResolver,
+  DEFAULT_EXTENSION_REGISTRY_ORIGIN,
   type ExtensionRelease,
   type ModuleFederationDistribution,
   type ExtensionReleaseReader,
@@ -51,6 +54,7 @@ export {
 export {
   Peer,
   PeerManager,
+  WebPeerRuntime,
   PeerHTTPOutbound,
   CapabilityDelegationUnavailable,
   PeerOutcomeUnknown,
diff --git a/packages/core/src/peer/index.ts b/packages/core/src/peer/index.ts
index 9f6d5d4..c863147 100644
--- a/packages/core/src/peer/index.ts
+++ b/packages/core/src/peer/index.ts
@@ -2,3 +2,4 @@ export * from './contracts'
 export * from './http'
 export * from './manager'
 export * from './peer'
+export * from './runtime'
diff --git a/packages/core/src/peer/runtime.test.ts b/packages/core/src/peer/runtime.test.ts
new file mode 100644
index 0000000..303800d
--- /dev/null
+++ b/packages/core/src/peer/runtime.test.ts
@@ -0,0 +1,104 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { PeerConfigSchema } from '../config'
+import { WEB_PEER_LEASE_RENEW_INTERVAL_MS, WebPeerRuntime } from './runtime'
+
+const peerId = '00000000-0000-4000-8000-000000000001'
+
+function peerRow(config: Record<string, unknown> = {}) {
+  return {
+    id: peerId,
+    name: 'Client Web',
+    labels: ['owner-label'],
+    config,
+    config_schema: {},
+    capabilities: [],
+    lease_expires_at: '2099-01-01T00:00:00Z',
+    created_at: '2026-01-01T00:00:00Z',
+    updated_at: '2026-01-01T00:00:00Z',
+  }
+}
+
+function database() {
+  const rpc = vi.fn(async (name: string, args: Record<string, unknown>) => {
+    void name
+    void args
+    return { data: '2099-01-01T00:00:00Z', error: null }
+  })
+  const single = vi.fn(async () => ({ data: peerRow(PeerConfigSchema.parse({})), error: null }))
+  const select = vi.fn(() => ({ single }))
+  const eq = vi.fn(() => ({ select }))
+  const update = vi.fn((payload: Record<string, unknown>) => {
+    void payload
+    return { eq }
+  })
+  const upsert = vi.fn((payload: Record<string, unknown>) => {
+    void payload
+    return { select }
+  })
+  return { rpc, update, upsert, eq, select, single }
+}
+
+describe('WebPeerRuntime', () => {
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('upserts only runtime-owned fields and preserves owner-managed labels and config', async () => {
+    const db = database()
+    const runtime = new WebPeerRuntime(peerId, db as never)
+
+    await expect(runtime.register()).resolves.toMatchObject({
+      id: peerId,
+      labels: ['owner-label'],
+      config: {},
+    })
+    expect(db.upsert).toHaveBeenCalledWith({
+      id: peerId,
+      name: 'Client Web',
+      config_schema: expect.any(Object),
+      capabilities: [],
+    })
+    expect(Object.keys(db.upsert.mock.calls[0]?.[0] ?? {})).toEqual([
+      'id',
+      'name',
+      'config_schema',
+      'capabilities',
+    ])
+  })
+
+  it('renews one registered Peer lease and stops browser-owned renewal cleanly', async () => {
+    vi.useFakeTimers()
+    const db = database()
+    const runtime = new WebPeerRuntime(peerId, db as never)
+
+    await runtime.start()
+    expect(db.rpc.mock.calls.map(([name]) => name)).toEqual(['renew_peer_lease'])
+
+    await vi.advanceTimersByTimeAsync(WEB_PEER_LEASE_RENEW_INTERVAL_MS)
+    expect(db.rpc.mock.calls.map(([name]) => name)).toEqual([
+      'renew_peer_lease',
+      'renew_peer_lease',
+    ])
+
+    runtime.stop()
+    await vi.advanceTimersByTimeAsync(WEB_PEER_LEASE_RENEW_INTERVAL_MS)
+    expect(db.rpc).toHaveBeenCalledTimes(2)
+    expect(db.rpc).toHaveBeenNthCalledWith(1, 'renew_peer_lease', {
+      peer: peerId,
+      ttl_seconds: 90,
+    })
+  })
+
+  it('writes only the owner-managed Peer config field', async () => {
+    const db = database()
+    const runtime = new WebPeerRuntime(peerId, db as never)
+    const config = PeerConfigSchema.parse({
+      extension_registry_url: 'https://registry.operator.example',
+    })
+
+    await runtime.saveConfig(config)
+
+    expect(db.update).toHaveBeenCalledWith({ config })
+    expect(db.eq).toHaveBeenCalledWith('id', peerId)
+  })
+})
diff --git a/packages/core/src/peer/runtime.ts b/packages/core/src/peer/runtime.ts
new file mode 100644
index 0000000..bef434c
--- /dev/null
+++ b/packages/core/src/peer/runtime.ts
@@ -0,0 +1,107 @@
+import { z } from 'zod'
+import { signDatabaseToken } from '../auth'
+import { APIError, DBAPIClient } from '../base'
+import {
+  MetaConfigSchema,
+  PeerConfigSchema,
+  type MetaConfig,
+  type PeerConfig,
+} from '../config/schema'
+import { Peer } from './peer'
+
+export const WEB_PEER_LEASE_TTL_SECONDS = 90
+export const WEB_PEER_LEASE_RENEW_INTERVAL_MS = 30_000
+
+type PeerDatabase = DBAPIClient<'peers', Peer>
+
+/** Browser ownership for one durable Peer identity and its database-time lease. */
+export class WebPeerRuntime {
+  private timer: ReturnType<typeof setInterval> | null = null
+  private registered = false
+
+  constructor(
+    readonly peerId: string,
+    private readonly database: PeerDatabase = Peer.dbApi,
+    private readonly warn: (message: string) => void = console.warn
+  ) {}
+
+  async register(): Promise<Peer> {
+    const response = await this.database
+      .upsert({
+        id: this.peerId,
+        name: 'Client Web',
+        config_schema: z.toJSONSchema(PeerConfigSchema),
+        capabilities: [],
+      })
+      .select()
+      .single()
+    assertSuccess(response, 'register')
+    const peer = Peer.parse(response.data)
+    this.registered = true
+    return peer
+  }
+
+  async renew(): Promise<Date> {
+    const response = await this.database.rpc('renew_peer_lease', {
+      peer: this.peerId,
+      ttl_seconds: WEB_PEER_LEASE_TTL_SECONDS,
+    })
+    assertSuccess(response, 'renew lease')
+    return z.coerce.date().parse(response.data)
+  }
+
+  async saveConfig(config: PeerConfig): Promise<Peer> {
+    const response = await this.database
+      .update({ config: PeerConfigSchema.parse(config) })
+      .eq('id', this.peerId)
+      .select()
+      .single()
+    assertSuccess(response, 'save config')
+    return Peer.parse(response.data)
+  }
+
+  async start(): Promise<void> {
+    if (this.timer !== null) return
+    if (!this.registered) await this.register()
+    await this.renew()
+    this.timer = setInterval(() => {
+      void this.renew().catch((error: unknown) => {
+        this.warn(
+          `Web Peer lease renewal failed: ${error instanceof Error ? error.message : String(error)}`
+        )
+      })
+    }, WEB_PEER_LEASE_RENEW_INTERVAL_MS)
+  }
+
+  stop(): void {
+    if (this.timer === null) return
+    clearInterval(this.timer)
+    this.timer = null
+  }
+
+  static async connect(
+    meta: MetaConfig,
+    config: PeerConfig
+  ): Promise<{ peer: Peer; runtime: WebPeerRuntime }> {
+    const exactMeta = MetaConfigSchema.parse(meta)
+    const exactConfig = PeerConfigSchema.parse(config)
+    const database = new DBAPIClient<'peers', Peer>(
+      'peers',
+      Peer,
+      'inkcre',
+      exactMeta.INKCRE_PGREST_URL,
+      () => signDatabaseToken(exactMeta.INKCRE_JWT_SECRET)
+    )
+    const runtime = new WebPeerRuntime(exactMeta.INKCRE_PEER_ID, database)
+    await runtime.register()
+    const peer = await runtime.saveConfig(exactConfig)
+    await runtime.start()
+    return { peer, runtime }
+  }
+}
+
+function assertSuccess(response: { error?: { message: string } | null }, operation: string): void {
+  if (response.error) {
+    throw new APIError(`Web Peer ${operation} failed: ${response.error.message}`, 0, response.error)
+  }
+}
diff --git a/scripts/check-local-runtime-contract.mjs b/scripts/check-local-runtime-contract.mjs
index b6f9a88..e682d38 100644
--- a/scripts/check-local-runtime-contract.mjs
+++ b/scripts/check-local-runtime-contract.mjs
@@ -134,6 +134,8 @@ const reviewedNonEnvironmentUrls = new Set(
     'https://github.com/vueuse/vueuse/blob/658444bf9f8b96118dbd06eba411bb6639e24e88/packages/core/useStorageAsync/index.ts',
     'https://openrouter.ai/api/v1',
     'https://platform.openai.com/api-keys',
+    // Public product infrastructure, not a deployment/runtime environment coordinate.
+    'https://registry.inkcre.dev',
   ].map((value) => new URL(value).href)
 )
 const absoluteUrlPattern = /https?:\/\/[^\s"'`<>),;，）、]+/g

From a59605fe5a601271af069720b101b3a41e992b9f Mon Sep 17 00:00:00 2001
From: Lan_zhijiang <lanzhijiang@foxmail.com>
Date: Mon, 17 Aug 2026 15:07:32 +0800
Subject: [PATCH 2/9] fix(database): apply runtime URL synchronously

- update reactive PostgREST transport before immediate bootstrap queries
- cover config cutover followed by a same-tick database request
---
 packages/core/src/base/db-api.test.ts | 31 +++++++++++++++++++++++++++
 packages/core/src/base/db-api.ts      |  2 +-
 2 files changed, 32 insertions(+), 1 deletion(-)
 create mode 100644 packages/core/src/base/db-api.test.ts

diff --git a/packages/core/src/base/db-api.test.ts b/packages/core/src/base/db-api.test.ts
new file mode 100644
index 0000000..a055a22
--- /dev/null
+++ b/packages/core/src/base/db-api.test.ts
@@ -0,0 +1,31 @@
+import { afterEach, describe, expect, test, vi } from 'vitest'
+import { configStore } from '../config'
+import { DBAPIClient } from './db-api'
+
+describe('DBAPIClient reactive transport', () => {
+  afterEach(() => {
+    configStore.metaConfig.INKCRE_PGREST_URL = ''
+    vi.unstubAllGlobals()
+  })
+
+  test('uses a newly configured PostgREST URL immediately', async () => {
+    const fetch = vi.fn().mockResolvedValue(
+      new Response('[]', {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    )
+    vi.stubGlobal('fetch', fetch)
+    configStore.metaConfig.INKCRE_PGREST_URL = ''
+    const database = new DBAPIClient('peers', undefined, 'inkcre', '', async () => 'test-token')
+
+    configStore.metaConfig.INKCRE_PGREST_URL = 'https://database.example.test///'
+    const response = await database.from().select('id')
+
+    expect(response.error).toBeNull()
+    expect(fetch).toHaveBeenCalledOnce()
+    expect(fetch.mock.calls[0]?.[0].toString()).toBe(
+      'https://database.example.test/peers?select=id'
+    )
+  })
+})
diff --git a/packages/core/src/base/db-api.ts b/packages/core/src/base/db-api.ts
index ec950fb..9d85491 100644
--- a/packages/core/src/base/db-api.ts
+++ b/packages/core/src/base/db-api.ts
@@ -132,7 +132,7 @@ export class DBAPIClient<
         (newVal) => {
           this.url = normalizePostgrestBaseUrl(newVal)
         },
-        { immediate: true }
+        { immediate: true, flush: 'sync' }
       )
     }
   }

From bd2b401a3d3f60bbb72613a8ce7a0ced038de976 Mon Sep 17 00:00:00 2001
From: Lan_zhijiang <lanzhijiang@foxmail.com>
Date: Mon, 17 Aug 2026 20:03:43 +0800
Subject: [PATCH 3/9] ref(twitter): compose setup from web domains

- use fixed OAuth capabilities and ordinary Source, Cron, and Job models
- separate Bookmark Source selection, creation, and scheduling in the wizard
- publish the immutable Web Distribution as 0.2.1
---
 apps/client-web/src/twitter-setup-api.spec.ts |  76 ++-
 extensions/twitter/package.json               |   2 +-
 .../twitterSetupWizard.scss                   |  36 +-
 .../twitterSetupWizard/twitterSetupWizard.vue | 440 +++++++++---------
 extensions/twitter/src/setup-api.ts           | 138 ++++--
 packages/core/package.json                    |   2 +-
 packages/core/src/cron/cron.ts                |  19 +
 7 files changed, 426 insertions(+), 287 deletions(-)

diff --git a/apps/client-web/src/twitter-setup-api.spec.ts b/apps/client-web/src/twitter-setup-api.spec.ts
index 85c1c1b..d9d012e 100644
--- a/apps/client-web/src/twitter-setup-api.spec.ts
+++ b/apps/client-web/src/twitter-setup-api.spec.ts
@@ -1,8 +1,17 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
-import { Peer, PeerManager, type ExtensionStatePort, type InstalledExtension } from '@inkcre/core'
+import {
+  Cron,
+  Peer,
+  PeerManager,
+  Source,
+  SourceForm,
+  type ExtensionStatePort,
+  type InstalledExtension,
+} from '@inkcre/core'
 import {
   discoverCoreCandidates,
   OAuthTransactionSchema,
+  TwitterBookmarkSetup,
   TwitterSetupAPI,
   TwitterSetupStatusSchema,
 } from '../../../extensions/twitter/src/setup-api'
@@ -10,7 +19,7 @@ import {
 const corePeerId = '00000000-0000-4000-8000-000000000002'
 const installed: InstalledExtension = {
   name: 'inkcre/twitter',
-  version: '0.2.0',
+  version: '0.2.1',
   enabled: [corePeerId],
   nickname: 'Twitter',
   config: {},
@@ -28,7 +37,7 @@ const corePeer = Peer.parse({
       inbound: { protocol: 'core.peer.protocol.http.v1', parameters: {} },
     },
     {
-      id: 'inkcre.twitter.setup.v1',
+      id: 'inkcre.twitter.setup.status.v1',
       inbound: { protocol: 'core.peer.protocol.http.v1', parameters: {} },
     },
   ],
@@ -70,20 +79,14 @@ describe('Twitter Peer setup API', () => {
         handle: null,
         scopes: [],
         reconnect_required: false,
-        bookmark_source_id: null,
-        bookmark_cron_id: null,
-        bookmark_sources: [],
-        collect_at: { day_of_week: null, hour: 0, minute: 0 },
-        bookmark_source_ready: false,
-        ready: false,
       },
     })
 
     await new TwitterSetupAPI(corePeer).status()
 
     expect(delegate).toHaveBeenCalledWith(
-      'inkcre.twitter.setup.v1',
-      { body: { action: 'get_status' } },
+      'inkcre.twitter.setup.status.v1',
+      { body: {} },
       corePeerId
     )
   })
@@ -100,12 +103,6 @@ describe('Twitter Peer setup API', () => {
         handle: null,
         scopes: [],
         reconnect_required: false,
-        bookmark_source_id: null,
-        bookmark_cron_id: null,
-        bookmark_sources: [],
-        collect_at: { day_of_week: null, hour: 0, minute: 0 },
-        bookmark_source_ready: false,
-        ready: false,
       })
     ).toThrow('HTTP or HTTPS')
     expect(() =>
@@ -127,4 +124,49 @@ describe('Twitter Peer setup API', () => {
       })
     ).toThrow('embedded credentials')
   })
+
+  it('composes bookmark Source, Cron, and initial Job through ordinary database models', async () => {
+    const source = Source.parse({
+      id: 25,
+      type: 'extensions.twitter.bookmark.Source',
+      nickname: 'Bookmarks',
+      config: {},
+      state: {},
+      storage: null,
+      block: null,
+      created_at: '2026-01-01T00:00:00Z',
+      updated_at: '2026-01-01T00:00:00Z',
+    })
+    const cron = Cron.parse({
+      id: 9,
+      schedule: '30 6 * * *',
+      enabled: false,
+      job_type: 'core.source.collect.v1',
+      job_parameters: { source: 25, config: { full: false, result_limit: 40 } },
+      job_timeout_seconds: null,
+      last_job: null,
+      last_scheduled_for: null,
+      created_at: '2026-01-01T00:00:00Z',
+      updated_at: '2026-01-01T00:00:00Z',
+    })
+    vi.spyOn(Source, 'getAll').mockResolvedValue([source])
+    vi.spyOn(Cron, 'getBySource').mockResolvedValue([cron])
+    vi.spyOn(SourceForm.prototype, 'create').mockResolvedValue(source)
+    const update = vi
+      .spyOn(Cron.prototype, 'update')
+      .mockImplementation(async (form) =>
+        Cron.parse({ ...cron, ...form, id: cron.id, enabled: form.enabled })
+      )
+    const runNow = vi.spyOn(Cron.prototype, 'runNow').mockResolvedValue({} as never)
+
+    await expect(TwitterBookmarkSetup.read()).resolves.toMatchObject({ source, cron })
+    await expect(TwitterBookmarkSetup.createSource('Bookmarks')).resolves.toBe(source)
+    const scheduled = await TwitterBookmarkSetup.saveSchedule(source, 7, 15)
+    expect(update).toHaveBeenLastCalledWith(
+      expect.objectContaining({ schedule: '15 7 * * *', enabled: false })
+    )
+    await TwitterBookmarkSetup.finish(source, scheduled)
+    expect(update).toHaveBeenLastCalledWith(expect.objectContaining({ enabled: true }))
+    expect(runNow).toHaveBeenCalledOnce()
+  })
 })
diff --git a/extensions/twitter/package.json b/extensions/twitter/package.json
index f70ef7f..25f0f93 100644
--- a/extensions/twitter/package.json
+++ b/extensions/twitter/package.json
@@ -36,7 +36,7 @@
     "nickname": "Twitter",
     "module_federation": {
       "host_sdk": "@inkcre/core",
-      "host_sdk_version": ">=0.1.0 <0.2.0"
+      "host_sdk_version": ">=0.1.2 <0.2.0"
     }
   }
 }
diff --git a/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.scss b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.scss
index ec1815c..0c6a1ad 100644
--- a/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.scss
+++ b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.scss
@@ -20,7 +20,7 @@
       display: flex;
       align-items: center;
       gap: 0.4rem;
-      color: #6b7280;
+      color: sys-var(color, text, muted);
       font-size: 0.8rem;
     }
 
@@ -35,7 +35,7 @@
 
     .is-current,
     .is-complete {
-      color: #2563eb;
+      color: sys-var(color, info, base);
       font-weight: 600;
     }
   }
@@ -58,20 +58,36 @@
     }
   }
 
+  &__section,
+  &__empty {
+    display: grid;
+    gap: sys-var(space, sm);
+    padding: sys-var(space, md);
+    border: 1px solid sys-var(color, border, base);
+    background: sys-var(color, surface, subtle);
+
+    h4,
+    p {
+      margin: 0;
+    }
+  }
+
+  &__hint {
+    color: sys-var(color, text, subtle);
+  }
+
   &__field,
   &__schedule label {
     display: grid;
     gap: 0.35rem;
   }
 
-  select,
-  input {
+  &__field input {
     min-height: 2.5rem;
-    padding: 0.5rem;
-    border: 1px solid #d1d5db;
-    border-radius: 0.35rem;
-    background: transparent;
-    color: inherit;
+    padding: sys-var(space, sm);
+    border: 1px solid sys-var(color, border, base);
+    background: sys-var(color, surface, base);
+    color: sys-var(color, text, base);
   }
 
   &__schedule,
@@ -94,7 +110,7 @@
 
   &__error {
     margin: 0;
-    color: #b91c1c;
+    color: sys-var(color, danger, base);
   }
 
   dl {
diff --git a/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.vue b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.vue
index d55f0a1..4ab4bb5 100644
--- a/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.vue
+++ b/extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.vue
@@ -1,8 +1,18 @@
 <script setup lang="ts">
 import { computed, onBeforeUnmount, onMounted, ref, watch } from 'vue'
-import { InkButton, InkInput, InkLoading } from '@inkcre/ui-web'
+import {
+  InkButton,
+  InkDatetimePickerView,
+  InkDropdown,
+  InkInput,
+  InkLoading,
+  InkPicker,
+  type DropdownOption,
+} from '@inkcre/ui-web'
+import type { Cron, Source } from '@inkcre/core'
 import {
   discoverCoreCandidates,
+  TwitterBookmarkSetup,
   TwitterSetupAPI,
   type CorePeerCandidate,
   type OAuthTransaction,
@@ -12,65 +22,97 @@ import { TWITTER_SETUP_STEPS, twitterSetupWizardEmits } from './twitterSetupWiza
 
 const emit = defineEmits(twitterSetupWizardEmits)
 const candidates = ref<CorePeerCandidate[]>([])
-const selectedPeerId = ref<string | null>(null)
+const selectedPeerId = ref<string | number | null>(null)
 const status = ref<TwitterSetupStatus | null>(null)
 const currentStep = ref(0)
 const loading = ref(true)
-const busy = ref(false)
+const pending = ref<string | null>(null)
 const error = ref<string | null>(null)
 const clientId = ref('')
 const clientSecret = ref('')
 const transaction = ref<OAuthTransaction | null>(null)
-const sourceId = ref<number | null>(null)
+const sources = ref<Source[]>([])
+const selectedSourceId = ref<string | number | null>(null)
+const selectedSource = ref<Source | null>(null)
+const selectedCron = ref<Cron | null>(null)
+const creatingSource = ref(false)
 const sourceNickname = ref('Twitter Bookmarks')
-const sourceHour = ref(0)
-const sourceMinute = ref(0)
+const scheduleTime = ref(new Date(2000, 0, 1, 0, 0))
 let polling: AbortController | null = null
 const lifecycle = new AbortController()
 
 const selectedCandidate = computed(
-  () => candidates.value.find((candidate) => candidate.peer.id === selectedPeerId.value) ?? null
+  () => candidates.value.find((item) => item.peer.id === selectedPeerId.value) ?? null
 )
 const api = computed(() =>
   selectedCandidate.value ? new TwitterSetupAPI(selectedCandidate.value.peer) : null
 )
 const selectedCoreEnabled = computed(() => selectedCandidate.value?.enabled ?? false)
+const busy = computed(() => pending.value !== null)
+const setupReady = computed(() =>
+  Boolean(status.value?.connected && selectedSource.value && selectedCron.value?.enabled)
+)
+const peerOptions = computed<DropdownOption[]>(() =>
+  candidates.value.map((item) => ({
+    value: item.peer.id,
+    label: `${item.peer.name}${item.enabled ? ' — enabled' : ''}`,
+  }))
+)
+const sourceOptions = computed<DropdownOption[]>(() => [
+  ...sources.value.map((source) => ({
+    value: source.id,
+    label: source.nickname || `Bookmark Source #${source.id}`,
+  })),
+  { value: 'create', label: 'Create a new Source' },
+])
 
 function message(cause: unknown): string {
   return cause instanceof Error ? cause.message : String(cause)
 }
-
-function deriveStep(next: TwitterSetupStatus): number {
-  if (!next.oauth_app_configured || !next.connected) return 1
-  if (next.bookmark_source_id === null) return 2
-  return 3
+function scheduleFromCron(cron: Cron | null): Date {
+  const [minute = '0', hour = '0'] = cron?.schedule.split(' ') ?? []
+  return new Date(2000, 0, 1, Number(hour), Number(minute))
 }
-
-function applyStatus(next: TwitterSetupStatus): void {
+async function run(operation: string, task: () => Promise<void>): Promise<void> {
+  if (busy.value) return
+  pending.value = operation
+  error.value = null
+  try {
+    await task()
+  } catch (cause) {
+    error.value = message(cause)
+  } finally {
+    pending.value = null
+  }
+}
+async function loadCollection(preferredSourceId?: number | null): Promise<void> {
+  const collection = await TwitterBookmarkSetup.read(preferredSourceId)
+  sources.value = collection.sources
+  selectedSource.value = collection.source
+  selectedSourceId.value = collection.source?.id ?? null
+  selectedCron.value = collection.cron
+  scheduleTime.value = scheduleFromCron(collection.cron)
+  creatingSource.value = collection.sources.length === 0
+}
+async function applyStatus(next: TwitterSetupStatus): Promise<void> {
   status.value = next
   clientId.value = next.client_id ?? ''
   clientSecret.value = ''
-  sourceId.value = next.bookmark_source_id ?? next.bookmark_sources[0]?.source_id ?? null
-  const source = next.bookmark_sources.find((item) => item.source_id === sourceId.value)
-  if (source) sourceNickname.value = source.nickname
-  sourceHour.value = next.collect_at.hour
-  sourceMinute.value = next.collect_at.minute
-  currentStep.value = deriveStep(next)
+  if (next.connected) await loadCollection(selectedSource.value?.id)
+  currentStep.value = !next.oauth_app_configured || !next.connected ? 1 : setupReady.value ? 3 : 2
 }
-
 async function reloadStatus(): Promise<void> {
-  if (!api.value || !selectedCoreEnabled.value) return
-  applyStatus(await api.value.status(lifecycle.signal))
+  if (api.value && selectedCoreEnabled.value)
+    await applyStatus(await api.value.status(lifecycle.signal))
 }
-
 async function initialize(): Promise<void> {
   loading.value = true
   error.value = null
   try {
     candidates.value = await discoverCoreCandidates(lifecycle.signal)
     const selected =
-      candidates.value.find((candidate) => candidate.enabled && candidate.setupAvailable) ??
-      candidates.value.find((candidate) => candidate.enabled) ??
+      candidates.value.find((item) => item.enabled && item.setupAvailable) ??
+      candidates.value.find((item) => item.enabled) ??
       candidates.value[0]
     selectedPeerId.value = selected?.peer.id ?? null
     if (selected?.enabled) await reloadStatus()
@@ -80,7 +122,6 @@ async function initialize(): Promise<void> {
     loading.value = false
   }
 }
-
 watch(selectedPeerId, async (next, previous) => {
   if (next === previous || loading.value) return
   stopPolling()
@@ -88,69 +129,59 @@ watch(selectedPeerId, async (next, previous) => {
   transaction.value = null
   currentStep.value = 0
   error.value = null
-  try {
-    if (selectedCoreEnabled.value) await reloadStatus()
-  } catch (cause) {
-    error.value = message(cause)
+  if (selectedCoreEnabled.value) await run('status', reloadStatus)
+})
+watch(selectedSourceId, async (value) => {
+  if (value === 'create') {
+    creatingSource.value = true
+    selectedSource.value = null
+    selectedCron.value = null
+    return
   }
+  if (typeof value !== 'number') return
+  creatingSource.value = false
+  const collection = await TwitterBookmarkSetup.read(value)
+  selectedSource.value = collection.source
+  selectedCron.value = collection.cron
+  scheduleTime.value = scheduleFromCron(collection.cron)
 })
-
 async function enableSelectedCore(): Promise<void> {
   if (!api.value || !selectedCandidate.value) return
-  busy.value = true
-  error.value = null
-  try {
-    const extension = await api.value.enableCore(lifecycle.signal)
-    selectedCandidate.value.extension = extension
-    selectedCandidate.value.enabled = extension.enabled.includes(selectedCandidate.value.peer.id)
+  await run('enable-core', async () => {
+    const extension = await api.value!.enableCore(lifecycle.signal)
+    selectedCandidate.value!.extension = extension
+    selectedCandidate.value!.enabled = extension.enabled.includes(selectedCandidate.value!.peer.id)
     await reloadStatus()
-  } catch (cause) {
-    error.value = message(cause)
-  } finally {
-    busy.value = false
-  }
+  })
 }
-
 async function saveOAuthApp(): Promise<void> {
   if (!api.value) return
-  busy.value = true
-  error.value = null
-  try {
+  await run('save-oauth-app', async () => {
     try {
-      applyStatus(
-        await api.value.saveOAuthApp(clientId.value, clientSecret.value, false, lifecycle.signal)
+      await applyStatus(
+        await api.value!.saveOAuthApp(clientId.value, clientSecret.value, false, lifecycle.signal)
       )
     } catch (cause) {
-      const causeMessage = message(cause)
-      if (!causeMessage.includes('requires confirmation')) throw cause
-      if (!window.confirm(`${causeMessage}\n\nDisconnect the current account and continue?`)) return
-      applyStatus(
-        await api.value.saveOAuthApp(clientId.value, clientSecret.value, true, lifecycle.signal)
+      const text = message(cause)
+      if (!text.includes('requires confirmation')) throw cause
+      if (!window.confirm(`${text}\n\nDisconnect the current account and continue?`)) return
+      await applyStatus(
+        await api.value!.saveOAuthApp(clientId.value, clientSecret.value, true, lifecycle.signal)
       )
     }
-  } catch (cause) {
-    error.value = message(cause)
-  } finally {
-    busy.value = false
-  }
+  })
 }
-
 function stopPolling(): void {
   polling?.abort()
   polling = null
 }
-
 function close(): void {
   stopPolling()
   emit('close')
 }
-
 async function wait(milliseconds: number, signal: AbortSignal): Promise<void> {
   await new Promise<void>((resolve, reject) => {
-    if (signal.aborted) {
-      reject(new DOMException('Polling cancelled', 'AbortError'))
-      return
-    }
+    if (signal.aborted) return reject(new DOMException('Polling cancelled', 'AbortError'))
     const onAbort = () => {
       window.clearTimeout(timer)
       reject(new DOMException('Polling cancelled', 'AbortError'))
@@ -162,7 +193,6 @@ async function wait(milliseconds: number, signal: AbortSignal): Promise<void> {
     signal.addEventListener('abort', onAbort, { once: true })
   })
 }
-
 async function pollTransaction(id: string): Promise<void> {
   if (!api.value) return
   stopPolling()
@@ -185,75 +215,48 @@ async function pollTransaction(id: string): Promise<void> {
     if (polling === controller) polling = null
   }
 }
-
 async function beginOAuth(): Promise<void> {
   if (!api.value) return
-  busy.value = true
-  error.value = null
-  try {
-    transaction.value = await api.value.beginOAuth(lifecycle.signal)
+  await run('begin-oauth', async () => {
+    transaction.value = await api.value!.beginOAuth(lifecycle.signal)
     void pollTransaction(transaction.value.id)
-  } catch (cause) {
-    error.value = message(cause)
-  } finally {
-    busy.value = false
-  }
+  })
 }
-
 async function disconnect(): Promise<void> {
   if (!api.value) return
-  busy.value = true
-  error.value = null
-  try {
+  await run('disconnect', async () => {
     stopPolling()
     transaction.value = null
-    applyStatus(await api.value.disconnect(lifecycle.signal))
-  } catch (cause) {
-    error.value = message(cause)
-  } finally {
-    busy.value = false
-  }
+    await applyStatus(await api.value!.disconnect(lifecycle.signal))
+  })
 }
-
-async function saveBookmarkSource(): Promise<void> {
-  if (!api.value || busy.value) return
-  busy.value = true
-  error.value = null
-  try {
-    applyStatus(
-      await api.value.configureBookmarkSource(
-        {
-          ...(sourceId.value === null ? {} : { source_id: sourceId.value }),
-          nickname: sourceNickname.value,
-          collect_at: {
-            day_of_week: null,
-            hour: sourceHour.value,
-            minute: sourceMinute.value,
-          },
-        },
-        lifecycle.signal
-      )
+async function createSource(): Promise<void> {
+  await run('create-source', async () => {
+    const source = await TwitterBookmarkSetup.createSource(sourceNickname.value)
+    creatingSource.value = false
+    await loadCollection(source.id)
+  })
+}
+async function saveSchedule(): Promise<void> {
+  if (!selectedSource.value) return
+  await run('save-schedule', async () => {
+    selectedCron.value = await TwitterBookmarkSetup.saveSchedule(
+      selectedSource.value!,
+      scheduleTime.value.getHours(),
+      scheduleTime.value.getMinutes()
     )
-  } catch (cause) {
-    error.value = message(cause)
-  } finally {
-    busy.value = false
-  }
+    currentStep.value = 3
+  })
 }
-
 async function finish(): Promise<void> {
-  if (!api.value || busy.value) return
-  busy.value = true
-  error.value = null
-  try {
-    applyStatus(await api.value.finish(lifecycle.signal))
-  } catch (cause) {
-    error.value = message(cause)
-  } finally {
-    busy.value = false
-  }
+  if (!selectedSource.value || !selectedCron.value) return
+  await run('finish', async () => {
+    selectedCron.value = await TwitterBookmarkSetup.finish(
+      selectedSource.value!,
+      selectedCron.value!
+    )
+  })
 }
-
 onMounted(() => void initialize())
 onBeforeUnmount(() => {
   lifecycle.abort()
@@ -273,67 +276,64 @@ onBeforeUnmount(() => {
         >{{ step }}
       </li>
     </ol>
-
     <div v-if="loading" class="twitter-setup__loading"><InkLoading /></div>
     <template v-else>
       <p v-if="error" class="twitter-setup__error" role="alert">{{ error }}</p>
-
       <div v-if="currentStep === 0" class="twitter-setup__panel">
         <h3>Choose a Core Peer</h3>
-        <p>
-          The setup commands run on a Core Peer, but configure Twitter for the whole deployment.
-        </p>
-        <label v-if="candidates.length" class="twitter-setup__field">
-          Core Peer
-          <select v-model="selectedPeerId">
-            <option
-              v-for="candidate in candidates"
-              :key="candidate.peer.id"
-              :value="candidate.peer.id"
-            >
-              {{ candidate.peer.name }}{{ candidate.enabled ? ' — enabled' : '' }}
-            </option>
-          </select>
-        </label>
-        <p v-else>No live Core Peer exposes Extension management for installed Twitter.</p>
+        <p>The OAuth callback runs on a Core Peer, while setup applies to the deployment.</p>
+        <InkDropdown
+          v-if="candidates.length"
+          v-model="selectedPeerId"
+          :options="peerOptions"
+          label="Core Peer"
+        />
+        <p v-else>No live Core Peer can manage the installed Twitter Extension.</p>
         <InkButton
           v-if="selectedCandidate && !selectedCoreEnabled"
           text="Enable Twitter on this Core Peer"
           theme="primary"
-          :loading="busy"
+          :is-loading="pending === 'enable-core'"
+          :disabled="busy"
           @click="enableSelectedCore"
         />
       </div>
-
       <div v-else-if="currentStep === 1" class="twitter-setup__panel">
         <h3>Connect an X account</h3>
-        <p>
-          Register your own X OAuth 2.0 application and use this callback URL:
-          <code>{{ status?.callback_url }}</code>
-        </p>
-        <InkInput v-model="clientId" label="Client ID" required />
+        <p>Register your own X OAuth 2.0 application with this callback URL:</p>
+        <code>{{ status?.callback_url }}</code>
+        <InkInput v-model="clientId" label="Client ID" required :disabled="busy" />
         <label class="twitter-setup__field">
           Client Secret
-          <input v-model="clientSecret" type="password" autocomplete="off" required />
+          <input
+            v-model="clientSecret"
+            type="password"
+            autocomplete="off"
+            required
+            :disabled="busy"
+          />
         </label>
         <div class="twitter-setup__actions">
           <InkButton
             text="Save OAuth App"
-            :loading="busy"
-            :disabled="!clientId || !clientSecret"
+            :is-loading="pending === 'save-oauth-app'"
+            :disabled="busy || !clientId || !clientSecret"
             @click="saveOAuthApp"
           />
           <InkButton
             v-if="status?.oauth_app_configured"
             text="Create authorization link"
             theme="primary"
-            :loading="busy"
+            :is-loading="pending === 'begin-oauth'"
+            :disabled="busy"
             @click="beginOAuth"
           />
           <InkButton
             v-if="status?.connected"
             text="Disconnect"
             theme="danger"
+            :is-loading="pending === 'disconnect'"
+            :disabled="busy"
             @click="disconnect"
           />
         </div>
@@ -343,82 +343,98 @@ onBeforeUnmount(() => {
           target="_blank"
           rel="noopener noreferrer"
           class="twitter-setup__oauth-link"
+          >Open X authorization</a
         >
-          Open X authorization
-        </a>
         <p v-if="transaction && ['pending', 'exchanging'].includes(transaction.status)">
-          Waiting for the standalone Core callback…
+          Waiting for authorization to return to Core…
         </p>
         <p v-if="status?.connected">Connected as @{{ status.handle }}.</p>
       </div>
-
       <div v-else-if="currentStep === 2" class="twitter-setup__panel">
-        <h3>Choose a Bookmark Source</h3>
-        <label v-if="status?.bookmark_sources.length" class="twitter-setup__field">
-          Existing Source
-          <select v-model="sourceId">
-            <option :value="null">Create a new Source</option>
-            <option
-              v-for="source in status.bookmark_sources"
-              :key="source.source_id"
-              :value="source.source_id"
-            >
-              {{ source.nickname }}
-            </option>
-          </select>
-        </label>
-        <InkInput v-model="sourceNickname" label="Source nickname" :disabled="sourceId !== null" />
-        <div class="twitter-setup__schedule">
-          <label>
-            Daily hour
-            <input
-              v-model.number="sourceHour"
-              type="number"
-              min="0"
-              max="23"
-              :disabled="sourceId !== null"
-            />
-          </label>
-          <label>
-            Minute
-            <input
-              v-model.number="sourceMinute"
-              type="number"
-              min="0"
-              max="59"
-              :disabled="sourceId !== null"
-            />
-          </label>
+        <div>
+          <h3>Set up bookmark collection</h3>
+          <p>Choose an existing Bookmark Source or create one for this deployment.</p>
+        </div>
+        <div v-if="sources.length" class="twitter-setup__section">
+          <h4>Bookmark Source</h4>
+          <InkDropdown
+            v-model="selectedSourceId"
+            :options="sourceOptions"
+            label="Bookmark Source"
+            :disabled="busy"
+          />
+        </div>
+        <div v-else class="twitter-setup__empty">
+          <h4>No Bookmark Sources yet</h4>
+          <p>Create one to store collection cursor and source-specific settings.</p>
+        </div>
+        <div v-if="creatingSource" class="twitter-setup__section">
+          <h4>New Bookmark Source</h4>
+          <p>Give the deployment resource a recognizable nickname.</p>
+          <InkInput v-model="sourceNickname" label="Source nickname" :disabled="busy" />
+          <InkButton
+            text="Create Bookmark Source"
+            :is-loading="pending === 'create-source'"
+            :disabled="busy || !sourceNickname.trim()"
+            @click="createSource"
+          />
+        </div>
+        <div v-if="selectedSource" class="twitter-setup__section">
+          <h4>Collection schedule</h4>
+          <p>Choose when Core should collect bookmarks each day.</p>
+          <InkPicker
+            v-model="scheduleTime"
+            type="time"
+            label="Collect bookmarks daily at"
+            :formatter="
+              (value: Date) => value.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })
+            "
+          >
+            <template #default="{ closePopup }"
+              ><InkDatetimePickerView
+                v-model="scheduleTime"
+                mode="time"
+                hour-format="24" /><InkButton text="Done" theme="primary" @click="closePopup"
+            /></template>
+          </InkPicker>
+          <p class="twitter-setup__hint">Time uses the Core deployment timezone.</p>
+          <InkButton
+            text="Continue"
+            theme="primary"
+            :is-loading="pending === 'save-schedule'"
+            :disabled="busy"
+            @click="saveSchedule"
+          />
         </div>
-        <p v-if="sourceId !== null">Change an existing Source schedule from the Sources page.</p>
-        <InkButton
-          text="Use this Source"
-          theme="primary"
-          :loading="busy"
-          @click="saveBookmarkSource"
-        />
       </div>
-
       <div v-else class="twitter-setup__panel">
-        <h3>{{ status?.ready ? 'Twitter is ready' : 'Review and start' }}</h3>
+        <h3>{{ setupReady ? 'Twitter is ready' : 'Review and start' }}</h3>
+        <p>Confirm the deployment resources before starting bookmark collection.</p>
         <dl>
           <dt>Account</dt>
           <dd>@{{ status?.handle }}</dd>
           <dt>Bookmark Source</dt>
-          <dd>#{{ status?.bookmark_source_id }}</dd>
-          <dt>Initial collection</dt>
-          <dd>{{ status?.bookmark_source_ready ? 'accepted' : 'not started' }}</dd>
+          <dd>{{ selectedSource?.nickname || `#${selectedSource?.id}` }}</dd>
+          <dt>Schedule</dt>
+          <dd>{{ selectedCron?.schedule }}</dd>
         </dl>
-        <InkButton
-          v-if="!status?.ready"
-          text="Start collecting bookmarks"
-          theme="primary"
-          :loading="busy"
-          @click="finish"
-        />
+        <div class="twitter-setup__actions">
+          <InkButton
+            text="Back"
+            theme="subtle"
+            :disabled="busy"
+            @click="currentStep = 2"
+          /><InkButton
+            v-if="!setupReady"
+            text="Start collecting bookmarks"
+            theme="primary"
+            :is-loading="pending === 'finish'"
+            :disabled="busy || !selectedCron"
+            @click="finish"
+          />
+        </div>
       </div>
     </template>
-
     <div class="twitter-setup__toolbar">
       <InkButton text="Close" theme="subtle" @click="close" />
     </div>
diff --git a/extensions/twitter/src/setup-api.ts b/extensions/twitter/src/setup-api.ts
index 0c32749..b25f5b5 100644
--- a/extensions/twitter/src/setup-api.ts
+++ b/extensions/twitter/src/setup-api.ts
@@ -1,9 +1,13 @@
 import {
   InstalledExtensionSchema,
+  Cron,
+  CronForm,
   Peer,
   PeerManager,
   PeerProtocolResponseSchema,
   PostgrestExtensionStatePort,
+  Source,
+  SourceForm,
   type ExtensionStatePort,
   type InstalledExtension,
   type JsonValue,
@@ -12,7 +16,13 @@ import { z } from 'zod'
 
 const EXTENSION_NAME = 'inkcre/twitter'
 const EXTENSION_MANAGEMENT_CAPABILITY = 'core.extension.management.v1'
-const TWITTER_SETUP_CAPABILITY = 'inkcre.twitter.setup.v1'
+const TWITTER_SETUP_STATUS_CAPABILITY = 'inkcre.twitter.setup.status.v1'
+const TWITTER_OAUTH_APP_CONFIGURE_CAPABILITY = 'inkcre.twitter.oauth-app.configure.v1'
+const TWITTER_OAUTH_BEGIN_CAPABILITY = 'inkcre.twitter.oauth.begin.v1'
+const TWITTER_OAUTH_TRANSACTION_READ_CAPABILITY = 'inkcre.twitter.oauth.transaction.read.v1'
+const TWITTER_OAUTH_DISCONNECT_CAPABILITY = 'inkcre.twitter.oauth.disconnect.v1'
+const BOOKMARK_SOURCE_TYPE = 'extensions.twitter.bookmark.Source'
+const SOURCE_COLLECT_JOB_TYPE = 'core.source.collect.v1'
 
 function hasAuthorityUserInfo(value: string): boolean {
   return /^[a-z][a-z0-9+.-]*:\/\/[^/?#]*@/i.test(value)
@@ -30,17 +40,6 @@ const HttpsUrlSchema = z
     'Authorization URL must use HTTPS without embedded credentials.'
   )
 
-const CollectAtSchema = z.object({
-  day_of_week: z.number().int().min(0).max(6).nullable(),
-  hour: z.number().int().min(0).max(23),
-  minute: z.number().int().min(0).max(59),
-})
-
-const BookmarkSourceSchema = z.object({
-  source_id: z.number().int().positive(),
-  nickname: z.string(),
-})
-
 export const TwitterSetupStatusSchema = z.object({
   backend: z.string(),
   callback_url: HttpUrlSchema,
@@ -51,12 +50,6 @@ export const TwitterSetupStatusSchema = z.object({
   handle: z.string().nullable(),
   scopes: z.array(z.string()),
   reconnect_required: z.boolean(),
-  bookmark_source_id: z.number().int().positive().nullable(),
-  bookmark_cron_id: z.number().int().positive().nullable(),
-  bookmark_sources: z.array(BookmarkSourceSchema),
-  collect_at: CollectAtSchema,
-  bookmark_source_ready: z.boolean(),
-  ready: z.boolean(),
 })
 
 export const OAuthTransactionSchema = z.object({
@@ -99,7 +92,7 @@ export async function discoverCoreCandidates(
       peer,
       extension,
       enabled: extension.enabled.includes(peer.id),
-      setupAvailable: advertises(peer, TWITTER_SETUP_CAPABILITY),
+      setupAvailable: advertises(peer, TWITTER_SETUP_STATUS_CAPABILITY),
     }))
 }
 
@@ -117,7 +110,13 @@ export class TwitterSetupAPI {
   }
 
   status(signal?: AbortSignal): Promise<TwitterSetupStatus> {
-    return this.setup({ action: 'get_status' }, TwitterSetupStatusSchema, signal)
+    return executeCapability(
+      this.peer,
+      TWITTER_SETUP_STATUS_CAPABILITY,
+      {},
+      TwitterSetupStatusSchema,
+      signal
+    )
   }
 
   saveOAuthApp(
@@ -126,9 +125,10 @@ export class TwitterSetupAPI {
     confirmAccountReset: boolean,
     signal?: AbortSignal
   ): Promise<TwitterSetupStatus> {
-    return this.setup(
+    return executeCapability(
+      this.peer,
+      TWITTER_OAUTH_APP_CONFIGURE_CAPABILITY,
       {
-        action: 'save_oauth_app',
         client_id: clientId,
         client_secret: clientSecret,
         confirm_account_reset: confirmAccountReset,
@@ -139,46 +139,92 @@ export class TwitterSetupAPI {
   }
 
   beginOAuth(signal?: AbortSignal): Promise<OAuthTransaction> {
-    return this.setup({ action: 'begin_oauth' }, OAuthTransactionSchema, signal)
+    return executeCapability(
+      this.peer,
+      TWITTER_OAUTH_BEGIN_CAPABILITY,
+      {},
+      OAuthTransactionSchema,
+      signal
+    )
   }
 
   oauthTransaction(transactionId: string, signal?: AbortSignal): Promise<OAuthTransaction> {
-    return this.setup(
-      { action: 'get_oauth_transaction', transaction_id: transactionId },
+    return executeCapability(
+      this.peer,
+      TWITTER_OAUTH_TRANSACTION_READ_CAPABILITY,
+      { transaction_id: transactionId },
       OAuthTransactionSchema,
       signal
     )
   }
 
   disconnect(signal?: AbortSignal): Promise<TwitterSetupStatus> {
-    return this.setup({ action: 'disconnect_account' }, TwitterSetupStatusSchema, signal)
-  }
-
-  configureBookmarkSource(
-    input: {
-      source_id?: number
-      nickname: string
-      collect_at: { day_of_week: number | null; hour: number; minute: number }
-    },
-    signal?: AbortSignal
-  ): Promise<TwitterSetupStatus> {
-    return this.setup(
-      { action: 'configure_bookmark_source', ...input },
+    return executeCapability(
+      this.peer,
+      TWITTER_OAUTH_DISCONNECT_CAPABILITY,
+      {},
       TwitterSetupStatusSchema,
       signal
     )
   }
+}
+
+export interface BookmarkCollectionSetup {
+  sources: Source[]
+  source: Source | null
+  cron: Cron | null
+}
+
+export class TwitterBookmarkSetup {
+  static async read(sourceId?: number | null): Promise<BookmarkCollectionSetup> {
+    const sources = (await Source.getAll()).filter((source) => source.type === BOOKMARK_SOURCE_TYPE)
+    const source =
+      sources.find((candidate) => candidate.id === sourceId) ??
+      (sourceId == null && sources.length === 1 ? sources[0]! : null)
+    const crons = source ? await Cron.getBySource(source.id) : []
+    const cron =
+      crons.find(
+        (candidate) =>
+          candidate.job_type === SOURCE_COLLECT_JOB_TYPE &&
+          candidate.job_parameters.source === source?.id
+      ) ?? null
+    return { sources, source, cron }
+  }
 
-  finish(signal?: AbortSignal): Promise<TwitterSetupStatus> {
-    return this.setup({ action: 'finish' }, TwitterSetupStatusSchema, signal)
+  static async createSource(nickname: string): Promise<Source> {
+    return new SourceForm({
+      type: BOOKMARK_SOURCE_TYPE,
+      nickname,
+      config: {},
+      state: {},
+      storage: null,
+    }).create()
   }
 
-  private setup<Result>(
-    command: JsonValue,
-    schema: z.ZodType<Result>,
-    signal?: AbortSignal
-  ): Promise<Result> {
-    return executeCapability(this.peer, TWITTER_SETUP_CAPABILITY, command, schema, signal)
+  static async saveSchedule(source: Source, hour: number, minute: number): Promise<Cron> {
+    const current = await this.read(source.id)
+    const form = new CronForm({
+      schedule: `${minute} ${hour} * * *`,
+      enabled: current.cron?.enabled ?? false,
+      job_type: SOURCE_COLLECT_JOB_TYPE,
+      job_parameters: { source: source.id, config: { full: false, result_limit: 40 } },
+      job_timeout_seconds: current.cron?.job_timeout_seconds ?? null,
+    })
+    return current.cron ? current.cron.update(form) : form.create()
+  }
+
+  static async finish(source: Source, cron: Cron): Promise<Cron> {
+    const enabled = await cron.update(
+      new CronForm({
+        schedule: cron.schedule,
+        enabled: true,
+        job_type: SOURCE_COLLECT_JOB_TYPE,
+        job_parameters: { source: source.id, config: { full: false, result_limit: 40 } },
+        job_timeout_seconds: cron.job_timeout_seconds,
+      })
+    )
+    await enabled.runNow()
+    return enabled
   }
 }
 
diff --git a/packages/core/package.json b/packages/core/package.json
index a0271c0..fc6d45a 100644
--- a/packages/core/package.json
+++ b/packages/core/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@inkcre/core",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "files": [
     "dist"
   ],
diff --git a/packages/core/src/cron/cron.ts b/packages/core/src/cron/cron.ts
index a47bc70..3642f62 100644
--- a/packages/core/src/cron/cron.ts
+++ b/packages/core/src/cron/cron.ts
@@ -42,6 +42,25 @@ export class Cron extends Z.class({
     )
   }
 
+  async update(form: CronForm): Promise<Cron> {
+    return Cron.parse(
+      (
+        await Cron.dbApi
+          .from()
+          .update({
+            schedule: form.schedule,
+            enabled: form.enabled,
+            job_type: form.job_type,
+            job_parameters: form.job_parameters as never,
+            job_timeout_seconds: form.job_timeout_seconds,
+          })
+          .eq('id', this.id)
+          .select()
+          .single()
+      ).data
+    )
+  }
+
   async delete(): Promise<void> {
     await Cron.dbApi.from().delete().eq('id', this.id)
   }

From 230edcdf61e22d1e536de47575648a43f0281fcc Mon Sep 17 00:00:00 2001
From: Lan_zhijiang <lanzhijiang@foxmail.com>
Date: Mon, 24 Aug 2026 10:52:40 +0800
Subject: [PATCH 4/9] =?UTF-8?q?ref(extension):=20=E5=88=87=E6=8D=A2?=
 =?UTF-8?q?=E8=87=B3=E7=8B=AC=E7=AB=8B=20Web=20Runtime?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 由 Client Web 组合 Registry、Module Federation 与 Extension manager
- 通过已发布 tgz 接入 Runtime 0.1.0 并提升 Host SDK 至 0.1.2
- 适配精确 Peer 启停并保留 Twitter setup popup
---
 apps/client-web/package.json                  |   1 +
 .../extensionCard/extensionCard.spec.ts       | 113 -----
 .../extension/extensionCard/extensionCard.vue |   6 +-
 apps/client-web/src/core.ts                   |  73 ++-
 .../src/extension-peer-control.spec.ts        | 106 -----
 apps/client-web/src/extension-peer-control.ts |  17 +-
 apps/client-web/src/twitter-setup-api.spec.ts | 172 -------
 .../src/twitter-setup-wizard.spec.ts          |  91 ----
 .../src/views/extensions/extensions.spec.ts   | 122 -----
 .../src/views/extensions/extensions.vue       |   5 +-
 .../src/views/settings/settings.spec.ts       | 140 ------
 extensions/twitter/src/setup-api.ts           |  13 +-
 packages/core/src/auth/store.ts               |  33 +-
 packages/core/src/base/db-api.test.ts         |  31 --
 packages/core/src/config/store.test.ts        |  82 ----
 packages/core/src/extension/host.ts           | 443 ------------------
 packages/core/src/extension/index.ts          |  35 +-
 packages/core/src/extension/model.ts          | 178 +++++++
 .../core/src/extension/module-federation.ts   |  78 ---
 .../core/src/extension/postgrest-state.ts     | 147 ------
 .../src/extension/registry-origin.test.ts     |  71 ---
 packages/core/src/extension/registry.ts       |  95 ----
 packages/core/src/extension/state.ts          |  15 -
 packages/core/src/index.ts                    |  25 +-
 packages/core/src/peer/runtime.test.ts        | 104 ----
 pnpm-lock.yaml                                |  22 +
 26 files changed, 276 insertions(+), 1942 deletions(-)
 delete mode 100644 apps/client-web/src/components/extension/extensionCard/extensionCard.spec.ts
 delete mode 100644 apps/client-web/src/extension-peer-control.spec.ts
 delete mode 100644 apps/client-web/src/twitter-setup-api.spec.ts
 delete mode 100644 apps/client-web/src/twitter-setup-wizard.spec.ts
 delete mode 100644 apps/client-web/src/views/extensions/extensions.spec.ts
 delete mode 100644 apps/client-web/src/views/settings/settings.spec.ts
 delete mode 100644 packages/core/src/base/db-api.test.ts
 delete mode 100644 packages/core/src/config/store.test.ts
 delete mode 100644 packages/core/src/extension/host.ts
 delete mode 100644 packages/core/src/extension/module-federation.ts
 delete mode 100644 packages/core/src/extension/postgrest-state.ts
 delete mode 100644 packages/core/src/extension/registry-origin.test.ts
 delete mode 100644 packages/core/src/extension/registry.ts
 delete mode 100644 packages/core/src/extension/state.ts
 delete mode 100644 packages/core/src/peer/runtime.test.ts

diff --git a/apps/client-web/package.json b/apps/client-web/package.json
index 9366445..5f75d06 100644
--- a/apps/client-web/package.json
+++ b/apps/client-web/package.json
@@ -18,6 +18,7 @@
     "@codemirror/state": "^6.5.2",
     "@codemirror/view": "^6.38.8",
     "@inkcre/core": "workspace:*",
+    "@inkcre/extension-runtime-client-web": "https://github.com/InKCre/ext-reg/releases/download/runtime-client-web-v0.1.0/inkcre-extension-runtime-client-web-0.1.0.tgz",
     "@inkcre/ui-web": "1.4.0",
     "@module-federation/runtime": "^0.21.4",
     "@supabase/postgrest-js": "^2.84.0",
diff --git a/apps/client-web/src/components/extension/extensionCard/extensionCard.spec.ts b/apps/client-web/src/components/extension/extensionCard/extensionCard.spec.ts
deleted file mode 100644
index e8a604c..0000000
--- a/apps/client-web/src/components/extension/extensionCard/extensionCard.spec.ts
+++ /dev/null
@@ -1,113 +0,0 @@
-import { defineComponent } from 'vue'
-import { flushPromises, mount } from '@vue/test-utils'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import ExtensionCard from './extensionCard.vue'
-
-const SetupComponent = defineComponent({
-  template: '<p data-test="twitter-setup">Twitter setup</p>',
-})
-const host = {
-  getSetupContribution: vi.fn((): { component: typeof SetupComponent } | null => ({
-    component: SetupComponent,
-  })),
-  changeVersion: vi.fn(),
-  updateConfig: vi.fn(),
-  uninstall: vi.fn(),
-}
-
-vi.mock('@/core', () => ({ getExtensionHost: () => host }))
-vi.mock('vue-i18n', () => ({ useI18n: () => ({ t: (key: string) => key }) }))
-
-const extension = {
-  name: 'inkcre/twitter',
-  version: '0.2.0',
-  enabled: ['00000000-0000-4000-8000-000000000001'],
-  nickname: 'Twitter',
-  config: {},
-  config_schema: null,
-}
-
-const stubs = {
-  InkButton: defineComponent({
-    props: ['text'],
-    emits: ['click'],
-    template: '<button @click="$emit(\'click\')">{{ text }}</button>',
-  }),
-  InkSwitch: defineComponent({
-    props: ['modelValue'],
-    emits: ['update:modelValue'],
-    template: '<button data-test="switch" @click="$emit(\'update:modelValue\', false)" />',
-  }),
-  InkDialog: defineComponent({ template: '<section><slot /></section>' }),
-  InkInput: true,
-  InkJsonEditor: true,
-}
-
-describe('ExtensionCard setup contribution', () => {
-  beforeEach(() => vi.clearAllMocks())
-
-  it('mounts setup from the current Web runtime independently of selected Client state', async () => {
-    const wrapper = mount(ExtensionCard, {
-      props: {
-        extension,
-        enabled: false,
-        controlsCurrentWebRuntime: false,
-        setEnabled: vi.fn(async () => ({ ...extension, enabled: [] })),
-      },
-      global: { stubs },
-    })
-
-    const setup = wrapper.findAll('button').find((button) => button.text() === 'extension.setup')
-    expect(setup).toBeDefined()
-    await setup?.trigger('click')
-
-    expect(host.getSetupContribution).toHaveBeenCalledWith('inkcre/twitter')
-    expect(wrapper.get('[data-test="twitter-setup"]').text()).toBe('Twitter setup')
-  })
-
-  it('does not offer setup without a running Web contribution', () => {
-    host.getSetupContribution.mockReturnValueOnce(null)
-    const wrapper = mount(ExtensionCard, {
-      props: {
-        extension: { ...extension, enabled: [] },
-        enabled: false,
-        controlsCurrentWebRuntime: false,
-        setEnabled: vi.fn(async () => ({ ...extension, enabled: [] })),
-      },
-      global: { stubs },
-    })
-
-    expect(wrapper.text()).not.toContain('extension.setup')
-  })
-
-  it('unmounts contributed setup before disabling its current Web runtime', async () => {
-    const setEnabled = vi.fn(async () => {
-      expect(wrapper.find('[data-test="twitter-setup"]').exists()).toBe(false)
-      return { ...extension, enabled: [] }
-    })
-    const wrapper = mount(ExtensionCard, {
-      props: { extension, enabled: true, controlsCurrentWebRuntime: true, setEnabled },
-      global: { stubs },
-    })
-    const setup = wrapper.findAll('button').find((button) => button.text() === 'extension.setup')
-    await setup?.trigger('click')
-    await wrapper.get('[data-test="switch"]').trigger('click')
-    await flushPromises()
-
-    expect(setEnabled).toHaveBeenCalledWith(false)
-  })
-
-  it('keeps current Web setup mounted when controlling another selected Client', async () => {
-    const setEnabled = vi.fn(async () => ({ ...extension, enabled: [] }))
-    const wrapper = mount(ExtensionCard, {
-      props: { extension, enabled: true, controlsCurrentWebRuntime: false, setEnabled },
-      global: { stubs },
-    })
-    const setup = wrapper.findAll('button').find((button) => button.text() === 'extension.setup')
-    await setup?.trigger('click')
-    await wrapper.get('[data-test="switch"]').trigger('click')
-    await flushPromises()
-
-    expect(wrapper.find('[data-test="twitter-setup"]').exists()).toBe(true)
-  })
-})
diff --git a/apps/client-web/src/components/extension/extensionCard/extensionCard.vue b/apps/client-web/src/components/extension/extensionCard/extensionCard.vue
index 2f9bd6b..ae5aab3 100644
--- a/apps/client-web/src/components/extension/extensionCard/extensionCard.vue
+++ b/apps/client-web/src/components/extension/extensionCard/extensionCard.vue
@@ -2,7 +2,7 @@
 import { ref, computed, nextTick, shallowRef, watch, type Component } from 'vue'
 import { useI18n } from 'vue-i18n'
 import { InkButton, InkSwitch, InkDialog, InkInput, InkJsonEditor } from '@inkcre/ui-web'
-import { getExtensionHost } from '@/core'
+import { getExtensionHost, getExtensionSetupContribution } from '@/core'
 import { extensionCardProps, extensionCardEmits } from './extensionCard'
 
 const props = defineProps(extensionCardProps)
@@ -14,7 +14,7 @@ const configPopupOpen = ref<boolean | Promise<boolean>>(false)
 const versionPopupOpen = ref<boolean | Promise<boolean>>(false)
 const setupPopupOpen = ref(false)
 const setupComponent = shallowRef<Component | null>(null)
-const setupContribution = shallowRef(getExtensionHost().getSetupContribution(props.extension.name))
+const setupContribution = shallowRef(getExtensionSetupContribution(props.extension.name))
 const togglePromise = ref<Promise<boolean> | null>(null)
 const isUninstalling = ref(false)
 const operationError = ref<string | null>(null)
@@ -51,7 +51,7 @@ const toggleModel = computed({
         operationError.value = error instanceof Error ? error.message : String(error)
         return props.enabled
       } finally {
-        setupContribution.value = getExtensionHost().getSetupContribution(props.extension.name)
+        setupContribution.value = getExtensionSetupContribution(props.extension.name)
         togglePromise.value = null
       }
     })()
diff --git a/apps/client-web/src/core.ts b/apps/client-web/src/core.ts
index b8e8964..0122685 100644
--- a/apps/client-web/src/core.ts
+++ b/apps/client-web/src/core.ts
@@ -8,11 +8,7 @@
 import {
   configStore,
   ExtensionRegistryOriginResolver,
-  getMFImplementation,
   localStorageAdapter,
-  PostgrestExtensionStatePort,
-  RegistryExtensionReleaseReader,
-  setMFImplementation,
   registerCoreResolvers,
   TextResolver,
   AudioResolver,
@@ -26,10 +22,15 @@ import {
   PeerManager,
   WebPeerRuntime,
   JobManager,
-  WebExtensionHost,
-  type ExtensionStatePort,
+  type ExtensionModule,
+  type ExtensionSetupContribution,
 } from '@inkcre/core'
-import { createInstance } from '@module-federation/enhanced/runtime'
+import { createInstance } from '@module-federation/runtime'
+import {
+  ExtensionManager,
+  RegistryReleaseReader,
+  type WebExtensionModule,
+} from '@inkcre/extension-runtime-client-web'
 import * as InKCreCore from '@inkcre/core'
 import * as Zod from 'zod'
 import * as Vue from 'vue'
@@ -80,36 +81,34 @@ export function setupResolvers(): void {
 // Configuration
 // ============================================================================
 
-let extensionHost: WebExtensionHost | null = null
+type ClientExtensionModule = WebExtensionModule & ExtensionModule
+type ClientExtensionManager = ExtensionManager<ClientExtensionModule>
+
+let extensionHost: ClientExtensionManager | null = null
 let extensionHostStartup: Promise<void> | null = null
-let extensionState: ExtensionStatePort | null = null
+let moduleFederation: ReturnType<typeof createInstance> | null = null
 let webPeerRuntime: WebPeerRuntime | null = null
 
-export function initializeExtensionHost(state: ExtensionStatePort): WebExtensionHost {
+export function initializeExtensionHost(): ClientExtensionManager {
   extensionHostStartup = null
-  extensionState = state
   const registryOrigin = new ExtensionRegistryOriginResolver(
     () => configStore.peerConfig.extension_registry_url
   )
-  extensionHost = new WebExtensionHost({
-    state,
-    releases: new RegistryExtensionReleaseReader(() => registryOrigin.resolve()),
-    moduleFederation: getMFImplementation,
-    currentPeerId: () => configStore.metaConfig.INKCRE_PEER_ID,
-    hostSdkVersion: corePackageJson.version,
+  if (!moduleFederation) throw new Error('Module Federation has not been initialized.')
+  extensionHost = new ExtensionManager<ClientExtensionModule>({
+    releases: new RegistryReleaseReader({
+      registryOrigin: () => registryOrigin.resolve(),
+      hostSdk: { name: '@inkcre/core', version: corePackageJson.version },
+    }),
+    moduleFederation,
   })
   return extensionHost
 }
 
-export function getExtensionState(): ExtensionStatePort {
-  if (!extensionState) throw new Error('Web Extension state port has not been initialized.')
-  return extensionState
-}
-
 /** Share one initial runtime restore across the app shell and management view. */
 export function startExtensionHost(): Promise<void> {
   if (extensionHostStartup) return extensionHostStartup
-  const startup = getExtensionHost().startup()
+  const startup = getExtensionHost().startup(configStore.metaConfig.INKCRE_PEER_ID)
   extensionHostStartup = startup.catch((error: unknown) => {
     extensionHostStartup = null
     throw error
@@ -117,13 +116,18 @@ export function startExtensionHost(): Promise<void> {
   return extensionHostStartup
 }
 
-export function getExtensionHost(): WebExtensionHost {
+export function getExtensionHost(): ClientExtensionManager {
   if (!extensionHost) {
     throw new Error('Web Extension Host state port has not been initialized.')
   }
   return extensionHost
 }
 
+/** Project the running native module into the Client-owned setup popup contract. */
+export function getExtensionSetupContribution(name: string): ExtensionSetupContribution | null {
+  return getExtensionHost().getModule(name)?.setup ?? null
+}
+
 /** Replace the browser-owned lease runtime after a validated Settings cutover. */
 export function adoptWebPeerRuntime(runtime: WebPeerRuntime): void {
   webPeerRuntime?.stop()
@@ -154,10 +158,10 @@ export async function startConfiguredWebPeerRuntime(): Promise<void> {
 
 /**
  * Initialize Module Federation runtime.
- * Creates the MF instance and injects it into core.
+ * Creates the MF instance consumed by the application-owned Extension manager.
  */
 export function initializeModuleFederation(): void {
-  const mfInstance = createInstance({
+  moduleFederation = createInstance({
     name: 'host',
     remotes: [],
     shared: {
@@ -212,21 +216,6 @@ export function initializeModuleFederation(): void {
     },
   })
 
-  // Inject MF implementation into core
-  const mfImpl = {
-    registerRemotes: (
-      remotes: Array<{ name: string; entry: string; type?: 'module' | 'script' }>,
-      options?: { force?: boolean }
-    ) => {
-      mfInstance.registerRemotes(remotes, options)
-    },
-    loadRemote: async <T>(remoteName: string): Promise<T | null> => {
-      return mfInstance.loadRemote<T>(remoteName)
-    },
-  }
-
-  setMFImplementation(mfImpl)
-
   console.log('[Core] Module Federation initialized')
 }
 
@@ -266,7 +255,7 @@ export async function initializeCore(options: { loadPeerConfig?: boolean } = {})
   JobManager.startWorker()
   setupResolvers()
   initializeModuleFederation()
-  initializeExtensionHost(new PostgrestExtensionStatePort())
+  initializeExtensionHost()
   if (webPeerRuntime) await webPeerRuntime.start()
   console.log('[Core] Initialization complete')
 }
diff --git a/apps/client-web/src/extension-peer-control.spec.ts b/apps/client-web/src/extension-peer-control.spec.ts
deleted file mode 100644
index fa9d293..0000000
--- a/apps/client-web/src/extension-peer-control.spec.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import {
-  Peer,
-  PeerManager,
-  type ExtensionStatePort,
-  type InstalledExtension,
-  type WebExtensionHost,
-} from '@inkcre/core'
-import {
-  EXTENSION_MANAGEMENT_CAPABILITY,
-  extensionPeerControlMode,
-  setExtensionPeerEnabled,
-} from './extension-peer-control'
-
-const currentPeerId = '00000000-0000-4000-8000-000000000001'
-const remotePeerId = '00000000-0000-4000-8000-000000000002'
-const installed: InstalledExtension = {
-  name: 'inkcre/twitter',
-  version: '0.2.0',
-  enabled: [],
-  nickname: 'Twitter',
-  config: {},
-  config_schema: null,
-}
-
-function peer(id: string, options: { live?: boolean; management?: boolean } = {}): Peer {
-  return Peer.parse({
-    id,
-    name: 'Client',
-    labels: [],
-    config: {},
-    config_schema: {},
-    capabilities: options.management
-      ? [
-          {
-            id: EXTENSION_MANAGEMENT_CAPABILITY,
-            inbound: { protocol: 'core.peer.protocol.http.v1', parameters: {} },
-          },
-        ]
-      : [],
-    lease_expires_at: options.live === false ? new Date(0) : new Date('2099-01-01'),
-    created_at: new Date('2026-01-01'),
-    updated_at: new Date('2026-01-01'),
-  })
-}
-
-describe('Extension Peer control', () => {
-  afterEach(() => vi.restoreAllMocks())
-
-  it('uses the local Web Host for this browser Client', async () => {
-    const enable = vi.fn(async () => ({ ...installed, enabled: [currentPeerId] }))
-    const state = { setPeerEnabled: vi.fn() }
-
-    await expect(
-      setExtensionPeerEnabled({
-        name: installed.name,
-        peer: peer(currentPeerId),
-        currentPeerId,
-        enabled: true,
-        webHost: { enable } as never,
-        state: state as never,
-      })
-    ).resolves.toMatchObject({ enabled: [currentPeerId] })
-    expect(enable).toHaveBeenCalledWith(installed.name)
-    expect(state.setPeerEnabled).not.toHaveBeenCalled()
-  })
-
-  it('delegates to an exact live Client that advertises runtime management', async () => {
-    const delegate = vi.spyOn(PeerManager, 'delegate').mockResolvedValue({
-      status: 200,
-      body: { ...installed, enabled: [remotePeerId] },
-    } as never)
-
-    await setExtensionPeerEnabled({
-      name: installed.name,
-      peer: peer(remotePeerId, { management: true }),
-      currentPeerId,
-      enabled: true,
-      webHost: {} as WebExtensionHost,
-      state: {} as ExtensionStatePort,
-    })
-
-    expect(delegate).toHaveBeenCalledWith(
-      EXTENSION_MANAGEMENT_CAPABILITY,
-      { body: { action: 'enable', extension: installed.name } },
-      remotePeerId
-    )
-  })
-
-  it('updates durable desired state for any Client without a live management endpoint', async () => {
-    const target = peer(remotePeerId, { live: false })
-    const setPeerEnabled = vi.fn(async () => ({ ...installed, enabled: [remotePeerId] }))
-
-    expect(extensionPeerControlMode(target, currentPeerId)).toBe('desired-state')
-    await setExtensionPeerEnabled({
-      name: installed.name,
-      peer: target,
-      currentPeerId,
-      enabled: true,
-      webHost: {} as WebExtensionHost,
-      state: { setPeerEnabled } as unknown as ExtensionStatePort,
-    })
-
-    expect(setPeerEnabled).toHaveBeenCalledWith(installed.name, remotePeerId, true)
-  })
-})
diff --git a/apps/client-web/src/extension-peer-control.ts b/apps/client-web/src/extension-peer-control.ts
index 637a93d..9fe5080 100644
--- a/apps/client-web/src/extension-peer-control.ts
+++ b/apps/client-web/src/extension-peer-control.ts
@@ -1,12 +1,12 @@
 import {
   InstalledExtensionSchema,
+  ExtensionModel,
   Peer,
   PeerManager,
   PeerProtocolResponseSchema,
-  type ExtensionStatePort,
   type InstalledExtension,
-  type WebExtensionHost,
 } from '@inkcre/core'
+import type { ExtensionManager } from '@inkcre/extension-runtime-client-web'
 
 export const EXTENSION_MANAGEMENT_CAPABILITY = 'core.extension.management.v1'
 export type ExtensionPeerControlMode = 'current-runtime' | 'remote-host' | 'desired-state'
@@ -35,15 +35,20 @@ export async function setExtensionPeerEnabled(input: {
   peer: Peer
   currentPeerId: string
   enabled: boolean
-  webHost: WebExtensionHost
-  state: ExtensionStatePort
+  manager: ExtensionManager
 }): Promise<InstalledExtension> {
   const mode = extensionPeerControlMode(input.peer, input.currentPeerId)
   if (mode === 'current-runtime') {
-    return input.enabled ? input.webHost.enable(input.name) : input.webHost.disable(input.name)
+    return input.enabled
+      ? input.manager.enable(input.name, input.currentPeerId)
+      : input.manager.disable(input.name, input.currentPeerId)
   }
   if (mode === 'desired-state') {
-    return input.state.setPeerEnabled(input.name, input.peer.id, input.enabled)
+    const extension = await ExtensionModel.get(input.name)
+    if (!extension) throw new Error(`Extension ${input.name} is not installed.`)
+    return input.enabled
+      ? extension.enablePeer(input.peer.id)
+      : extension.disablePeer(input.peer.id)
   }
 
   const delegated = await PeerManager.delegate(
diff --git a/apps/client-web/src/twitter-setup-api.spec.ts b/apps/client-web/src/twitter-setup-api.spec.ts
deleted file mode 100644
index d9d012e..0000000
--- a/apps/client-web/src/twitter-setup-api.spec.ts
+++ /dev/null
@@ -1,172 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import {
-  Cron,
-  Peer,
-  PeerManager,
-  Source,
-  SourceForm,
-  type ExtensionStatePort,
-  type InstalledExtension,
-} from '@inkcre/core'
-import {
-  discoverCoreCandidates,
-  OAuthTransactionSchema,
-  TwitterBookmarkSetup,
-  TwitterSetupAPI,
-  TwitterSetupStatusSchema,
-} from '../../../extensions/twitter/src/setup-api'
-
-const corePeerId = '00000000-0000-4000-8000-000000000002'
-const installed: InstalledExtension = {
-  name: 'inkcre/twitter',
-  version: '0.2.1',
-  enabled: [corePeerId],
-  nickname: 'Twitter',
-  config: {},
-  config_schema: null,
-}
-const corePeer = Peer.parse({
-  id: corePeerId,
-  name: 'Core Preview',
-  labels: [],
-  config: {},
-  config_schema: {},
-  capabilities: [
-    {
-      id: 'core.extension.management.v1',
-      inbound: { protocol: 'core.peer.protocol.http.v1', parameters: {} },
-    },
-    {
-      id: 'inkcre.twitter.setup.status.v1',
-      inbound: { protocol: 'core.peer.protocol.http.v1', parameters: {} },
-    },
-  ],
-  lease_expires_at: new Date('2099-01-01'),
-  created_at: new Date('2026-01-01'),
-  updated_at: new Date('2026-01-01'),
-})
-
-describe('Twitter Peer setup API', () => {
-  afterEach(() => vi.restoreAllMocks())
-
-  it('discovers setup against one shared installation and live capability snapshots', async () => {
-    vi.spyOn(PeerManager, 'listLive').mockResolvedValue([corePeer])
-    const get = vi.fn(async () => installed)
-
-    await expect(
-      discoverCoreCandidates(undefined, { get } as unknown as ExtensionStatePort)
-    ).resolves.toEqual([
-      expect.objectContaining({
-        peer: corePeer,
-        extension: installed,
-        enabled: true,
-        setupAvailable: true,
-      }),
-    ])
-    expect(get).toHaveBeenCalledWith('inkcre/twitter')
-  })
-
-  it('executes setup only through the exact selected Core Peer capability', async () => {
-    const delegate = vi.spyOn(PeerManager, 'delegate').mockResolvedValue({
-      status: 200,
-      body: {
-        backend: 'oauth2',
-        callback_url: 'https://core.example/twitter/oauth/callback',
-        oauth_app_configured: false,
-        client_id: null,
-        connected: false,
-        user_id: null,
-        handle: null,
-        scopes: [],
-        reconnect_required: false,
-      },
-    })
-
-    await new TwitterSetupAPI(corePeer).status()
-
-    expect(delegate).toHaveBeenCalledWith(
-      'inkcre.twitter.setup.status.v1',
-      { body: {} },
-      corePeerId
-    )
-  })
-
-  it('rejects non-HTTP callback and non-HTTPS authorization URLs from a Peer', () => {
-    expect(() =>
-      TwitterSetupStatusSchema.parse({
-        backend: 'oauth2',
-        callback_url: 'javascript:alert(1)',
-        oauth_app_configured: false,
-        client_id: null,
-        connected: false,
-        user_id: null,
-        handle: null,
-        scopes: [],
-        reconnect_required: false,
-      })
-    ).toThrow('HTTP or HTTPS')
-    expect(() =>
-      OAuthTransactionSchema.parse({
-        id: '00000000-0000-4000-8000-000000000003',
-        status: 'pending',
-        authorize_url: 'javascript:alert(1)',
-        expires_at: '2099-01-01T00:00:00Z',
-        error: null,
-      })
-    ).toThrow('HTTPS')
-    expect(() =>
-      OAuthTransactionSchema.parse({
-        id: '00000000-0000-4000-8000-000000000004',
-        status: 'pending',
-        authorize_url: 'https://user:secret@x.example/authorize',
-        expires_at: '2099-01-01T00:00:00Z',
-        error: null,
-      })
-    ).toThrow('embedded credentials')
-  })
-
-  it('composes bookmark Source, Cron, and initial Job through ordinary database models', async () => {
-    const source = Source.parse({
-      id: 25,
-      type: 'extensions.twitter.bookmark.Source',
-      nickname: 'Bookmarks',
-      config: {},
-      state: {},
-      storage: null,
-      block: null,
-      created_at: '2026-01-01T00:00:00Z',
-      updated_at: '2026-01-01T00:00:00Z',
-    })
-    const cron = Cron.parse({
-      id: 9,
-      schedule: '30 6 * * *',
-      enabled: false,
-      job_type: 'core.source.collect.v1',
-      job_parameters: { source: 25, config: { full: false, result_limit: 40 } },
-      job_timeout_seconds: null,
-      last_job: null,
-      last_scheduled_for: null,
-      created_at: '2026-01-01T00:00:00Z',
-      updated_at: '2026-01-01T00:00:00Z',
-    })
-    vi.spyOn(Source, 'getAll').mockResolvedValue([source])
-    vi.spyOn(Cron, 'getBySource').mockResolvedValue([cron])
-    vi.spyOn(SourceForm.prototype, 'create').mockResolvedValue(source)
-    const update = vi
-      .spyOn(Cron.prototype, 'update')
-      .mockImplementation(async (form) =>
-        Cron.parse({ ...cron, ...form, id: cron.id, enabled: form.enabled })
-      )
-    const runNow = vi.spyOn(Cron.prototype, 'runNow').mockResolvedValue({} as never)
-
-    await expect(TwitterBookmarkSetup.read()).resolves.toMatchObject({ source, cron })
-    await expect(TwitterBookmarkSetup.createSource('Bookmarks')).resolves.toBe(source)
-    const scheduled = await TwitterBookmarkSetup.saveSchedule(source, 7, 15)
-    expect(update).toHaveBeenLastCalledWith(
-      expect.objectContaining({ schedule: '15 7 * * *', enabled: false })
-    )
-    await TwitterBookmarkSetup.finish(source, scheduled)
-    expect(update).toHaveBeenLastCalledWith(expect.objectContaining({ enabled: true }))
-    expect(runNow).toHaveBeenCalledOnce()
-  })
-})
diff --git a/apps/client-web/src/twitter-setup-wizard.spec.ts b/apps/client-web/src/twitter-setup-wizard.spec.ts
deleted file mode 100644
index 337bbaf..0000000
--- a/apps/client-web/src/twitter-setup-wizard.spec.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-import { defineComponent } from 'vue'
-import { flushPromises, mount } from '@vue/test-utils'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import TwitterSetupWizard from '../../../extensions/twitter/src/components/twitterSetupWizard/twitterSetupWizard.vue'
-
-const fixtures = vi.hoisted(() => {
-  const peerId = '00000000-0000-4000-8000-000000000002'
-  const extension = {
-    name: 'inkcre/twitter',
-    version: '0.2.0',
-    enabled: [] as string[],
-    nickname: 'Twitter',
-    config: {},
-    config_schema: null,
-  }
-  const candidate = {
-    peer: { id: peerId, name: 'Core Preview' },
-    extension,
-    enabled: false,
-    setupAvailable: false,
-  }
-  const status = {
-    backend: 'official',
-    callback_url: 'https://core.example/twitter/auth/callback',
-    oauth_app_configured: false,
-    client_id: null,
-    connected: false,
-    user_id: null,
-    handle: null,
-    scopes: [],
-    reconnect_required: false,
-    bookmark_source_id: null,
-    bookmark_cron_id: null,
-    bookmark_sources: [],
-    collect_at: { day_of_week: null, hour: 0, minute: 0 },
-    bookmark_source_ready: false,
-    ready: false,
-  }
-  return {
-    peerId,
-    extension,
-    candidate,
-    status,
-    discover: vi.fn(async () => [candidate]),
-    enableCore: vi.fn(async () => ({ ...extension, enabled: [peerId] })),
-    readStatus: vi.fn(async () => status),
-  }
-})
-
-vi.mock('../../../extensions/twitter/src/setup-api', () => ({
-  discoverCoreCandidates: fixtures.discover,
-  TwitterSetupAPI: class {
-    enableCore = fixtures.enableCore
-    status = fixtures.readStatus
-  },
-}))
-
-const stubs = {
-  InkButton: defineComponent({
-    props: ['text'],
-    emits: ['click'],
-    template: '<button @click="$emit(\'click\')">{{ text }}</button>',
-  }),
-  InkInput: true,
-  InkLoading: true,
-}
-
-describe('TwitterSetupWizard', () => {
-  beforeEach(() => {
-    fixtures.candidate.enabled = false
-    fixtures.candidate.extension = fixtures.extension
-    vi.clearAllMocks()
-  })
-
-  it('requires explicit Core enablement before whole-Extension setup commands', async () => {
-    const wrapper = mount(TwitterSetupWizard, { global: { stubs } })
-    await flushPromises()
-
-    const enable = wrapper
-      .findAll('button')
-      .find((button) => button.text() === 'Enable Twitter on this Core Peer')
-    expect(enable).toBeDefined()
-    await enable?.trigger('click')
-    await flushPromises()
-
-    expect(fixtures.enableCore).toHaveBeenCalledOnce()
-    expect(fixtures.readStatus).toHaveBeenCalledOnce()
-    expect(wrapper.text()).toContain('Connect an X account')
-    expect(wrapper.text()).toContain('https://core.example/twitter/auth/callback')
-  })
-})
diff --git a/apps/client-web/src/views/extensions/extensions.spec.ts b/apps/client-web/src/views/extensions/extensions.spec.ts
deleted file mode 100644
index 87d0c36..0000000
--- a/apps/client-web/src/views/extensions/extensions.spec.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import { defineComponent, nextTick } from 'vue'
-import { flushPromises, mount } from '@vue/test-utils'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import ExtensionsView from './extensions.vue'
-
-const fixtures = vi.hoisted(() => {
-  const currentPeerId = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'
-  const remotePeerId = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb'
-  const peers = [
-    { id: currentPeerId, name: 'Browser A', capabilities: [], lease_expires_at: new Date() },
-    { id: remotePeerId, name: 'Browser B', capabilities: [], lease_expires_at: new Date(0) },
-  ]
-  const extension = {
-    name: 'inkcre/twitter',
-    version: '0.2.0',
-    enabled: [currentPeerId],
-    nickname: 'Twitter',
-    config: {},
-    config_schema: null,
-  }
-  return {
-    currentPeerId,
-    remotePeerId,
-    peers,
-    extension,
-    host: { list: vi.fn(async () => [extension]) },
-    listPeers: vi.fn(async () => peers),
-    setPeerEnabled: vi.fn(),
-  }
-})
-
-vi.mock('@inkcre/core', () => ({
-  Peer: {
-    list: fixtures.listPeers,
-    parse: (value: unknown) => value,
-  },
-  configStore: { metaConfig: { INKCRE_PEER_ID: fixtures.currentPeerId } },
-}))
-vi.mock('@/core', () => ({
-  getExtensionHost: () => fixtures.host,
-  getExtensionState: () => ({ setPeerEnabled: vi.fn() }),
-  startExtensionHost: vi.fn(async () => undefined),
-}))
-vi.mock('@/extension-peer-control', () => ({
-  extensionPeerControlMode: (peer: { id: string }) =>
-    peer.id === fixtures.currentPeerId ? 'current-runtime' : 'desired-state',
-  setExtensionPeerEnabled: fixtures.setPeerEnabled,
-}))
-vi.mock('vue-i18n', () => ({ useI18n: () => ({ t: (key: string) => key }) }))
-
-const ExtensionCardStub = defineComponent({
-  props: ['extension', 'enabled', 'controlsCurrentWebRuntime', 'setEnabled'],
-  template:
-    '<div data-test="extension-card" :data-enabled="String(enabled)" :data-current="String(controlsCurrentWebRuntime)" />',
-})
-const InkDropdownStub = defineComponent({
-  props: ['modelValue', 'options', 'label', 'placeholder'],
-  emits: ['update:modelValue'],
-  template: '<button data-test="client-selector" />',
-})
-
-describe('Extensions Client selector', () => {
-  beforeEach(() => vi.clearAllMocks())
-
-  it('defaults to this browser and projects enabled state for the selected Client', async () => {
-    const wrapper = mount(ExtensionsView, {
-      global: {
-        stubs: {
-          extensionCard: ExtensionCardStub,
-          installExtension: true,
-          InkDropdown: InkDropdownStub,
-          InkLoading: true,
-        },
-      },
-    })
-    await flushPromises()
-
-    const selector = wrapper.getComponent(InkDropdownStub)
-    expect(selector.props('modelValue')).toBe(fixtures.currentPeerId)
-    expect(selector.props('options')[0]).toMatchObject({
-      value: fixtures.currentPeerId,
-      label: 'Browser A (extension.currentBrowser)',
-    })
-    expect(wrapper.get('[data-test="extension-card"]').attributes()).toMatchObject({
-      'data-enabled': 'true',
-      'data-current': 'true',
-    })
-
-    selector.vm.$emit('update:modelValue', fixtures.remotePeerId)
-    await nextTick()
-    expect(wrapper.get('[data-test="extension-card"]').attributes()).toMatchObject({
-      'data-enabled': 'false',
-      'data-current': 'false',
-    })
-    expect(wrapper.text()).toContain('extension.desiredStateOnly')
-  })
-
-  it('keeps this-browser management available when the Client list fails', async () => {
-    fixtures.listPeers.mockRejectedValueOnce(new Error('Peer row could not be parsed'))
-    const wrapper = mount(ExtensionsView, {
-      global: {
-        stubs: {
-          extensionCard: ExtensionCardStub,
-          installExtension: true,
-          InkDropdown: InkDropdownStub,
-          InkLoading: true,
-        },
-      },
-    })
-    await flushPromises()
-
-    const selector = wrapper.getComponent(InkDropdownStub)
-    expect(selector.props('options')).toEqual([
-      {
-        label: 'extension.currentBrowser',
-        value: fixtures.currentPeerId,
-        description: fixtures.currentPeerId,
-      },
-    ])
-    expect(wrapper.text()).toContain('extension.peerListUnavailable')
-  })
-})
diff --git a/apps/client-web/src/views/extensions/extensions.vue b/apps/client-web/src/views/extensions/extensions.vue
index 9e97b52..efcad47 100644
--- a/apps/client-web/src/views/extensions/extensions.vue
+++ b/apps/client-web/src/views/extensions/extensions.vue
@@ -4,7 +4,7 @@ import extensionCard from '@/components/extension/extensionCard/extensionCard.vu
 import installExtension from '@/components/extension/installExtension/installExtension.vue'
 import { InkDropdown, InkLoading } from '@inkcre/ui-web'
 import { configStore, Peer, type InstalledExtension } from '@inkcre/core'
-import { getExtensionHost, getExtensionState, startExtensionHost } from '@/core'
+import { getExtensionHost, startExtensionHost } from '@/core'
 import { extensionPeerControlMode, setExtensionPeerEnabled } from '@/extension-peer-control'
 import { useI18n } from 'vue-i18n'
 
@@ -115,8 +115,7 @@ const setEnabledForSelectedPeer = (
     peer,
     currentPeerId,
     enabled,
-    webHost: getExtensionHost(),
-    state: getExtensionState(),
+    manager: getExtensionHost(),
   })
 }
 </script>
diff --git a/apps/client-web/src/views/settings/settings.spec.ts b/apps/client-web/src/views/settings/settings.spec.ts
deleted file mode 100644
index 64f02ac..0000000
--- a/apps/client-web/src/views/settings/settings.spec.ts
+++ /dev/null
@@ -1,140 +0,0 @@
-import { defineComponent, onMounted } from 'vue'
-import { flushPromises, mount } from '@vue/test-utils'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { configStore, MetaConfigSchema, PeerConfigSchema } from '@inkcre/core'
-import Settings from './settings.vue'
-
-const peerListState = vi.hoisted(() => ({ mounts: 0 }))
-const appRuntimeState = vi.hoisted(() => ({
-  adopt: vi.fn(),
-  startConfigured: vi.fn(async () => undefined),
-  stop: vi.fn(),
-}))
-
-vi.mock('@/core', () => ({
-  adoptWebPeerRuntime: appRuntimeState.adopt,
-  startConfiguredWebPeerRuntime: appRuntimeState.startConfigured,
-  stopWebPeerRuntime: appRuntimeState.stop,
-}))
-
-vi.mock('@/components/peer/peerList/peerList.vue', () => ({
-  default: defineComponent({
-    name: 'PeerList',
-    setup() {
-      onMounted(() => {
-        peerListState.mounts += 1
-      })
-    },
-    template: '<section data-test="all-clients" />',
-  }),
-}))
-
-vi.mock('vue-i18n', async (importOriginal) => ({
-  ...(await importOriginal<typeof import('vue-i18n')>()),
-  useI18n: () => ({ t: (key: string) => key }),
-}))
-
-const connectedMeta = MetaConfigSchema.parse({
-  INKCRE_PGREST_URL: 'https://database.example.test/',
-  INKCRE_JWT_SECRET: 'secret',
-  INKCRE_PEER_ID: '00000000-0000-4000-8000-000000000001',
-})
-const originalMeta = { ...configStore.metaConfig }
-const originalPeer = PeerConfigSchema.parse(configStore.peerConfig)
-
-const stubs = {
-  InkForm: defineComponent({ template: '<form><slot /></form>' }),
-  InkInput: true,
-  InkButton: defineComponent({
-    props: ['text'],
-    emits: ['click'],
-    template: '<button type="button" @click="$emit(\'click\')">{{ text }}</button>',
-  }),
-  InkDoubleCheck: defineComponent({ template: '<div><slot /></div>' }),
-}
-
-describe('Settings Client scopes', () => {
-  beforeEach(() => {
-    peerListState.mounts = 0
-    appRuntimeState.adopt.mockReset()
-    appRuntimeState.startConfigured.mockClear()
-    appRuntimeState.stop.mockReset()
-    vi.stubGlobal('alert', vi.fn())
-  })
-
-  afterEach(() => {
-    Object.assign(configStore.metaConfig, originalMeta)
-    Object.assign(configStore.peerConfig, originalPeer)
-    vi.restoreAllMocks()
-    vi.unstubAllGlobals()
-  })
-
-  it('keeps bootstrap recovery available without mounting deployment Clients', async () => {
-    Object.assign(configStore.metaConfig, MetaConfigSchema.parse({}))
-    const loadPeerConfig = vi.spyOn(configStore, 'loadPeerConfig').mockResolvedValue()
-
-    const wrapper = mount(Settings, { global: { stubs } })
-    await flushPromises()
-
-    expect(wrapper.find('[data-test="all-clients"]').exists()).toBe(false)
-    expect(loadPeerConfig).not.toHaveBeenCalled()
-    wrapper.unmount()
-  })
-
-  it('loads Client settings and the complete Client list once connected', async () => {
-    Object.assign(configStore.metaConfig, connectedMeta)
-    vi.spyOn(configStore, 'loadPeerConfig').mockResolvedValue()
-
-    const wrapper = mount(Settings, { global: { stubs } })
-    await flushPromises()
-
-    expect(wrapper.find('[data-test="all-clients"]').exists()).toBe(true)
-    expect(peerListState.mounts).toBe(1)
-    wrapper.unmount()
-  })
-
-  it('refreshes the Client list after validated Client settings are saved', async () => {
-    Object.assign(configStore.metaConfig, connectedMeta)
-    vi.spyOn(configStore, 'loadPeerConfig').mockResolvedValue()
-    const runtime = { stop: vi.fn() }
-    vi.spyOn(configStore, 'connectAndSave').mockImplementation(async (meta, peer) => {
-      Object.assign(configStore.metaConfig, meta)
-      Object.assign(configStore.peerConfig, peer)
-      return runtime as never
-    })
-    const wrapper = mount(Settings, { global: { stubs } })
-    await flushPromises()
-    const save = wrapper.findAll('button').find((button) => button.text() === 'settings.saveConfig')
-
-    await save?.trigger('click')
-    await flushPromises()
-
-    expect(configStore.connectAndSave).toHaveBeenCalledOnce()
-    expect(appRuntimeState.adopt).toHaveBeenCalledWith(runtime)
-    expect(peerListState.mounts).toBe(2)
-    wrapper.unmount()
-  })
-
-  it('does not overwrite Client settings while their initial read is pending', async () => {
-    Object.assign(configStore.metaConfig, connectedMeta)
-    let resolveLoad: (() => void) | undefined
-    vi.spyOn(configStore, 'loadPeerConfig').mockImplementation(
-      () =>
-        new Promise<void>((resolve) => {
-          resolveLoad = resolve
-        })
-    )
-    const connect = vi.spyOn(configStore, 'connectAndSave')
-    const wrapper = mount(Settings, { global: { stubs } })
-    await flushPromises()
-    const save = wrapper.findAll('button').find((button) => button.text() === 'settings.saveConfig')
-
-    expect(save?.attributes('disabled')).toBeDefined()
-    await save?.trigger('click')
-    expect(connect).not.toHaveBeenCalled()
-
-    resolveLoad?.()
-    await flushPromises()
-    wrapper.unmount()
-  })
-})
diff --git a/extensions/twitter/src/setup-api.ts b/extensions/twitter/src/setup-api.ts
index b25f5b5..bbec90d 100644
--- a/extensions/twitter/src/setup-api.ts
+++ b/extensions/twitter/src/setup-api.ts
@@ -2,13 +2,12 @@ import {
   InstalledExtensionSchema,
   Cron,
   CronForm,
+  ExtensionModel,
   Peer,
   PeerManager,
   PeerProtocolResponseSchema,
-  PostgrestExtensionStatePort,
   Source,
   SourceForm,
-  type ExtensionStatePort,
   type InstalledExtension,
   type JsonValue,
 } from '@inkcre/core'
@@ -78,12 +77,12 @@ function advertises(peer: Peer, capability: string): boolean {
   }
 }
 
-export async function discoverCoreCandidates(
-  signal?: AbortSignal,
-  state: ExtensionStatePort = new PostgrestExtensionStatePort()
-): Promise<CorePeerCandidate[]> {
+export async function discoverCoreCandidates(signal?: AbortSignal): Promise<CorePeerCandidate[]> {
   signal?.throwIfAborted()
-  const [extension, peers] = await Promise.all([state.get(EXTENSION_NAME), PeerManager.listLive()])
+  const [extension, peers] = await Promise.all([
+    ExtensionModel.get(EXTENSION_NAME),
+    PeerManager.listLive(),
+  ])
   signal?.throwIfAborted()
   if (!extension) return []
   return peers
diff --git a/packages/core/src/auth/store.ts b/packages/core/src/auth/store.ts
index 65f29bd..5889613 100644
--- a/packages/core/src/auth/store.ts
+++ b/packages/core/src/auth/store.ts
@@ -5,6 +5,21 @@ import { peerJwtContract } from '../database'
 
 const JWT_CLOCK_SKEW_SECONDS = 5
 
+export async function signDatabaseToken(jwtSecret: string): Promise<string> {
+  if (!jwtSecret) throw new Error('JWT_SECRET not configured')
+
+  const secret = new TextEncoder().encode(jwtSecret)
+  // A Peer and its PostgREST boundary may not share an exact wall clock.
+  const issuedAt = Math.floor(Date.now() / 1000) - JWT_CLOCK_SKEW_SECONDS
+  return new SignJWT({ role: peerJwtContract.role })
+    .setProtectedHeader({ alg: peerJwtContract.algorithm })
+    .setIssuedAt(issuedAt)
+    .setExpirationTime(issuedAt + peerJwtContract.maximum_lifetime_seconds)
+    .setIssuer(peerJwtContract.issuer)
+    .setAudience(peerJwtContract.audience)
+    .sign(secret)
+}
+
 /**
  * Create an auth store instance.
  * Returns reactive token and token management functions.
@@ -13,24 +28,8 @@ export function createAuthStore(configStoreIns = configStore) {
   const token = ref<string | undefined>(undefined)
 
   async function newToken(): Promise<string> {
-    if (!configStoreIns.metaConfig.INKCRE_JWT_SECRET) {
-      throw new Error('JWT_SECRET not configured')
-    }
-
     try {
-      const secret = new TextEncoder().encode(configStoreIns.metaConfig.INKCRE_JWT_SECRET)
-      // A Peer and its PostgREST boundary may not share an exact wall clock.
-      // Backdate the bounded token instead of leaking clock-skew handling into callers.
-      const issuedAt = Math.floor(Date.now() / 1000) - JWT_CLOCK_SKEW_SECONDS
-      const signedToken = await new SignJWT({
-        role: peerJwtContract.role,
-      })
-        .setProtectedHeader({ alg: peerJwtContract.algorithm })
-        .setIssuedAt(issuedAt)
-        .setExpirationTime(issuedAt + peerJwtContract.maximum_lifetime_seconds)
-        .setIssuer(peerJwtContract.issuer)
-        .setAudience(peerJwtContract.audience)
-        .sign(secret)
+      const signedToken = await signDatabaseToken(configStoreIns.metaConfig.INKCRE_JWT_SECRET)
 
       token.value = signedToken
       return signedToken
diff --git a/packages/core/src/base/db-api.test.ts b/packages/core/src/base/db-api.test.ts
deleted file mode 100644
index a055a22..0000000
--- a/packages/core/src/base/db-api.test.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-import { afterEach, describe, expect, test, vi } from 'vitest'
-import { configStore } from '../config'
-import { DBAPIClient } from './db-api'
-
-describe('DBAPIClient reactive transport', () => {
-  afterEach(() => {
-    configStore.metaConfig.INKCRE_PGREST_URL = ''
-    vi.unstubAllGlobals()
-  })
-
-  test('uses a newly configured PostgREST URL immediately', async () => {
-    const fetch = vi.fn().mockResolvedValue(
-      new Response('[]', {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      })
-    )
-    vi.stubGlobal('fetch', fetch)
-    configStore.metaConfig.INKCRE_PGREST_URL = ''
-    const database = new DBAPIClient('peers', undefined, 'inkcre', '', async () => 'test-token')
-
-    configStore.metaConfig.INKCRE_PGREST_URL = 'https://database.example.test///'
-    const response = await database.from().select('id')
-
-    expect(response.error).toBeNull()
-    expect(fetch).toHaveBeenCalledOnce()
-    expect(fetch.mock.calls[0]?.[0].toString()).toBe(
-      'https://database.example.test/peers?select=id'
-    )
-  })
-})
diff --git a/packages/core/src/config/store.test.ts b/packages/core/src/config/store.test.ts
deleted file mode 100644
index 8cca16e..0000000
--- a/packages/core/src/config/store.test.ts
+++ /dev/null
@@ -1,82 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { WebPeerRuntime } from '../peer'
-import { configStore } from './store'
-import type { ConfigAdapterWithWrite } from './types'
-
-const previousPeerId = '00000000-0000-4000-8000-000000000001'
-const nextPeerId = '00000000-0000-4000-8000-000000000002'
-
-function adapter() {
-  const write = vi.fn(async () => undefined)
-  const value: ConfigAdapterWithWrite = {
-    name: 'test',
-    read: async () => ({
-      INKCRE_PGREST_URL: 'https://old-database.example',
-      INKCRE_JWT_SECRET: 'old-secret',
-      INKCRE_PEER_ID: previousPeerId,
-    }),
-    write,
-  }
-  return { value, write }
-}
-
-describe('Config connection transaction', () => {
-  afterEach(() => vi.restoreAllMocks())
-
-  it('does not replace working browser bootstrap when database validation fails', async () => {
-    const storage = adapter()
-    await configStore.initializeMeta(storage.value)
-    vi.spyOn(WebPeerRuntime, 'connect').mockRejectedValue(new Error('wrong database'))
-
-    await expect(
-      configStore.connectAndSave(
-        {
-          INKCRE_PGREST_URL: 'https://new-database.example',
-          INKCRE_JWT_SECRET: 'new-secret',
-          INKCRE_PEER_ID: nextPeerId,
-        },
-        { ...configStore.peerConfig, extension_registry_url: 'https://registry.inkcre.dev' }
-      )
-    ).rejects.toThrow('wrong database')
-
-    expect(storage.write).not.toHaveBeenCalled()
-    expect(configStore.metaConfig.INKCRE_PEER_ID).toBe(previousPeerId)
-  })
-
-  it('persists bootstrap only after registration, config write, and lease validation succeed', async () => {
-    const storage = adapter()
-    await configStore.initializeMeta(storage.value)
-    const runtime = { stop: vi.fn() }
-    const connect = vi.spyOn(WebPeerRuntime, 'connect').mockResolvedValue({
-      peer: {} as never,
-      runtime: runtime as never,
-    })
-    const peerConfig = {
-      ...configStore.peerConfig,
-      extension_registry_url: 'https://registry.inkcre.dev',
-    }
-    const metaConfig = {
-      INKCRE_PGREST_URL: 'https://new-database.example',
-      INKCRE_JWT_SECRET: 'new-secret',
-      INKCRE_PEER_ID: nextPeerId,
-    }
-
-    await expect(configStore.connectAndSave(metaConfig, peerConfig)).resolves.toBe(runtime)
-
-    expect(connect).toHaveBeenCalledWith(metaConfig, peerConfig)
-    expect(storage.write).toHaveBeenCalledWith(metaConfig)
-    expect(configStore.metaConfig).toEqual(metaConfig)
-    expect(configStore.peerConfig.extension_registry_url).toBe('https://registry.inkcre.dev')
-  })
-
-  it('keeps the current bootstrap when reset persistence fails', async () => {
-    const storage = adapter()
-    await configStore.initializeMeta(storage.value)
-    storage.write.mockRejectedValueOnce(new Error('storage unavailable'))
-
-    await expect(configStore.resetMeta()).rejects.toThrow('storage unavailable')
-
-    expect(configStore.metaConfig.INKCRE_PEER_ID).toBe(previousPeerId)
-    expect(configStore.metaConfig.INKCRE_PGREST_URL).toBe('https://old-database.example')
-  })
-})
diff --git a/packages/core/src/extension/host.ts b/packages/core/src/extension/host.ts
deleted file mode 100644
index 5c75eb4..0000000
--- a/packages/core/src/extension/host.ts
+++ /dev/null
@@ -1,443 +0,0 @@
-import { satisfies, valid as validSemVer, validRange } from 'semver'
-import type { MFImplementation } from './module-federation'
-import {
-  InstalledExtensionSchema,
-  InstallExtensionInputSchema,
-  ExtensionVersionSchema,
-  type ExtensionModule,
-  type InstalledExtension,
-  type InstallExtensionInput,
-} from './model'
-import type {
-  ExtensionRelease,
-  ExtensionReleaseReader,
-  ModuleFederationDistribution,
-} from './registry'
-import type { ExtensionStatePort } from './state'
-
-const WEB_HOST_SDK = '@inkcre/core'
-
-export class WebExtensionHostError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'WebExtensionHostError'
-  }
-}
-
-export class WebExtensionIncompatibleError extends WebExtensionHostError {
-  constructor(name: string, version: string, reason: string) {
-    super(`Cannot run ${name}@${version} in this Web Host: ${reason}`)
-    this.name = 'WebExtensionIncompatibleError'
-  }
-}
-
-export class WebExtensionEnabledError extends WebExtensionHostError {
-  constructor(name: string) {
-    super(`Cannot change or uninstall ${name} while one or more Peers remain enabled.`)
-    this.name = 'WebExtensionEnabledError'
-  }
-}
-
-export interface WebExtensionHostOptions {
-  state: ExtensionStatePort
-  releases: ExtensionReleaseReader
-  moduleFederation: () => MFImplementation
-  currentPeerId: () => string | undefined
-  hostSdkVersion: string
-  warn?: (message: string) => void
-}
-
-interface RunningExtension {
-  installed: InstalledExtension
-  lifecycle: WebExtensionLifecycle
-}
-
-/** Platform-specific Host for native Module Federation Extension Releases. */
-export class WebExtensionHost {
-  private readonly state: ExtensionStatePort
-  private readonly releases: ExtensionReleaseReader
-  private readonly moduleFederation: () => MFImplementation
-  private readonly currentPeerId: () => string | undefined
-  private readonly hostSdkVersion: string
-  private readonly warn: (message: string) => void
-  private readonly running = new Map<string, RunningExtension>()
-  private readonly runtimeErrors = new Map<string, Error>()
-  private operationTail: Promise<void> = Promise.resolve()
-
-  constructor(options: WebExtensionHostOptions) {
-    if (validSemVer(options.hostSdkVersion) !== options.hostSdkVersion) {
-      throw new TypeError('Web Host SDK version must be strict SemVer.')
-    }
-    this.state = options.state
-    this.releases = options.releases
-    this.moduleFederation = options.moduleFederation
-    this.currentPeerId = options.currentPeerId
-    this.hostSdkVersion = options.hostSdkVersion
-    this.warn = options.warn ?? console.warn
-  }
-
-  list(): Promise<InstalledExtension[]> {
-    return this.state.list()
-  }
-
-  getRuntimeError(name: string): Error | null {
-    return this.runtimeErrors.get(name) ?? null
-  }
-
-  isRunning(name: string): boolean {
-    return this.running.has(name)
-  }
-
-  getSetupContribution(name: string) {
-    return this.running.get(name)?.lifecycle.module?.setup ?? null
-  }
-
-  async install(input: InstallExtensionInput): Promise<InstalledExtension> {
-    const exact = InstallExtensionInputSchema.parse(input)
-    return this.exclusively(async () => {
-      const release = await this.preflight(exact.name, exact.version, true)
-      const installed = InstalledExtensionSchema.parse({
-        name: release.name,
-        version: release.version,
-        enabled: [],
-        nickname: release.nickname,
-        config: {},
-        config_schema: null,
-      })
-      return this.state.install(installed)
-    })
-  }
-
-  updateConfig(name: string, config: Record<string, unknown>): Promise<InstalledExtension> {
-    return this.exclusively(() => this.state.updateConfig(name, config))
-  }
-
-  changeVersion(name: string, version: string): Promise<InstalledExtension> {
-    const exactVersion = ExtensionVersionSchema.parse(version)
-    return this.exclusively(async () => {
-      const installed = await this.requireInstalled(name)
-      if (installed.enabled.length > 0 || this.running.has(name)) {
-        throw new WebExtensionEnabledError(name)
-      }
-      if (installed.version === exactVersion) return installed
-      const release = await this.preflight(name, exactVersion, true)
-      return this.state.changeVersion(name, exactVersion, release.nickname)
-    })
-  }
-
-  enable(name: string): Promise<InstalledExtension> {
-    return this.exclusively(() => this.enableCurrentPeer(name))
-  }
-
-  disable(name: string): Promise<InstalledExtension> {
-    return this.exclusively(() => this.disableCurrentPeer(name))
-  }
-
-  uninstall(name: string): Promise<void> {
-    return this.exclusively(async () => {
-      const installed = await this.requireInstalled(name)
-      if (installed.enabled.length > 0 || this.running.has(name)) {
-        throw new WebExtensionEnabledError(name)
-      }
-      await this.state.uninstall(name)
-      this.runtimeErrors.delete(name)
-    })
-  }
-
-  /** Start only exact installed rows enabled for this Web Peer. */
-  async startup(): Promise<void> {
-    const peerId = this.currentPeerId()
-    if (!peerId) return
-
-    await this.exclusively(async () => {
-      const installedExtensions = await this.state.list()
-      const enabledExtensions = installedExtensions.filter((extension) =>
-        extension.enabled.includes(peerId)
-      )
-      const failures: Error[] = []
-
-      for (const installed of enabledExtensions) {
-        try {
-          await this.start(installed)
-        } catch (error) {
-          const failure = asError(error)
-          this.runtimeErrors.set(installed.name, failure)
-          failures.push(failure)
-        }
-      }
-
-      if (failures.length > 0) {
-        throw combineErrors('Web Extension startup failed.', failures)
-      }
-    })
-  }
-
-  /** Stop volatile runtimes without changing durable enabled intent. */
-  async shutdown(): Promise<void> {
-    await this.exclusively(async () => {
-      const failures: Error[] = []
-      for (const [name, runtime] of this.running) {
-        try {
-          await runtime.lifecycle.stop()
-          this.running.delete(name)
-        } catch (error) {
-          failures.push(asError(error))
-        }
-      }
-      if (failures.length > 0) throw combineErrors('Web Extension shutdown failed.', failures)
-    })
-  }
-
-  private async enableCurrentPeer(name: string): Promise<InstalledExtension> {
-    const peerId = this.requireCurrentPeerId()
-    const installed = await this.requireInstalled(name)
-    if (!this.running.has(name)) {
-      await this.start(installed)
-    }
-    if (installed.enabled.includes(peerId)) return installed
-
-    const runtime = this.running.get(name)
-    if (!runtime) throw new WebExtensionHostError(`Runtime ${name} did not start.`)
-
-    try {
-      const enabled = InstalledExtensionSchema.parse(
-        await this.state.setPeerEnabled(name, peerId, true)
-      )
-      if (!enabled.enabled.includes(peerId)) {
-        throw new WebExtensionHostError(`State port did not enable ${name} for the current Peer.`)
-      }
-      if (enabled.version !== installed.version) {
-        const versionConflict = new WebExtensionHostError(
-          `${name} changed from ${installed.version} to ${enabled.version} during enable; retry against the new exact Release.`
-        )
-        try {
-          await this.state.setPeerEnabled(name, peerId, false)
-        } catch (rollbackError) {
-          throw combineErrors('Enable version conflict and durable intent rollback failed.', [
-            versionConflict,
-            asError(rollbackError),
-          ])
-        }
-        throw versionConflict
-      }
-      runtime.installed = enabled
-      return enabled
-    } catch (persistenceError) {
-      try {
-        await runtime.lifecycle.stop()
-        this.running.delete(name)
-      } catch (cleanupError) {
-        throw combineErrors('Enable persistence and runtime compensation failed.', [
-          asError(persistenceError),
-          asError(cleanupError),
-        ])
-      }
-      throw persistenceError
-    }
-  }
-
-  private async disableCurrentPeer(name: string): Promise<InstalledExtension> {
-    const peerId = this.requireCurrentPeerId()
-    const installed = await this.requireInstalled(name)
-    if (!installed.enabled.includes(peerId)) return installed
-
-    const runtime = this.running.get(name)
-    if (runtime) {
-      await runtime.lifecycle.stop()
-      this.running.delete(name)
-    }
-
-    try {
-      const disabled = InstalledExtensionSchema.parse(
-        await this.state.setPeerEnabled(name, peerId, false)
-      )
-      if (disabled.enabled.includes(peerId)) {
-        throw new WebExtensionHostError(`State port did not disable ${name} for the current Peer.`)
-      }
-      this.runtimeErrors.delete(name)
-      return disabled
-    } catch (persistenceError) {
-      if (!runtime) throw persistenceError
-      try {
-        await this.start(installed)
-      } catch (restartError) {
-        throw combineErrors('Disable persistence and runtime restoration failed.', [
-          asError(persistenceError),
-          asError(restartError),
-        ])
-      }
-      throw persistenceError
-    }
-  }
-
-  private async start(installed: InstalledExtension): Promise<void> {
-    if (this.running.has(installed.name)) return
-
-    const release = await this.preflight(installed.name, installed.version, false)
-    const distribution = release.module_federation
-    if (!distribution) {
-      throw new WebExtensionIncompatibleError(
-        installed.name,
-        installed.version,
-        'the Release has no Module Federation Distribution.'
-      )
-    }
-
-    const manifestUrl = distribution.manifest_url
-    const remoteName = webExtensionRemoteName(installed.name)
-    const lifecycle = new WebExtensionLifecycle(async () => {
-      const moduleFederation = this.moduleFederation()
-      moduleFederation.registerRemotes([{ name: remoteName, entry: manifestUrl }], { force: true })
-      const loaded = await moduleFederation.loadRemote<
-        ExtensionModule | { default: ExtensionModule }
-      >(remoteName)
-      if (!loaded) {
-        throw new WebExtensionHostError(`${installed.name} returned no Module Federation module.`)
-      }
-      return 'default' in loaded ? loaded.default : loaded
-    })
-
-    await lifecycle.start()
-    this.running.set(installed.name, { installed, lifecycle })
-    this.runtimeErrors.delete(installed.name)
-  }
-
-  private async preflight(
-    name: string,
-    version: string,
-    requirePublished: boolean
-  ): Promise<ExtensionRelease> {
-    const release = await this.releases.get(name, version)
-    if (requirePublished && release.state !== 'published') {
-      throw new WebExtensionHostError(
-        `Only a published Release can be installed: ${name}@${version}.`
-      )
-    }
-    if (!requirePublished && release.state !== 'published' && release.state !== 'yanked') {
-      throw new WebExtensionHostError(
-        `Exact installed Release ${name}@${version} is not executable in state ${release.state}.`
-      )
-    }
-    if (release.state === 'yanked') {
-      this.warn(`Starting exact installed yanked Release ${name}@${version}.`)
-    }
-
-    const distribution = release.module_federation
-    if (!distribution) {
-      throw new WebExtensionIncompatibleError(
-        name,
-        version,
-        'the Release has no Module Federation Distribution.'
-      )
-    }
-    this.assertHostSdkCompatible(name, version, distribution)
-    return release
-  }
-
-  private assertHostSdkCompatible(
-    name: string,
-    version: string,
-    distribution: ModuleFederationDistribution
-  ): void {
-    if (distribution.host_sdk !== WEB_HOST_SDK) {
-      throw new WebExtensionIncompatibleError(
-        name,
-        version,
-        `expected Host SDK ${WEB_HOST_SDK}, received ${distribution.host_sdk}.`
-      )
-    }
-
-    const hostRange = distribution.host_sdk_version.replace(/,/g, ' ')
-    if (!validRange(hostRange) || !satisfies(this.hostSdkVersion, hostRange)) {
-      throw new WebExtensionIncompatibleError(
-        name,
-        version,
-        `Host SDK ${this.hostSdkVersion} does not satisfy ${distribution.host_sdk_version}.`
-      )
-    }
-  }
-
-  private async requireInstalled(name: string): Promise<InstalledExtension> {
-    const installed = await this.state.get(name)
-    if (!installed) throw new WebExtensionHostError(`Extension ${name} is not installed.`)
-    return InstalledExtensionSchema.parse(installed)
-  }
-
-  private requireCurrentPeerId(): string {
-    const peerId = this.currentPeerId()
-    if (!peerId) throw new WebExtensionHostError('INKCRE_PEER_ID is required for Extension state.')
-    return peerId
-  }
-
-  private async exclusively<T>(operation: () => Promise<T>): Promise<T> {
-    let release: (() => void) | undefined
-    const previous = this.operationTail
-    this.operationTail = new Promise<void>((resolve) => {
-      release = resolve
-    })
-    await previous
-    try {
-      return await operation()
-    } finally {
-      release?.()
-    }
-  }
-}
-
-class WebExtensionLifecycle {
-  private extensionModule: ExtensionModule | null = null
-  private active = false
-
-  constructor(private readonly load: () => Promise<ExtensionModule>) {}
-
-  get module(): ExtensionModule | null {
-    return this.extensionModule
-  }
-
-  async start(): Promise<void> {
-    if (this.extensionModule) return
-
-    const extensionModule = await this.load()
-    this.extensionModule = extensionModule
-    try {
-      await extensionModule.initialize?.()
-      await extensionModule.activate?.()
-      this.active = true
-    } catch (startError) {
-      try {
-        await this.stop()
-      } catch (cleanupError) {
-        throw combineErrors('Extension start and compensation failed.', [
-          asError(startError),
-          asError(cleanupError),
-        ])
-      }
-      throw startError
-    }
-  }
-
-  async stop(): Promise<void> {
-    const extensionModule = this.extensionModule
-    if (!extensionModule) return
-
-    if (this.active) {
-      await extensionModule.deactivate?.()
-      this.active = false
-    }
-    await extensionModule.dispose?.()
-    this.extensionModule = null
-  }
-}
-
-export function webExtensionRemoteName(name: string): string {
-  return `extension.${name.replace('/', '.')}`
-}
-
-function asError(error: unknown): Error {
-  return error instanceof Error ? error : new Error(String(error))
-}
-
-function combineErrors(message: string, errors: Error[]): Error {
-  if (errors.length === 1) return errors[0]
-  return new WebExtensionHostError(`${message} ${errors.map((error) => error.message).join(' | ')}`)
-}
diff --git a/packages/core/src/extension/index.ts b/packages/core/src/extension/index.ts
index 9afb609..91de33c 100644
--- a/packages/core/src/extension/index.ts
+++ b/packages/core/src/extension/index.ts
@@ -3,47 +3,18 @@ export {
   ExtensionVersionSchema,
   InstalledExtensionSchema,
   InstallExtensionInputSchema,
+  ExtensionModel,
+  ExtensionPersistenceError,
   type ExtensionModule,
   type ExtensionSetupContribution,
   type InstalledExtension,
   type InstallExtensionInput,
+  type ExtensionModelInstallInput,
 } from './model'
 
-export {
-  setMFImplementation,
-  getMFImplementation,
-  registerRemotes,
-  loadRemote,
-  isMFInitialized,
-  type RemoteConfig,
-  type RegisterRemotesOptions,
-  type MFImplementation,
-} from './module-federation'
-
-export {
-  ExtensionReleaseSchema,
-  RegistryExtensionReleaseReader,
-  type ExtensionRelease,
-  type ModuleFederationDistribution,
-  type ExtensionReleaseReader,
-} from './registry'
-
 export {
   DEFAULT_EXTENSION_REGISTRY_ORIGIN,
   EXTENSION_REGISTRY_CONFIG_KEY,
   EXTENSION_REGISTRY_CONFIG_SCHEMA,
   ExtensionRegistryOriginResolver,
 } from './registry-origin'
-
-export type { ExtensionStatePort } from './state'
-
-export { PostgrestExtensionStatePort, ExtensionStatePersistenceError } from './postgrest-state'
-
-export {
-  WebExtensionHost,
-  WebExtensionHostError,
-  WebExtensionIncompatibleError,
-  WebExtensionEnabledError,
-  webExtensionRemoteName,
-  type WebExtensionHostOptions,
-} from './host'
diff --git a/packages/core/src/extension/model.ts b/packages/core/src/extension/model.ts
index 1d635d5..cc9f438 100644
--- a/packages/core/src/extension/model.ts
+++ b/packages/core/src/extension/model.ts
@@ -1,6 +1,7 @@
 import { parse as parseSemVer } from 'semver'
 import type { Component } from 'vue'
 import { z } from 'zod'
+import { APIError, DBAPIClient } from '../base'
 
 const EXTENSION_NAME_PATTERN =
   /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?\/[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/
@@ -36,6 +37,183 @@ export const InstallExtensionInputSchema = InstalledExtensionSchema.pick({
 
 export type InstalledExtension = z.infer<typeof InstalledExtensionSchema>
 export type InstallExtensionInput = z.infer<typeof InstallExtensionInputSchema>
+export interface ExtensionModelInstallInput extends InstallExtensionInput {
+  nickname: string
+}
+
+const EXTENSION_MANAGEMENT_PROJECTION =
+  'name,version,enabled,nickname,config,config_schema' as const
+
+export class ExtensionPersistenceError extends Error {
+  constructor(operation: string, cause?: unknown) {
+    super(
+      `Extension state ${operation} failed${cause instanceof Error ? `: ${cause.message}` : ''}.`
+    )
+    this.name = 'ExtensionPersistenceError'
+  }
+}
+
+/** Rich deployment Extension aggregate backed by the canonical PostgREST relation. */
+export class ExtensionModel implements InstalledExtension {
+  static readonly #dbApi = new DBAPIClient<'extensions'>('extensions')
+
+  readonly name: string
+  readonly version: string
+  readonly enabled: string[]
+  readonly nickname: string | null
+  readonly config: Record<string, unknown>
+  readonly config_schema: Record<string, unknown> | null
+
+  constructor(row: InstalledExtension) {
+    const parsed = InstalledExtensionSchema.parse(row)
+    this.name = parsed.name
+    this.version = parsed.version
+    this.enabled = parsed.enabled
+    this.nickname = parsed.nickname
+    this.config = parsed.config
+    this.config_schema = parsed.config_schema
+  }
+
+  static async list(): Promise<ExtensionModel[]> {
+    const response = await this.#dbApi
+      .from()
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
+      .order('name', { ascending: true })
+    assertSuccess(response, 'list')
+    return InstalledExtensionSchema.array()
+      .parse(response.data ?? [])
+      .map(this.fromRow)
+  }
+
+  static async get(name: string): Promise<ExtensionModel | null> {
+    const response = await this.#dbApi
+      .from()
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
+      .eq('name', name)
+      .maybeSingle()
+    assertSuccess(response, 'read')
+    return response.data === null ? null : this.fromRow(response.data)
+  }
+
+  static async install(input: ExtensionModelInstallInput): Promise<ExtensionModel> {
+    const coordinate = InstallExtensionInputSchema.parse(input)
+    const exact = InstalledExtensionSchema.parse({
+      ...coordinate,
+      nickname: input.nickname,
+      enabled: [],
+      config: {},
+      config_schema: null,
+    })
+    const existing = await this.get(exact.name)
+    if (existing) {
+      if (existing.version === exact.version) return existing
+      throw new ExtensionPersistenceError(
+        'install',
+        new Error(
+          `${exact.name} is already installed at ${existing.version}; disable every Peer before an explicit version change.`
+        )
+      )
+    }
+
+    const response = await this.#dbApi
+      .insert({
+        name: exact.name,
+        version: exact.version,
+        nickname: exact.nickname,
+        config: exact.config,
+        config_schema: exact.config_schema,
+      })
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
+      .single()
+    assertSuccess(response, 'install')
+    return this.fromRow(response.data)
+  }
+
+  async changeVersion(version: string, nickname: string): Promise<ExtensionModel> {
+    const exactVersion = ExtensionVersionSchema.parse(version)
+    const response = await ExtensionModel.#dbApi
+      .update({ version: exactVersion, nickname, config_schema: null })
+      .eq('name', this.name)
+      .filter('enabled', 'eq', '{}')
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
+      .maybeSingle()
+    assertSuccess(response, 'change version')
+    if (response.data === null) {
+      throw new ExtensionPersistenceError(
+        'change version',
+        new Error(`Extension ${this.name} is missing or still enabled on a Peer.`)
+      )
+    }
+    return ExtensionModel.fromRow(response.data)
+  }
+
+  async updateConfig(config: Record<string, unknown>): Promise<ExtensionModel> {
+    const response = await ExtensionModel.#dbApi
+      .update({ config })
+      .eq('name', this.name)
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
+      .single()
+    assertSuccess(response, 'update config')
+    return ExtensionModel.fromRow(response.data)
+  }
+
+  enablePeer(peerId: string): Promise<ExtensionModel> {
+    return this.setPeerEnabled(peerId, true)
+  }
+
+  disablePeer(peerId: string): Promise<ExtensionModel> {
+    return this.setPeerEnabled(peerId, false)
+  }
+
+  async uninstall(): Promise<void> {
+    const response = await ExtensionModel.#dbApi
+      .from()
+      .delete()
+      .eq('name', this.name)
+      .filter('enabled', 'eq', '{}')
+      .select('name')
+    assertSuccess(response, 'uninstall')
+    const deletedRows = InstalledExtensionSchema.pick({ name: true }).array().parse(response.data)
+    if (deletedRows.length !== 1) {
+      throw new ExtensionPersistenceError(
+        'uninstall',
+        new Error(`Extension ${this.name} is missing or still enabled on a Peer.`)
+      )
+    }
+  }
+
+  private async setPeerEnabled(peerId: string, enabled: boolean): Promise<ExtensionModel> {
+    const response = await ExtensionModel.#dbApi
+      .rpc('set_extension_peer_enabled', {
+        p_name: this.name,
+        p_peer_id: peerId,
+        p_enabled: enabled,
+      })
+      .select(EXTENSION_MANAGEMENT_PROJECTION)
+    assertSuccess(response, enabled ? 'enable Peer' : 'disable Peer')
+    const updated = InstalledExtensionSchema.array().parse(response.data ?? [])[0]
+    if (!updated) {
+      throw new ExtensionPersistenceError(
+        enabled ? 'enable Peer' : 'disable Peer',
+        new Error(`Extension ${this.name} does not exist.`)
+      )
+    }
+    return ExtensionModel.fromRow(updated)
+  }
+
+  private static fromRow(row: unknown): ExtensionModel {
+    return new ExtensionModel(InstalledExtensionSchema.parse(row))
+  }
+}
+
+function assertSuccess(response: { error?: { message: string } | null }, operation: string): void {
+  if (response.error) {
+    throw new ExtensionPersistenceError(
+      operation,
+      new APIError(response.error.message, 0, response.error)
+    )
+  }
+}
 
 /** Setup UI contributed by one already-running Web Extension. */
 export interface ExtensionSetupContribution {
diff --git a/packages/core/src/extension/module-federation.ts b/packages/core/src/extension/module-federation.ts
deleted file mode 100644
index 28ebf0c..0000000
--- a/packages/core/src/extension/module-federation.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-/**
- * Module Federation Abstraction Layer
- *
- * Provides environment-agnostic MF utilities. Apps inject their
- * MF implementation during initialization.
- */
-
-export interface RemoteConfig {
-  name: string
-  entry: string
-  type?: 'module' | 'script'
-}
-
-export interface RegisterRemotesOptions {
-  force?: boolean
-}
-
-export interface MFImplementation {
-  registerRemotes: (remotes: RemoteConfig[], options?: RegisterRemotesOptions) => void
-  loadRemote: <T>(remoteName: string) => Promise<T | null>
-}
-
-let _mfImplementation: MFImplementation | null = null
-
-/**
- * Set the Module Federation implementation.
- * Apps must call this during initialization.
- *
- * @example
- * ```typescript
- * import { init } from "@module-federation/enhanced/runtime";
- * import { setMFImplementation } from "@inkcre/core";
- *
- * const mf = init({...});
- * setMFImplementation({
- *   registerRemotes: (remotes) => mf.registerRemotes(remotes),
- *   loadRemote: (name) => mf.loadRemote(name)
- * });
- * ```
- */
-export function setMFImplementation(impl: MFImplementation): void {
-  _mfImplementation = impl
-}
-
-export function getMFImplementation(): MFImplementation {
-  if (!_mfImplementation) {
-    throw new Error('Module Federation not initialized. Call setMFImplementation() first.')
-  }
-  return _mfImplementation
-}
-
-/**
- * Register remote modules with the MF runtime.
- *
- * @param remotes - Array of remote configuration objects
- * @throws Error if MF not initialized
- */
-export function registerRemotes(remotes: RemoteConfig[], options?: RegisterRemotesOptions): void {
-  getMFImplementation().registerRemotes(remotes, options)
-}
-
-/**
- * Load a remote module.
- *
- * @param remoteName - The name of the remote module to load
- * @returns Promise resolving to the loaded module or null
- * @throws Error if MF not initialized
- */
-export async function loadRemote<T = any>(remoteName: string): Promise<T | null> {
-  return getMFImplementation().loadRemote<T>(remoteName)
-}
-
-/**
- * Check if Module Federation has been initialized.
- */
-export function isMFInitialized(): boolean {
-  return _mfImplementation !== null
-}
diff --git a/packages/core/src/extension/postgrest-state.ts b/packages/core/src/extension/postgrest-state.ts
deleted file mode 100644
index edc4a54..0000000
--- a/packages/core/src/extension/postgrest-state.ts
+++ /dev/null
@@ -1,147 +0,0 @@
-import { APIError, DBAPIClient } from '../base'
-import { InstalledExtensionSchema, type InstalledExtension } from './model'
-import type { ExtensionStatePort } from './state'
-
-const EXTENSION_MANAGEMENT_PROJECTION =
-  'name,version,enabled,nickname,config,config_schema' as const
-
-export class ExtensionStatePersistenceError extends Error {
-  constructor(operation: string, cause?: unknown) {
-    super(
-      `Extension state ${operation} failed${cause instanceof Error ? `: ${cause.message}` : ''}.`
-    )
-    this.name = 'ExtensionStatePersistenceError'
-  }
-}
-
-/** PostgREST transport adapter for the canonical deployment Extension relation. */
-export class PostgrestExtensionStatePort implements ExtensionStatePort {
-  private readonly dbApi = new DBAPIClient<'extensions'>('extensions')
-
-  async list(): Promise<InstalledExtension[]> {
-    const response = await this.dbApi
-      .from()
-      .select(EXTENSION_MANAGEMENT_PROJECTION)
-      .order('name', { ascending: true })
-    assertSuccess(response, 'list')
-    return InstalledExtensionSchema.array().parse(response.data ?? [])
-  }
-
-  async get(name: string): Promise<InstalledExtension | null> {
-    const response = await this.dbApi
-      .from()
-      .select(EXTENSION_MANAGEMENT_PROJECTION)
-      .eq('name', name)
-      .maybeSingle()
-    assertSuccess(response, 'read')
-    return response.data === null ? null : InstalledExtensionSchema.parse(response.data)
-  }
-
-  async install(extension: InstalledExtension): Promise<InstalledExtension> {
-    const exact = InstalledExtensionSchema.parse(extension)
-    const existing = await this.get(exact.name)
-    if (existing) {
-      if (existing.version === exact.version) return existing
-      throw new ExtensionStatePersistenceError(
-        'install',
-        new Error(
-          `${exact.name} is already installed at ${existing.version}; disable every Peer before an explicit version change.`
-        )
-      )
-    }
-
-    const response = await this.dbApi
-      .insert({
-        name: exact.name,
-        version: exact.version,
-        nickname: exact.nickname,
-        config: exact.config,
-        config_schema: exact.config_schema,
-      })
-      .select(EXTENSION_MANAGEMENT_PROJECTION)
-      .single()
-    assertSuccess(response, 'install')
-    return InstalledExtensionSchema.parse(response.data)
-  }
-
-  async updateConfig(name: string, config: Record<string, unknown>): Promise<InstalledExtension> {
-    const response = await this.dbApi
-      .update({ config })
-      .eq('name', name)
-      .select(EXTENSION_MANAGEMENT_PROJECTION)
-      .single()
-    assertSuccess(response, 'update config')
-    return InstalledExtensionSchema.parse(response.data)
-  }
-
-  async changeVersion(
-    name: string,
-    version: string,
-    nickname: string
-  ): Promise<InstalledExtension> {
-    const response = await this.dbApi
-      .update({ version, nickname, config_schema: null })
-      .eq('name', name)
-      .filter('enabled', 'eq', '{}')
-      .select(EXTENSION_MANAGEMENT_PROJECTION)
-      .maybeSingle()
-    assertSuccess(response, 'change version')
-    if (response.data === null) {
-      throw new ExtensionStatePersistenceError(
-        'change version',
-        new Error(`Extension ${name} is missing or still enabled on a Peer.`)
-      )
-    }
-    return InstalledExtensionSchema.parse(response.data)
-  }
-
-  async setPeerEnabled(
-    name: string,
-    peerId: string,
-    enabled: boolean
-  ): Promise<InstalledExtension> {
-    const response = await this.dbApi
-      .rpc('set_extension_peer_enabled', {
-        p_name: name,
-        p_peer_id: peerId,
-        p_enabled: enabled,
-      })
-      .select(EXTENSION_MANAGEMENT_PROJECTION)
-    assertSuccess(response, enabled ? 'enable Peer' : 'disable Peer')
-    const rows = InstalledExtensionSchema.array().parse(response.data ?? [])
-    const updated = rows[0]
-    if (!updated) {
-      throw new ExtensionStatePersistenceError(
-        enabled ? 'enable Peer' : 'disable Peer',
-        new Error(`Extension ${name} does not exist.`)
-      )
-    }
-    return updated
-  }
-
-  async uninstall(name: string): Promise<void> {
-    const response = await this.dbApi
-      .from()
-      .delete()
-      .eq('name', name)
-      .filter('enabled', 'eq', '{}')
-      .select('name')
-    assertSuccess(response, 'uninstall')
-    const deletedRows = InstalledExtensionSchema.pick({ name: true }).array().parse(response.data)
-    if (deletedRows.length !== 1) {
-      throw new ExtensionStatePersistenceError(
-        'uninstall',
-        new Error(`Extension ${name} is missing or still enabled on a Peer.`)
-      )
-    }
-  }
-}
-
-function assertSuccess(response: { error?: { message: string } | null }, operation: string): void {
-  if (response.error) {
-    throw new ExtensionStatePersistenceError(
-      operation,
-      new APIError(response.error.message, 0, response.error)
-    )
-  }
-}
diff --git a/packages/core/src/extension/registry-origin.test.ts b/packages/core/src/extension/registry-origin.test.ts
deleted file mode 100644
index b9c8b31..0000000
--- a/packages/core/src/extension/registry-origin.test.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import {
-  DEFAULT_EXTENSION_REGISTRY_ORIGIN,
-  EXTENSION_REGISTRY_CONFIG_KEY,
-  EXTENSION_REGISTRY_CONFIG_SCHEMA,
-  ExtensionRegistryOriginResolver,
-} from './registry-origin'
-
-function database(result: { data: unknown; error: null | { message: string }; status?: number }) {
-  const maybeSingle = vi.fn(async () => result)
-  const query = {
-    select: vi.fn(() => query),
-    eq: vi.fn(() => query),
-    maybeSingle,
-  }
-  return { from: vi.fn(() => query), query }
-}
-
-describe('ExtensionRegistryOriginResolver', () => {
-  it('uses the current Peer override without reading deployment state', async () => {
-    const db = database({ data: null, error: null })
-    const resolver = new ExtensionRegistryOriginResolver(
-      () => 'https://peer-registry.example/',
-      db as never
-    )
-
-    await expect(resolver.resolve()).resolves.toBe('https://peer-registry.example')
-    expect(db.from).not.toHaveBeenCalled()
-  })
-
-  it('uses the typed deployment config when the Peer has no override', async () => {
-    const db = database({
-      data: {
-        schema: EXTENSION_REGISTRY_CONFIG_SCHEMA,
-        value: { extension_registry_url: 'https://deployment-registry.example/' },
-      },
-      error: null,
-    })
-    const resolver = new ExtensionRegistryOriginResolver(() => '', db as never)
-
-    await expect(resolver.resolve()).resolves.toBe('https://deployment-registry.example')
-    expect(db.query.eq).toHaveBeenCalledWith('key', EXTENSION_REGISTRY_CONFIG_KEY)
-  })
-
-  it('falls back to the public product Registry only when no override exists', async () => {
-    const resolver = new ExtensionRegistryOriginResolver(
-      () => '',
-      database({ data: null, error: null }) as never
-    )
-
-    await expect(resolver.resolve()).resolves.toBe(DEFAULT_EXTENSION_REGISTRY_ORIGIN)
-  })
-
-  it('does not hide a failed deployment-config read behind the product fallback', async () => {
-    const resolver = new ExtensionRegistryOriginResolver(
-      () => '',
-      database({ data: null, error: { message: 'offline' }, status: 503 }) as never
-    )
-
-    await expect(resolver.resolve()).rejects.toThrow('deployment config failed: offline')
-  })
-
-  it('rejects an origin whose authority contains even empty user information', async () => {
-    const resolver = new ExtensionRegistryOriginResolver(
-      () => 'https://@registry.example',
-      database({ data: null, error: null }) as never
-    )
-
-    await expect(resolver.resolve()).rejects.toThrow('one HTTP(S) origin')
-  })
-})
diff --git a/packages/core/src/extension/registry.ts b/packages/core/src/extension/registry.ts
deleted file mode 100644
index af5e4d4..0000000
--- a/packages/core/src/extension/registry.ts
+++ /dev/null
@@ -1,95 +0,0 @@
-import { z } from 'zod'
-import { ExtensionNameSchema, ExtensionVersionSchema } from './model'
-
-const ModuleFederationDistributionSchema = z.object({
-  manifest_url: z.string().min(1),
-  host_sdk: z.literal('@inkcre/core'),
-  host_sdk_version: z.string().min(1),
-})
-
-const PythonDistributionSchema = z.object({
-  project: z.string().min(1),
-  simple_url: z.string().min(1),
-  host_sdk: z.literal('core-py'),
-  host_sdk_version: z.string().min(1),
-  entry_point: z.object({
-    group: z.string().min(1),
-    name: z.string().min(1),
-    object: z.string().min(1),
-  }),
-})
-
-export const ExtensionReleaseSchema = z.object({
-  name: ExtensionNameSchema,
-  nickname: z.string(),
-  version: ExtensionVersionSchema,
-  state: z.enum(['preparing', 'published', 'yanked', 'blocked']),
-  python: PythonDistributionSchema.nullish(),
-  module_federation: ModuleFederationDistributionSchema.nullish(),
-})
-
-export type ExtensionRelease = z.infer<typeof ExtensionReleaseSchema>
-export type ModuleFederationDistribution = z.infer<typeof ModuleFederationDistributionSchema>
-
-export interface ExtensionReleaseReader {
-  get(name: string, version: string): Promise<ExtensionRelease>
-}
-
-/** Public exact-Release reader for the Registry control plane. */
-export class RegistryExtensionReleaseReader implements ExtensionReleaseReader {
-  private readonly fetchImplementation: typeof globalThis.fetch
-  private readonly registryOrigin: () => string | Promise<string>
-
-  constructor(
-    registryOrigin: string | (() => string | Promise<string>),
-    fetchImplementation: typeof globalThis.fetch = globalThis.fetch
-  ) {
-    this.registryOrigin =
-      typeof registryOrigin === 'function' ? registryOrigin : () => registryOrigin
-    this.fetchImplementation = fetchImplementation.bind(globalThis)
-  }
-
-  async get(name: string, version: string): Promise<ExtensionRelease> {
-    const [namespace, localName] = splitExtensionName(ExtensionNameSchema.parse(name))
-    const exactVersion = ExtensionVersionSchema.parse(version)
-    const registryUrl = await this.registryUrl()
-    const location = new URL(
-      `/v1/extensions/${encodeURIComponent(namespace)}/${encodeURIComponent(localName)}/releases/${encodeURIComponent(exactVersion)}`,
-      registryUrl
-    )
-    const response = await this.fetchImplementation(location, {
-      headers: { Accept: 'application/json' },
-    })
-    if (!response.ok) {
-      throw new Error(`Extension Registry release request failed with HTTP ${response.status}.`)
-    }
-
-    const release = ExtensionReleaseSchema.parse(await response.json())
-    if (release.name !== name || release.version !== exactVersion) {
-      throw new Error('Extension Registry returned a different exact Release coordinate.')
-    }
-    const distribution = release.module_federation
-    if (!distribution) return release
-    const manifest = new URL(distribution.manifest_url, registryUrl)
-    if (manifest.origin !== registryUrl.origin) {
-      throw new Error('Module Federation manifest must be hosted by the configured Registry.')
-    }
-    return {
-      ...release,
-      module_federation: { ...distribution, manifest_url: manifest.href },
-    }
-  }
-
-  private async registryUrl(): Promise<URL> {
-    const registryOrigin = await this.registryOrigin()
-    if (!registryOrigin) {
-      throw new Error('Extension Registry URL is not configured.')
-    }
-    return new URL(registryOrigin)
-  }
-}
-
-function splitExtensionName(name: string): [string, string] {
-  const [namespace, localName] = name.split('/')
-  return [namespace, localName]
-}
diff --git a/packages/core/src/extension/state.ts b/packages/core/src/extension/state.ts
deleted file mode 100644
index ba8c5c0..0000000
--- a/packages/core/src/extension/state.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import type { InstalledExtension } from './model'
-
-/**
- * Deployment Extension state as operations, independent of SQL, PostgREST,
- * generated table types, and transport routes.
- */
-export interface ExtensionStatePort {
-  list(): Promise<InstalledExtension[]>
-  get(name: string): Promise<InstalledExtension | null>
-  install(extension: InstalledExtension): Promise<InstalledExtension>
-  changeVersion(name: string, version: string, nickname: string): Promise<InstalledExtension>
-  updateConfig(name: string, config: Record<string, unknown>): Promise<InstalledExtension>
-  setPeerEnabled(name: string, peerId: string, enabled: boolean): Promise<InstalledExtension>
-  uninstall(name: string): Promise<void>
-}
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 5e30401..f621a60 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -20,34 +20,15 @@ export {
   ExtensionVersionSchema,
   InstalledExtensionSchema,
   InstallExtensionInputSchema,
+  ExtensionModel,
+  ExtensionPersistenceError,
   type ExtensionModule,
   type ExtensionSetupContribution,
   type InstalledExtension,
   type InstallExtensionInput,
-  setMFImplementation,
-  getMFImplementation,
-  registerRemotes,
-  loadRemote,
-  isMFInitialized,
-  type RemoteConfig,
-  type RegisterRemotesOptions,
-  type MFImplementation,
-  ExtensionReleaseSchema,
-  RegistryExtensionReleaseReader,
+  type ExtensionModelInstallInput,
   ExtensionRegistryOriginResolver,
   DEFAULT_EXTENSION_REGISTRY_ORIGIN,
-  type ExtensionRelease,
-  type ModuleFederationDistribution,
-  type ExtensionReleaseReader,
-  type ExtensionStatePort,
-  PostgrestExtensionStatePort,
-  ExtensionStatePersistenceError,
-  WebExtensionHost,
-  WebExtensionHostError,
-  WebExtensionIncompatibleError,
-  WebExtensionEnabledError,
-  webExtensionRemoteName,
-  type WebExtensionHostOptions,
 } from './extension'
 
 // Peer discovery and delegation
diff --git a/packages/core/src/peer/runtime.test.ts b/packages/core/src/peer/runtime.test.ts
deleted file mode 100644
index 303800d..0000000
--- a/packages/core/src/peer/runtime.test.ts
+++ /dev/null
@@ -1,104 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { PeerConfigSchema } from '../config'
-import { WEB_PEER_LEASE_RENEW_INTERVAL_MS, WebPeerRuntime } from './runtime'
-
-const peerId = '00000000-0000-4000-8000-000000000001'
-
-function peerRow(config: Record<string, unknown> = {}) {
-  return {
-    id: peerId,
-    name: 'Client Web',
-    labels: ['owner-label'],
-    config,
-    config_schema: {},
-    capabilities: [],
-    lease_expires_at: '2099-01-01T00:00:00Z',
-    created_at: '2026-01-01T00:00:00Z',
-    updated_at: '2026-01-01T00:00:00Z',
-  }
-}
-
-function database() {
-  const rpc = vi.fn(async (name: string, args: Record<string, unknown>) => {
-    void name
-    void args
-    return { data: '2099-01-01T00:00:00Z', error: null }
-  })
-  const single = vi.fn(async () => ({ data: peerRow(PeerConfigSchema.parse({})), error: null }))
-  const select = vi.fn(() => ({ single }))
-  const eq = vi.fn(() => ({ select }))
-  const update = vi.fn((payload: Record<string, unknown>) => {
-    void payload
-    return { eq }
-  })
-  const upsert = vi.fn((payload: Record<string, unknown>) => {
-    void payload
-    return { select }
-  })
-  return { rpc, update, upsert, eq, select, single }
-}
-
-describe('WebPeerRuntime', () => {
-  afterEach(() => {
-    vi.useRealTimers()
-  })
-
-  it('upserts only runtime-owned fields and preserves owner-managed labels and config', async () => {
-    const db = database()
-    const runtime = new WebPeerRuntime(peerId, db as never)
-
-    await expect(runtime.register()).resolves.toMatchObject({
-      id: peerId,
-      labels: ['owner-label'],
-      config: {},
-    })
-    expect(db.upsert).toHaveBeenCalledWith({
-      id: peerId,
-      name: 'Client Web',
-      config_schema: expect.any(Object),
-      capabilities: [],
-    })
-    expect(Object.keys(db.upsert.mock.calls[0]?.[0] ?? {})).toEqual([
-      'id',
-      'name',
-      'config_schema',
-      'capabilities',
-    ])
-  })
-
-  it('renews one registered Peer lease and stops browser-owned renewal cleanly', async () => {
-    vi.useFakeTimers()
-    const db = database()
-    const runtime = new WebPeerRuntime(peerId, db as never)
-
-    await runtime.start()
-    expect(db.rpc.mock.calls.map(([name]) => name)).toEqual(['renew_peer_lease'])
-
-    await vi.advanceTimersByTimeAsync(WEB_PEER_LEASE_RENEW_INTERVAL_MS)
-    expect(db.rpc.mock.calls.map(([name]) => name)).toEqual([
-      'renew_peer_lease',
-      'renew_peer_lease',
-    ])
-
-    runtime.stop()
-    await vi.advanceTimersByTimeAsync(WEB_PEER_LEASE_RENEW_INTERVAL_MS)
-    expect(db.rpc).toHaveBeenCalledTimes(2)
-    expect(db.rpc).toHaveBeenNthCalledWith(1, 'renew_peer_lease', {
-      peer: peerId,
-      ttl_seconds: 90,
-    })
-  })
-
-  it('writes only the owner-managed Peer config field', async () => {
-    const db = database()
-    const runtime = new WebPeerRuntime(peerId, db as never)
-    const config = PeerConfigSchema.parse({
-      extension_registry_url: 'https://registry.operator.example',
-    })
-
-    await runtime.saveConfig(config)
-
-    expect(db.update).toHaveBeenCalledWith({ config })
-    expect(db.eq).toHaveBeenCalledWith('id', peerId)
-  })
-})
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 43a8cc5..963c264 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -110,6 +110,9 @@ importers:
       '@inkcre/core':
         specifier: workspace:*
         version: link:../../packages/core
+      '@inkcre/extension-runtime-client-web':
+        specifier: https://github.com/InKCre/ext-reg/releases/download/runtime-client-web-v0.1.0/inkcre-extension-runtime-client-web-0.1.0.tgz
+        version: https://github.com/InKCre/ext-reg/releases/download/runtime-client-web-v0.1.0/inkcre-extension-runtime-client-web-0.1.0.tgz(@inkcre/core@packages+core)(@module-federation/runtime@0.21.6)
       '@inkcre/ui-web':
         specifier: 1.4.0
         version: 1.4.0(@codemirror/autocomplete@6.20.3)(@codemirror/commands@6.10.4)(@codemirror/lang-json@6.0.2)(@codemirror/lint@6.9.7)(@codemirror/state@6.7.1)(@codemirror/view@6.43.6)(@vueuse/core@14.3.0(vue@3.5.40(typescript@5.9.3)))(dayjs@1.11.21)(unocss@66.7.5(vite@7.3.6(@types/node@22.17.2)(jiti@2.7.0)(lightningcss@1.33.0)(sass-embedded@1.90.0)(sass@1.101.6)(yaml@2.9.0)))(vscode-json-languageservice@5.7.2)(vscode-languageserver-textdocument@1.0.12)(vue-router@4.5.1(vue@3.5.40(typescript@5.9.3)))(vue@3.5.40(typescript@5.9.3))
@@ -1344,6 +1347,13 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@inkcre/extension-runtime-client-web@https://github.com/InKCre/ext-reg/releases/download/runtime-client-web-v0.1.0/inkcre-extension-runtime-client-web-0.1.0.tgz':
+    resolution: {integrity: sha512-UGDxtoN6Pcv+NCbr8InejfGg6UdvtCrZU7dZsx+Yev/aXmyA1YChfY7VicJTJRr5UIs9JbWe1smNwH1UB/bYQw==, tarball: https://github.com/InKCre/ext-reg/releases/download/runtime-client-web-v0.1.0/inkcre-extension-runtime-client-web-0.1.0.tgz}
+    version: 0.1.0
+    peerDependencies:
+      '@inkcre/core': '>=0.1.2 <0.2.0'
+      '@module-federation/runtime': '>=0.21.4 <0.23.0'
+
   '@inkcre/ui-web@1.4.0':
     resolution: {integrity: sha512-Sq5f/hFpOtuGNZwVB36JuMPoAJUvkWvrHogl/PauI4OuV2M/qExdVXrEZa76pbbn35Ic/dleEPyze6lJghxI5w==, tarball: https://npm.pkg.github.com/download/@inkcre/ui-web/1.4.0/356469307437642b43b7e67e82c9b60e52d4f926}
     peerDependencies:
@@ -6343,6 +6353,9 @@ packages:
       yaml:
         optional: true
 
+  zod@4.1.12:
+    resolution: {integrity: sha512-JInaHOamG8pt5+Ey8kGmdcAcg3OL9reK8ltczgHTAwNhMys/6ThXHityHxVV2p3fkw/c+MAvBHFVYHFZDmjMCQ==}
+
   zod@4.4.3:
     resolution: {integrity: sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==}
 
@@ -7240,6 +7253,13 @@ snapshots:
   '@img/sharp-win32-x64@0.35.2':
     optional: true
 
+  '@inkcre/extension-runtime-client-web@https://github.com/InKCre/ext-reg/releases/download/runtime-client-web-v0.1.0/inkcre-extension-runtime-client-web-0.1.0.tgz(@inkcre/core@packages+core)(@module-federation/runtime@0.21.6)':
+    dependencies:
+      '@inkcre/core': link:packages/core
+      '@module-federation/runtime': 0.21.6
+      semver: 7.8.5
+      zod: 4.1.12
+
   '@inkcre/ui-web@1.4.0(@codemirror/autocomplete@6.20.3)(@codemirror/commands@6.10.4)(@codemirror/lang-json@6.0.2)(@codemirror/lint@6.9.7)(@codemirror/state@6.7.1)(@codemirror/view@6.43.6)(@vueuse/core@14.3.0(vue@3.5.40(typescript@5.9.3)))(dayjs@1.11.21)(unocss@66.7.5(vite@7.3.6(@types/node@22.17.2)(jiti@2.7.0)(lightningcss@1.33.0)(sass-embedded@1.90.0)(sass@1.101.6)(yaml@2.9.0)))(vscode-json-languageservice@5.7.2)(vscode-languageserver-textdocument@1.0.12)(vue-router@4.5.1(vue@3.5.40(typescript@5.9.3)))(vue@3.5.40(typescript@5.9.3))':
     dependencies:
       '@codemirror/autocomplete': 6.20.3
@@ -11987,4 +12007,6 @@ snapshots:
       json5: 2.2.3
       yaml: 2.9.0
 
+  zod@4.1.12: {}
+
   zod@4.4.3: {}

From a01d3270b365c60dcf73ab113046afb563d178ed Mon Sep 17 00:00:00 2001
From: Lan_zhijiang <lanzhijiang@foxmail.com>
Date: Mon, 24 Aug 2026 11:40:29 +0800
Subject: [PATCH 5/9] fix(preview): consume static Registry route support

- upgrade the frozen Extension Toolkit to 0.2.1\n- rebuild the PDM lock from the independent release
---
 pdm.lock       | 31 +++++++++++++++++++++++--------
 pyproject.toml |  2 +-
 2 files changed, 24 insertions(+), 9 deletions(-)

diff --git a/pdm.lock b/pdm.lock
index 009e99e..a13054f 100644
--- a/pdm.lock
+++ b/pdm.lock
@@ -5,7 +5,7 @@
 groups = ["default"]
 strategy = ["inherit_metadata"]
 lock_version = "4.5.0"
-content_hash = "sha256:3127c3420995e55bce316643f65d2fcad0c590495101c40b5d5e9eacd3a69410"
+content_hash = "sha256:bb96fd8f2ae26ebe087a8994dd781ca818e851daa167633222c620945f45a29a"
 
 [[metadata.targets]]
 requires_python = "==3.13.*"
@@ -141,9 +141,9 @@ files = [
 
 [[package]]
 name = "inkcre-extension-toolkit"
-version = "0.1.0"
+version = "0.2.1"
 requires_python = "<3.14,>=3.12"
-url = "https://github.com/InKCre/ext-reg/releases/download/toolkit-v0.1.0/inkcre_extension_toolkit-0.1.0-py3-none-any.whl"
+url = "https://github.com/InKCre/ext-reg/releases/download/toolkit-v0.2.1/inkcre_extension_toolkit-0.2.1-py3-none-any.whl"
 summary = "Developer and delivery tooling for InKCre Extensions"
 groups = ["default"]
 dependencies = [
@@ -152,24 +152,25 @@ dependencies = [
     "semantic-version<3,>=2.10",
 ]
 files = [
-    {file = "inkcre_extension_toolkit-0.1.0-py3-none-any.whl", hash = "sha256:7ab1de5160d0bafbdf9f99b6b2a2b156a406b6f6afe14dc0342073620299bd64"},
+    {file = "inkcre_extension_toolkit-0.2.1-py3-none-any.whl", hash = "sha256:fffaad86db43d998731bfee69e992fa02d18ea2b428fdd00bda5ed6e311bf3de"},
 ]
 
 [[package]]
 name = "inkcre-extension-toolkit"
-version = "0.1.0"
+version = "0.2.1"
 extras = ["cli"]
 requires_python = "<3.14,>=3.12"
-url = "https://github.com/InKCre/ext-reg/releases/download/toolkit-v0.1.0/inkcre_extension_toolkit-0.1.0-py3-none-any.whl"
+url = "https://github.com/InKCre/ext-reg/releases/download/toolkit-v0.2.1/inkcre_extension_toolkit-0.2.1-py3-none-any.whl"
 summary = "Developer and delivery tooling for InKCre Extensions"
 groups = ["default"]
 dependencies = [
     "httpx<0.29,>=0.28",
-    "inkcre-extension-toolkit @ https://github.com/InKCre/ext-reg/releases/download/toolkit-v0.1.0/inkcre_extension_toolkit-0.1.0-py3-none-any.whl",
+    "inkcre-extension-toolkit @ https://github.com/InKCre/ext-reg/releases/download/toolkit-v0.2.1/inkcre_extension_toolkit-0.2.1-py3-none-any.whl",
     "typer<0.22,>=0.21",
+    "wheel<0.48,>=0.46",
 ]
 files = [
-    {file = "inkcre_extension_toolkit-0.1.0-py3-none-any.whl", hash = "sha256:7ab1de5160d0bafbdf9f99b6b2a2b156a406b6f6afe14dc0342073620299bd64"},
+    {file = "inkcre_extension_toolkit-0.2.1-py3-none-any.whl", hash = "sha256:fffaad86db43d998731bfee69e992fa02d18ea2b428fdd00bda5ed6e311bf3de"},
 ]
 
 [[package]]
@@ -342,3 +343,17 @@ files = [
     {file = "typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147"},
     {file = "typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47"},
 ]
+
+[[package]]
+name = "wheel"
+version = "0.47.0"
+requires_python = ">=3.9"
+summary = "Command line tool for manipulating wheel files"
+groups = ["default"]
+dependencies = [
+    "packaging>=24.0",
+]
+files = [
+    {file = "wheel-0.47.0-py3-none-any.whl", hash = "sha256:212281cab4dff978f6cedd499cd893e1f620791ca6ff7107cf270781e587eced"},
+    {file = "wheel-0.47.0.tar.gz", hash = "sha256:cc72bd1009ba0cf63922e28f94d9d83b920aa2bb28f798a31d0691b02fa3c9b3"},
+]
diff --git a/pyproject.toml b/pyproject.toml
index 95bf6c8..d6a6b93 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,7 +5,7 @@ description = "Repository-level development tooling for the InKCre Web monorepo"
 requires-python = ">=3.13,<3.14"
 # Gate: generate and commit pdm.lock only after this immutable Toolkit wheel is published.
 dependencies = [
-  "inkcre-extension-toolkit[cli] @ https://github.com/InKCre/ext-reg/releases/download/toolkit-v0.1.0/inkcre_extension_toolkit-0.1.0-py3-none-any.whl",
+  "inkcre-extension-toolkit[cli] @ https://github.com/InKCre/ext-reg/releases/download/toolkit-v0.2.1/inkcre_extension_toolkit-0.2.1-py3-none-any.whl",
 ]
 
 [tool.pdm]

From 4c3f107d473cc3f348f1f611cad9fbd4569a2889 Mon Sep 17 00:00:00 2001
From: Lan_zhijiang <lanzhijiang@foxmail.com>
Date: Mon, 24 Aug 2026 11:46:01 +0800
Subject: [PATCH 6/9] fix(twitter): align Web Distribution release

- publish the setup wizard Module Federation snapshot as 0.2.0\n- keep the Web and Core distributions in one Extension release
---
 extensions/twitter/CHANGELOG.md | 6 ++++++
 extensions/twitter/package.json | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/extensions/twitter/CHANGELOG.md b/extensions/twitter/CHANGELOG.md
index b5bb938..98f2127 100644
--- a/extensions/twitter/CHANGELOG.md
+++ b/extensions/twitter/CHANGELOG.md
@@ -1,5 +1,11 @@
 # @inkcre/ext-twitter
 
+## 0.2.0
+
+### Minor Changes
+
+- Add the Extension-owned multi-step setup wizard for OAuth, Bookmark Sources, and scheduling.
+
 ## 0.1.2
 
 ### Patch Changes
diff --git a/extensions/twitter/package.json b/extensions/twitter/package.json
index 25f0f93..24e8e4a 100644
--- a/extensions/twitter/package.json
+++ b/extensions/twitter/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@inkcre/ext-twitter",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "private": true,
   "type": "module",
   "scripts": {

From 1071a8f242de17734008e93a483a2a43dda32bd8 Mon Sep 17 00:00:00 2001
From: Lan_zhijiang <lanzhijiang@foxmail.com>
Date: Mon, 24 Aug 2026 21:31:47 +0800
Subject: [PATCH 7/9] =?UTF-8?q?fix(peer):=20=E5=94=A4=E9=86=92=20HTTP=20Pe?=
 =?UTF-8?q?er=20=E5=90=8E=E5=88=B7=E6=96=B0=E7=A7=9F=E7=BA=A6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Check Health 主动请求公开 readyz 端点
- 数据库 lease 继续作为在线状态权威
---
 .../src/components/peer/peerList/peerList.vue       |  2 +-
 packages/core/src/peer/manager.ts                   | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/apps/client-web/src/components/peer/peerList/peerList.vue b/apps/client-web/src/components/peer/peerList/peerList.vue
index 04386a1..e522cfc 100644
--- a/apps/client-web/src/components/peer/peerList/peerList.vue
+++ b/apps/client-web/src/components/peer/peerList/peerList.vue
@@ -18,7 +18,7 @@ const healthCheckLoading = ref(false)
 const checkAllHealth = async () => {
   healthCheckLoading.value = true
   try {
-    livePeers.value = new Set((await PeerManager.listLive()).map((peer) => peer.id))
+    livePeers.value = new Set((await PeerManager.checkHealth(peers.value)).map((peer) => peer.id))
   } finally {
     healthCheckLoading.value = false
   }
diff --git a/packages/core/src/peer/manager.ts b/packages/core/src/peer/manager.ts
index 41a46f3..436873e 100644
--- a/packages/core/src/peer/manager.ts
+++ b/packages/core/src/peer/manager.ts
@@ -91,6 +91,19 @@ export class PeerManager {
     return (result.data ?? []).map((row) => Peer.parse(row))
   }
 
+  static async checkHealth(peers: Peer[]): Promise<Peer[]> {
+    await Promise.allSettled(
+      peers.map((peer) => {
+        const publicBaseURL = peer.config.http_public_base_url
+        if (typeof publicBaseURL !== 'string') return Promise.resolve()
+        return fetch(new URL('/readyz', publicBaseURL), {
+          signal: AbortSignal.timeout(configStore.peerConfig.peer_http_timeout_ms),
+        })
+      })
+    )
+    return PeerManager.listLive()
+  }
+
   private static async candidates(
     capability: CapabilityID,
     routeToPeer: PeerRef | null

From 2083fde96744ffdd87a90bec75cbf920d9c361bc Mon Sep 17 00:00:00 2001
From: Lan_zhijiang <lanzhijiang@foxmail.com>
Date: Mon, 24 Aug 2026 21:32:57 +0800
Subject: [PATCH 8/9] =?UTF-8?q?fix(peer):=20=E4=BF=9D=E7=95=99=E5=81=A5?=
 =?UTF-8?q?=E5=BA=B7=E7=AB=AF=E7=82=B9=E8=B7=AF=E5=BE=84=E5=89=8D=E7=BC=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 相对 Peer public base URL 拼接 readyz
- 将无效 Peer URL 隔离为单项探测失败
---
 packages/core/src/peer/manager.ts | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/packages/core/src/peer/manager.ts b/packages/core/src/peer/manager.ts
index 436873e..3d2cd70 100644
--- a/packages/core/src/peer/manager.ts
+++ b/packages/core/src/peer/manager.ts
@@ -93,10 +93,11 @@ export class PeerManager {
 
   static async checkHealth(peers: Peer[]): Promise<Peer[]> {
     await Promise.allSettled(
-      peers.map((peer) => {
+      peers.map(async (peer) => {
         const publicBaseURL = peer.config.http_public_base_url
-        if (typeof publicBaseURL !== 'string') return Promise.resolve()
-        return fetch(new URL('/readyz', publicBaseURL), {
+        if (typeof publicBaseURL !== 'string') return
+        const baseURL = publicBaseURL.endsWith('/') ? publicBaseURL : `${publicBaseURL}/`
+        await fetch(new URL('readyz', baseURL), {
           signal: AbortSignal.timeout(configStore.peerConfig.peer_http_timeout_ms),
         })
       })

From 96fe322e3377dad3e0198697e259e782ac99b6b0 Mon Sep 17 00:00:00 2001
From: Lan_zhijiang <lanzhijiang@foxmail.com>
Date: Mon, 24 Aug 2026 21:58:40 +0800
Subject: [PATCH 9/9] =?UTF-8?q?fix(twitter):=20=E6=98=BE=E5=BC=8F=E6=9E=84?=
 =?UTF-8?q?=E9=80=A0=20setup=20Peer=20=E8=AF=B7=E6=B1=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 保留 TwitterSetupAPI 作为领域 facade
- 区分无 body 请求与 JSON body 请求
- 公开既有 Peer request schema 供调用方推导输入类型
---
 extensions/twitter/src/setup-api.ts | 32 ++++++++++++++++-------------
 packages/core/src/index.ts          |  1 +
 2 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/extensions/twitter/src/setup-api.ts b/extensions/twitter/src/setup-api.ts
index bbec90d..5357059 100644
--- a/extensions/twitter/src/setup-api.ts
+++ b/extensions/twitter/src/setup-api.ts
@@ -5,6 +5,7 @@ import {
   ExtensionModel,
   Peer,
   PeerManager,
+  PeerProtocolRequestSchema,
   PeerProtocolResponseSchema,
   Source,
   SourceForm,
@@ -22,6 +23,7 @@ const TWITTER_OAUTH_TRANSACTION_READ_CAPABILITY = 'inkcre.twitter.oauth.transact
 const TWITTER_OAUTH_DISCONNECT_CAPABILITY = 'inkcre.twitter.oauth.disconnect.v1'
 const BOOKMARK_SOURCE_TYPE = 'extensions.twitter.bookmark.Source'
 const SOURCE_COLLECT_JOB_TYPE = 'core.source.collect.v1'
+type TwitterPeerRequest = z.input<typeof PeerProtocolRequestSchema>
 
 function hasAuthorityUserInfo(value: string): boolean {
   return /^[a-z][a-z0-9+.-]*:\/\/[^/?#]*@/i.test(value)
@@ -99,17 +101,17 @@ export class TwitterSetupAPI {
   constructor(readonly peer: Peer) {}
 
   enableCore(signal?: AbortSignal): Promise<InstalledExtension> {
-    return executeCapability(
+    return delegateTwitterRequest(
       this.peer,
       EXTENSION_MANAGEMENT_CAPABILITY,
-      { action: 'enable', extension: EXTENSION_NAME },
+      { body: { action: 'enable', extension: EXTENSION_NAME } },
       InstalledExtensionSchema,
       signal
     )
   }
 
   status(signal?: AbortSignal): Promise<TwitterSetupStatus> {
-    return executeCapability(
+    return delegateTwitterRequest(
       this.peer,
       TWITTER_SETUP_STATUS_CAPABILITY,
       {},
@@ -124,13 +126,15 @@ export class TwitterSetupAPI {
     confirmAccountReset: boolean,
     signal?: AbortSignal
   ): Promise<TwitterSetupStatus> {
-    return executeCapability(
+    return delegateTwitterRequest(
       this.peer,
       TWITTER_OAUTH_APP_CONFIGURE_CAPABILITY,
       {
-        client_id: clientId,
-        client_secret: clientSecret,
-        confirm_account_reset: confirmAccountReset,
+        body: {
+          client_id: clientId,
+          client_secret: clientSecret,
+          confirm_account_reset: confirmAccountReset,
+        },
       },
       TwitterSetupStatusSchema,
       signal
@@ -138,7 +142,7 @@ export class TwitterSetupAPI {
   }
 
   beginOAuth(signal?: AbortSignal): Promise<OAuthTransaction> {
-    return executeCapability(
+    return delegateTwitterRequest(
       this.peer,
       TWITTER_OAUTH_BEGIN_CAPABILITY,
       {},
@@ -148,17 +152,17 @@ export class TwitterSetupAPI {
   }
 
   oauthTransaction(transactionId: string, signal?: AbortSignal): Promise<OAuthTransaction> {
-    return executeCapability(
+    return delegateTwitterRequest(
       this.peer,
       TWITTER_OAUTH_TRANSACTION_READ_CAPABILITY,
-      { transaction_id: transactionId },
+      { body: { transaction_id: transactionId } },
       OAuthTransactionSchema,
       signal
     )
   }
 
   disconnect(signal?: AbortSignal): Promise<TwitterSetupStatus> {
-    return executeCapability(
+    return delegateTwitterRequest(
       this.peer,
       TWITTER_OAUTH_DISCONNECT_CAPABILITY,
       {},
@@ -227,15 +231,15 @@ export class TwitterBookmarkSetup {
   }
 }
 
-async function executeCapability<Result>(
+async function delegateTwitterRequest<Result>(
   peer: Peer,
   capability: string,
-  command: JsonValue,
+  request: TwitterPeerRequest,
   schema: z.ZodType<Result>,
   signal?: AbortSignal
 ): Promise<Result> {
   signal?.throwIfAborted()
-  const delegated = await PeerManager.delegate(capability, { body: command }, peer.id)
+  const delegated = await PeerManager.delegate(capability, request as JsonValue, peer.id)
   signal?.throwIfAborted()
   const response = PeerProtocolResponseSchema.parse(delegated)
   if (response.status < 200 || response.status >= 300 || response.body === undefined) {
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index f621a60..f94053b 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -46,6 +46,7 @@ export {
   type CapabilityID,
   type JsonValue,
   type PeerProtocolRequest,
+  PeerProtocolRequestSchema,
   type PeerProtocolResponse,
   PeerProtocolResponseSchema,
   type PeerRef,