dsh-mcp-pill 0.2.4 → 0.2.8

package/README.md

@@ -2,7 +2,7 @@
 
 ## English
 
-**Current release: 0.2.3** — Remote settings are capability-detected and optional, so older DSH RC hosts continue to start the plugin.
+**Current release: 0.2.6** — Portable settings transport: the plugin now resolves its settings scope on both the `settingsScope` (≤ 0.1.5) and `configForms` (≥ 0.1.7-rc.1) hosts, so the Settings card keeps working across the rename.
 
 A lifecycle-safe MCP connection status pill for DeepSeek Harness Web. It exposes loopback-fenced status/toggle RPC, an official Settings card, and a composer-seat pill that stays hidden until enabled. DSH 0.1.2+ fine-grained `remote.settings` is preferred; older RC hosts use the legacy connection API.
 
@@ -18,10 +18,16 @@ Global MCP connection status pill for the DSH web UI — official bundle form
 - `POST /api/mcp-pill/set` — `{ id, enabled }` toggles a connection via the
   patch file's `disabled` marker (loader HMR applies it).
 - The pill is hidden by DEFAULT. An official-style expandable Settings Card
-  (`settings.plugin.item` / key `mcp-pill`) owns one switch,
-  「显示状态胶囊」(`pill.enabled`, default `false`); while it is off the pill
-  never mounts visibly, and toggling it takes effect within one status poll
-  (instantly after a save in the same tab).
+  owns one switch, 「显示状态胶囊」(`pill.enabled`, default `false`); while it is
+  off the pill never mounts visibly, and toggling it takes effect within one
+  status poll (instantly after a save in the same tab).
+- That card registers on BOTH settings seats, because DSH moved it: the keyed
+  row seat `plugins.row.config` (key `dsh-mcp-pill#mcp-pill`) on
+  DSH ≥ 0.1.7-rc.2, and the legacy item seat `settings.plugin.item`
+  (key `mcp-pill`) on ≤ 0.1.5. Each seat is declared by one host only, so the two
+  registrations coexist with no version sniffing and the card always has a home;
+  values keep flowing through the single settings transport
+  (`settingsScope` on ≤ 0.1.5, `configForms` on ≥ 0.1.7).
 - The pill snaps to one of the chat input's four corners (drag to switch);
   the anchor is remembered in `localStorage` (`dsh.mcpPill.anchor`).
 - The pill mounts inside the composer seat (same stacking level as the input
@@ -30,8 +36,19 @@ Global MCP connection status pill for the DSH web UI — official bundle form
 
 ## Install
 
-Add to the profile's `package.json` dependencies (`link:` for local dev) and
-to `dsh.profile.bundles`, then `pnpm install` and restart `dsh web`.
+```powershell
+dsh plugin --profile web add dsh-mcp-pill
+```
+
+Restart the existing DSH Web process afterwards: the Host scans the browser plugin roster at startup, so the pill and its Settings card appear only after that restart. Then open the card — on ≤ 0.1.5 it is a card in **Settings → Plugins**; on ≥ 0.1.7-rc.2 open the **插件** panel (the first sidebar panel icon), find the `dsh-mcp-pill` bundle and use the `mcp-pill` row's configure control — and turn on「显示状态胶囊」; the pill is hidden by default.
+
+Local development, from this package directory:
+
+```powershell
+dsh plugin --profile web add .
+```
+
+Either form records the package in the profile's `dsh.profile.bundles`, which is what mounts the Host half and serves the client bundle.
 
 ## Config
 

package/lib/client.js

@@ -6,9 +6,12 @@
 // remembered in localStorage.
 //
 // The pill is hidden by DEFAULT: an official-style expandable Settings Card
-// under settings.plugin.item / key mcp-pill owns the「显示状态胶囊」switch
-// (pill.enabled, default false), and the polled /api/mcp-pill/status payload
-// (`pill.enabled`, hot host mirror) decides whether the pill shows at all.
+// owns the「显示状态胶囊」switch (pill.enabled, default false). The same card is
+// registered on BOTH settings seats, because DSH moved it when 0.1.7-rc.2
+// removed the old one: `settings.plugin.item` / key `mcp-pill` on ≤ 0.1.5, and
+// the keyed row seat `plugins.row.config` / key ROW_CONFIG_KEY on ≥ 0.1.7-rc.2.
+// The polled /api/mcp-pill/status payload (`pill.enabled`, hot host mirror)
+// decides whether the pill shows at all.
 //
 // Lifecycle: every DOM node, observer, timer, rAF and listener created by
 // startPill() is registered with the idempotent disposer returned through
@@ -25,6 +28,54 @@ window.__ModuleLoader__.load({
 
     const NS = 'mcp-pill'
     const API = '/api/mcp-pill'
+
+    // ── the rc.2 settings seat key ───────────────────────────────────────────
+    //
+    // DSH 0.1.7-rc.2 REMOVED the slot `settings.plugin.item` — the seat this
+    // card registers on for ≤ 0.1.5. On the corridor a bundle ROW's
+    // configuration seat is the keyed slot `plugins.row.config`, and the
+    // official plugin-manager shows a row's configure control only when the
+    // EXACT key below sits on that slot's registration ledger:
+    //
+    //     rowConfigKey(pkg.name, row.rowId) → `${pkg.name}#${row.rowId}`
+    //     has: (row) => ledger.rows.has(rowConfigKey(pkg.name, row.rowId))
+    //
+    // So the key IS the contract: the package name from package.json plus the
+    // row id this package's own cordis.patch.yml declares. It lives in one
+    // constant, is exported for inspection, and test/client-lifecycle.test.mjs
+    // re-derives both halves from those two files and fails on any drift.
+    const ROW_CONFIG_KEY = 'dsh-mcp-pill#mcp-pill'
+
+    // ── settings-scope portability (DSH 0.1.5 ↔ 0.1.7-rc.1) ──────────────────
+    //
+    // The two supported hosts expose the same scope CONTRACT under different
+    // service names, so the adapter lives here instead of in every call site:
+    //
+    //   ≤ 0.1.5  settingsScope.bind({ namespace })  → SettingsScope<T>
+    //   ≥ 0.1.7  configForms.get(entryId)           → ConfigForm<T>
+    //
+    // Both return getSnapshot()/subscribe()/set()/unset()/mutate() over the same
+    // { status, value, base, user, revision, writable, mode } snapshot, so the
+    // resolved object is used unchanged by the card, the pill and the tests.
+    //
+    // NEITHER name may appear in `exports.inject`. cordis treats every inject
+    // name as a REQUIRED gate — `Fiber._refresh()` marks the fiber INACTIVE when
+    // any single name has no provider — so declaring both would leave this
+    // plugin permanently pending on every host, and declaring either one would
+    // block the other host. The optional transport is therefore awaited inside
+    // apply with `ctx.inject([...], cb)`, which is a NON-GATING wait: apply runs
+    // regardless, and the callback fires whenever the service arrives (including
+    // late registration).
+    //
+    // For this plugin the settings namespace and the profile entry id are both
+    // 'mcp-pill', so one key resolves on either host.
+    function resolveSettingsScopeFrom(ctx, namespace) {
+      const binder = ctx.get('settingsScope')
+      if (binder && typeof binder.bind === 'function') return binder.bind({ namespace })
+      const forms = ctx.get('configForms')
+      if (forms && typeof forms.get === 'function') return forms.get(namespace)
+      return undefined
+    }
     // Dynamic polling intervals (ms): active when any MCP enabled, idle when all disabled
     const POLL_INTERVALS = Object.freeze({
       ACTIVE: 3000, // When at least one MCP is enabled
@@ -88,6 +139,8 @@ window.__ModuleLoader__.load({
       '.dmpHeadText{flex-direction:column;flex:1;gap:4px;min-width:0;display:flex}',
       '.dmpName{color:var(--dsw-alias-label-primary);font-size:15px;font-weight:600;line-height:1.4}',
       '.dmpDescription{color:var(--dsw-alias-label-tertiary);font-size:13px;line-height:1.5}',
+      // rc.2 `view === 'summary'` seat: one line of text, no controls.
+      '.dmpRowSummary{color:var(--dsw-alias-label-tertiary);font-size:13px;line-height:1.5}',
       '.dmpChevron{color:var(--dsw-alias-label-tertiary);flex:none;transition:transform .16s}',
       '.dmpChevronOpen{transform:rotate(180deg)}',
       '.dmpBody{border-top:1px solid var(--dsw-alias-border-l2);margin:0 16px;padding-bottom:8px}',
@@ -322,7 +375,12 @@ window.__ModuleLoader__.load({
 
     // ── composer pill ───────────────────────────────────────────────────────
 
-    function startPill(scope) {
+    // `getScope` is a GETTER, not the scope itself: the settings transport is
+    // awaited with a non-gating ctx.inject callback, so the pill may start
+    // before (or entirely without) a scope. Reading it lazily keeps the pill
+    // working either way and lets the settings subscription attach if/when the
+    // transport appears — without ever blocking this plugin's activation.
+    function startPill(getScope) {
       if (typeof document === 'undefined' || !document.documentElement) return
       if (pillMounted) {
         // Previous mount leaked (disposal was skipped). Dispose it first, then
@@ -330,7 +388,7 @@ window.__ModuleLoader__.load({
         const previous = pillDispose
         pillDispose = null
         if (typeof previous === 'function') previous()
-        return startPill()
+        return startPill(getScope)
       }
       pillMounted = true
 
@@ -820,6 +878,7 @@ window.__ModuleLoader__.load({
         applyVisibility()
       }
 
+      const scope = getScope()
       if (scope && typeof scope.subscribe === 'function') {
         // A settings save reaches the host mirror immediately; re-fetch right
         // away so the pill flips without waiting for the next poll. The
@@ -864,38 +923,110 @@ window.__ModuleLoader__.load({
     function apply(ctx) {
       if (typeof document === 'undefined') return
 
-      // Settings card first: pill mounting waits for the composer seat
-      // asynchronously and must never delay or break the Settings Slot.
-      const scope = ctx.settingsScope.bind({ namespace: NS })
       // DSH 0.1.2+ exposes fine-grained remote settings through
       // @deepseek-ai/dsh-api-remotes (ctx.remote). The legacy RC connection API
       // is no longer available, so there is no fallback branch.
+      // Defined BEFORE the settings wait: the inject callback can fire while
+      // apply is still running, and the card closure reads both of these.
       const remote = ctx.get('remote')
       const api = remote && remote.settings
         ? { settings: { mutate: (payload) => remote.settings.mutate(payload.ns, payload.ops, payload.expectedRevision).then((result) => ({ result })) } }
         : undefined
-      const disposeSlot = ctx.slots.inject('settings.plugin.item', () => ctx.slots.register({
-        name: 'settings.plugin.item',
-        key: NS,
-        label: 'MCP Pill',
-      }, function McpPillCard() {
-        return e(SettingsCard, { scope, api })
-      }))
+      let scope
+      const disposeSlots = []
+
+      // The Settings card MUST be registered from inside a context that has the
+      // settings transport, i.e. from the `ctx.inject([...], cb)` callback and on
+      // the CHILD context the callback receives. Registering
+      // `settings.plugin.item` from the bare apply context puts the entry where
+      // the Plugins tab's ledger never sees it: the tab asks
+      // `ctx.slots.entries('settings.plugin.item')` from ITS context and the
+      // entry list came back empty, so the card never rendered even though
+      // `register` returned normally. (dshmarket, an out-of-repo bundle that
+      // does render its card, uses exactly this nested shape.)
+      // Both transport names are waited for WITHOUT gating activation, and
+      // whichever one this host mounts resolves; see resolveSettingsScopeFrom.
+      const registerCard = (sctx) => {
+        if (scope !== undefined) return
+        scope = resolveSettingsScopeFrom(sctx, NS)
+        if (scope === undefined) return
+        // Register on the SCOPED context, and read `scope` through a getter so a
+        // late/lazy value is still seen by the card.
+        disposeSlots.push(sctx.slots.inject('settings.plugin.item', () => sctx.slots.register({
+          name: 'settings.plugin.item',
+          key: NS,
+          label: 'MCP Pill',
+        }, function McpPillCard() {
+          return e(SettingsCard, { scope, api })
+        })))
+      }
+      // `ctx.inject(['settingsScope'], cb)` fires only when settingsScope exists;
+      // the second wait covers hosts that rename the transport, and its guard
+      // keeps the card from registering twice when both names exist.
+      ctx.inject(['settingsScope'], registerCard)
+      ctx.inject(['configForms'], (sctx) => { if (scope === undefined) registerCard(sctx) })
+
+      // ── rc.2 seat: the keyed slot `plugins.row.config` ─────────────────────
+      //
+      // 0.1.7-rc.2 removed `settings.plugin.item`; a bundle row's configuration
+      // seat is `plugins.row.config`, declared by the official plugin-manager
+      // page, and the row's configure control exists only while an occupant is
+      // registered under the exact ledger key ROW_CONFIG_KEY. The old seat is
+      // still declared (and still used) on ≤ 0.1.5, so both registrations sit
+      // side by side with no version sniffing: each fires only where its own
+      // slot is declared, and `slots.inject` disposes the entry when the
+      // declaration collapses.
+      //
+      // The host renders this ONE component in two views:
+      //   view === 'summary' → the row's one-liner: text only, no controls
+      //   view === 'page'    → the configuration page, i.e. the existing card
+      // The optional, host-owned form prop of that contract is deliberately NOT
+      // consumed: values keep flowing through the single transport resolved by
+      // resolveSettingsScopeFrom (settingsScope ≤ 0.1.5 / configForms ≥ 0.1.7),
+      // so this plugin has exactly one read path and one write path.
+      //
+      // `slots` is awaited NON-GATINGLY, and the callback returns the
+      // registration disposer so the entry is owned by the registering fiber and
+      // released with the rest of disposeSlots on stop / update / HMR.
+      const registerRowConfig = (sctx) => {
+        disposeSlots.push(sctx.slots.inject('plugins.row.config', () => sctx.slots.register({
+          name: 'plugins.row.config',
+          key: ROW_CONFIG_KEY,
+        }, function McpPillRowConfig(props) {
+          if (props && props.view === 'summary') {
+            return e('span', { className: 'dmpRowSummary' }, '显示状态胶囊开关（默认关闭）')
+          }
+          return e(SettingsCard, { scope, api })
+        })))
+      }
+      ctx.inject(['slots'], registerRowConfig)
 
       // Pill: fully lifecycle-owned as before, but created hidden — the gate
       // inside startPill reveals it only while /status reports pill.enabled
-      // === true (default off).
-      ctx.effect(() => startPill(scope), 'dsh-mcp-pill: composer pill')
+      // === true (default off). The getter is re-read on every refresh, so the
+      // settings subscription attaches as soon as the transport arrives.
+      ctx.effect(() => startPill(() => scope), 'dsh-mcp-pill: composer pill')
 
       // Plugin-card style tag: created lazily by SettingsCard renders and
       // removed here so no style is left behind after stop / update.
       ctx.effect(() => () => removeCardStyles(), 'dsh-mcp-pill: plugin card style')
 
-      return disposeSlot
+      return () => { for (const dispose of disposeSlots) { try { dispose() } catch (_) {} } }
     }
 
     exports.apply = apply
-    exports.inject = ['slots', 'settingsScope', 'remote', 'remote.settings']
+    // The rc.2 ledger key lives in one exported constant so a test (and anyone
+    // inspecting the bundle) can compare it with package.json#name plus the row
+    // id in cordis.patch.yml instead of trusting a second literal.
+    exports.ROW_CONFIG_KEY = ROW_CONFIG_KEY
+    // NEVER list 'settingsScope' or 'configForms' here: every inject name is a
+    // REQUIRED gate (Fiber._refresh() deactivates the fiber when one has no
+    // provider), so declaring the optional settings transport would leave this
+    // plugin permanently pending — the exact failure that broke Web boot.
+    // 'slots' is not a version-dependent service: every Web host provides it,
+    // and it is what orders the slot registrations above after the registry
+    // exists.
+    exports.inject = ['slots', 'remote', 'remote.settings']
     return module.exports
   },
 })

package/lib/index.js

@@ -7,9 +7,11 @@
 //                                 patch file's `disabled` marker (loader HMR applies it)
 //
 // The visibility of the pill itself is owned by the official settings service:
-// this half registers the `mcp-pill` namespace ({ pill: { enabled: false } })
-// and mirrors the resolved value into every /status response, so the client
-// half can follow it with its existing poll loop. Default is OFF.
+// on ≤ 0.1.5 this half registers the `mcp-pill` namespace
+// ({ pill: { enabled: false } }); on ≥ 0.1.7 the namespace is this entry's own
+// `Config` (same shape, with the leaf marked volatile). Either way the effective
+// value is read on demand and mirrored into every /status response, so the
+// client half can follow it with its existing poll loop. Default is OFF.
 //
 // The client half (lib/client.js) is a __ModuleLoader__ web bundle — no
 // tapIndex, no page-level <script> injection.
@@ -40,6 +42,48 @@ export const inject = ['webServer', 'fs', 'tools']
 
 const MCP_NAME = '@deepseek-ai/dsh-mcp-client'
 
+// ── settings portability helpers ────────────────────────────────────────────
+//
+// `Schema.prototype.volatile` exists only from @deepseek-ai/schemastery 3.18.4
+// (the DSH ≥ 0.1.7-rc.1 corridor). The 0.1.5 line resolves 3.18.1/3.18.2, where
+// that method is undefined and calling it throws, so the two hosts cannot share
+// one literal schema expression: the marker is applied through this probe and
+// degrades to the plain schema where the method is absent.
+const volatile = (schema) => (typeof schema?.volatile === 'function' ? schema.volatile() : schema)
+
+// A volatile field's parsed value is a cosmokit cell, not the value itself: it
+// exposes `get()` plus the registered write symbol below and NOTHING else — no
+// `set`. Keying on that symbol (rather than on a `set` method that never exists,
+// or on importing cosmokit, which would add a dependency for nothing) is what
+// makes the read yield the real value. The settings service writes such a field
+// in place without remounting the entry, so the value must be read on demand.
+const VOLATILE_WRITE = Symbol.for('cosmokit.volatile.write')
+
+function readVolatile(value) {
+  if (value === null || typeof value !== 'object') return value
+  if (typeof value.get !== 'function') return value
+  if (!(VOLATILE_WRITE in value)) return value
+  return value.get()
+}
+
+// ── the loader entry's own Config (DSH ≥ 0.1.7-rc.1) ────────────────────────
+//
+// The declarative host has no `ctx.settings.register(namespace, schema, opts)`:
+// a settings namespace exists only as the ACTIVE entry's own Config schema,
+// keyed by the loader entry id (`mcp-pill` — see cordis.patch.yml), and only
+// fields marked volatile produce an editable form (an entry whose schema
+// contains none gets no form at all). The nesting and defaults are kept
+// identical to the legacy `mcp-pill` namespace so the client half reads the same
+// `pill.enabled` on both hosts; `patchFile` stays the row's own field. A
+// volatile field must sit at a fixed object path and never enclose another
+// volatile field, so only the leaf is marked.
+const Config = Schema.object({
+  patchFile: Schema.string().default('cordis.patch.yml'),
+  pill: Schema.object({
+    enabled: volatile(Schema.boolean().default(DEFAULT_SETTINGS.pill.enabled)),
+  }).default(cloneSettings(DEFAULT_SETTINGS.pill)),
+})
+
 function resolvePatchFile(ctx, config) {
   const rel = (config && config.patchFile) ? String(config.patchFile) : 'cordis.patch.yml'
   if (path.isAbsolute(rel)) return rel
@@ -103,6 +147,10 @@ export function apply(ctx, config) {
   // Defaults to hidden; the client follows /status, so no direct coupling.
   const pillState = { enabled: false }
 
+  // True once the settings service is known to be the declarative host, where
+  // the effective value lives in this entry's parsed Config instead of a scope.
+  let declarativeSettings = false
+
   function readPillEnabled(scope) {
     try {
       const value = scope.get()
@@ -112,34 +160,89 @@ export function apply(ctx, config) {
     }
   }
 
-  ctx.inject(['settings'], (sctx) => {
+  // Declarative host: the pill toggle is this entry's parsed Config, and the
+  // settings service rewrites a volatile field IN PLACE without remounting the
+  // entry — so the value must be read on demand from `config` and never cached
+  // at apply time. Unwrapping both levels is harmless when neither is a cell.
+  function readEntryPillEnabled() {
     try {
-      const schema = Schema.object({
-        pill: Schema.object({
-          enabled: Schema.boolean().default(DEFAULT_SETTINGS.pill.enabled),
-        }).default(cloneSettings(DEFAULT_SETTINGS.pill)),
-      })
-      const scope = sctx.settings.register(SETTINGS_NS, schema, {
-        base: cloneSettings(DEFAULT_SETTINGS),
-        applies: 'live',
-        // The official settings service treats a throw as rejection and
-        // discards the return value, so translate the { ok, errors } contract
-        // into the throw contract here.
-        validate: (value) => {
-          const validated = validateSettings(value)
-          if (!validated.ok) throw new Error((validated.errors || []).join('; '))
-        },
-      })
-      pillState.enabled = readPillEnabled(scope)
-      sctx.effect(() => scope.watch(() => {
+      const pill = readVolatile(config && config.pill)
+      const enabled = readVolatile(pill && pill.enabled)
+      return enabled === true
+    } catch (_) {
+      return false
+    }
+  }
+
+  // Single source of truth for the routes: whichever host owns the value, an
+  // in-place settings write is observed on the next /status read.
+  function pillEnabled() {
+    return declarativeSettings ? readEntryPillEnabled() : pillState.enabled
+  }
+
+  ctx.inject(['settings'], (sctx) => {
+    // ── settings registration: dual-host ────────────────────────────────────
+    //
+    // ≤ 0.1.5  ctx.settings.register(namespace, schema, options) exists and this
+    //          plugin owns its `mcp-pill` namespace exactly as before, mirroring
+    //          the resolved `pill.enabled` into pillState for /status.
+    // ≥ 0.1.7  register() is GONE. The namespace is not registered by the plugin
+    //          at all: the settings service derives one form per ACTIVE profile
+    //          entry from that entry's Config schema (keyed by the entry id) and
+    //          exposes only fields marked volatile. The effective value therefore
+    //          arrives through this entry's parsed `config`, which is read on
+    //          demand by pillEnabled() so an in-place volatile write is seen
+    //          without a remount. configure({ auto: false }) suppresses the
+    //          official generic form page — the namespace still appears in the
+    //          client mirror, so the plugin's own settings card keeps working.
+    //
+    // Nothing throws on either host, and with no settings service at all the
+    // pill stays hidden (default off).
+    const settingsApi = sctx.settings
+    if (!settingsApi) return
+
+    if (typeof settingsApi.register === 'function') {
+      try {
+        const schema = Schema.object({
+          pill: Schema.object({
+            enabled: Schema.boolean().default(DEFAULT_SETTINGS.pill.enabled),
+          }).default(cloneSettings(DEFAULT_SETTINGS.pill)),
+        })
+        const scope = settingsApi.register(SETTINGS_NS, schema, {
+          base: cloneSettings(DEFAULT_SETTINGS),
+          applies: 'live',
+          // The official settings service treats a throw as rejection and
+          // discards the return value, so translate the { ok, errors } contract
+          // into the throw contract here.
+          validate: (value) => {
+            const validated = validateSettings(value)
+            if (!validated.ok) throw new Error((validated.errors || []).join('; '))
+          },
+        })
         pillState.enabled = readPillEnabled(scope)
-      }), 'dsh-mcp-pill: settings watch')
-      sctx.effect(() => () => {
-        pillState.enabled = false
-      }, 'dsh-mcp-pill: settings fallback')
+        sctx.effect(() => scope.watch(() => {
+          pillState.enabled = readPillEnabled(scope)
+        }), 'dsh-mcp-pill: settings watch')
+        sctx.effect(() => () => {
+          pillState.enabled = false
+        }, 'dsh-mcp-pill: settings fallback')
+      } catch (_) {
+        // Settings stay optional: without the service the pill remains hidden
+        // (default off) and the MCP rows keep working through the patch file.
+      }
+      return
+    }
+
+    // Declarative host: no register() at all, so the namespace is this entry's
+    // Config and every read goes through readEntryPillEnabled().
+    declarativeSettings = true
+    if (typeof settingsApi.configure !== 'function') return
+    try {
+      sctx.effect(() => settingsApi.configure({ auto: false }, ctx.fiber), 'dsh-mcp-pill: settings presentation')
     } catch (_) {
-      // Settings stay optional: without the service the pill remains hidden
-      // (default off) and the MCP rows keep working through the patch file.
+      // configure() throws when called twice for one fiber. The namespace is
+      // still derived from Config, so failing to suppress the generated page is
+      // never fatal.
     }
   })
 
@@ -193,7 +296,7 @@ export function apply(ctx, config) {
       const msg = String((err && err.message) || err)
       if (/not found|ENOENT|no such file/i.test(msg)) {
         // The patch file does not exist — nothing to report, not an error.
-        return { ok: true, patchFile, warning: msg, pill: { enabled: pillState.enabled }, entries: [] }
+        return { ok: true, patchFile, warning: msg, pill: { enabled: pillEnabled() }, entries: [] }
       }
       throw err
     }
@@ -210,7 +313,7 @@ export function apply(ctx, config) {
     return {
       ok: true,
       patchFile,
-      pill: { enabled: pillState.enabled },
+      pill: { enabled: pillEnabled() },
       entries: entries.map((e) => ({
         id: e.id,
         serverName: e.serverName || e.id,
@@ -279,6 +382,13 @@ export function apply(ctx, config) {
   }), 'dsh-mcp-pill: set route')
 }
 
+// The plugin object handed to the loader. `Config` is read by cordis as
+// `runtime.Config` (see Registry.plugin) — for an object plugin this property is
+// the equivalent of a class's `static Config`, and it is what the declarative
+// host's settings service uses as this entry's namespace. The named exports
+// above stay for direct importers; the loader unwraps `default` first.
+export default { name, inject, Config, apply }
+
 // Re-export the config contract for backward compatibility (the same public
 // names as before the config.js split). isPlainObject/cloneSettings stay
 // module-private, mirroring dsh-tool-adapt's narrower index surface.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mcp-pill",
-  "version": "0.2.4",
+  "version": "0.2.8",
   "description": "EN: Lifecycle-safe MCP status pill and Settings card for DeepSeek Harness Web. ZH: 面向 DeepSeek Harness Web 的生命周期安全 MCP 状态胶囊与设置卡片。",
   "type": "module",
   "main": "lib/index.js",