dsh-tool-adapt 0.2.5 → 0.2.9

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.9** — 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 and pill switch keep working across the rename.
 
 A compatibility and safety adaptation layer for non-DeepSeek model families in DeepSeek Harness Web. It guards dead escalation states, injects model-family conventions, fuses repeated failures, and provides a lifecycle-safe Settings card and optional composer pill. Its DSH 0.1.2+ `remote.settings` path falls back to the legacy connection API on older RC hosts.
 
@@ -26,9 +26,15 @@ them run with the fields stripped (strip) — no error, no loop.
   veto.
 
 Config is hot. When Host `ctx.settings` is available the plugin registers the
-`tool-adapt` namespace and an official-style expandable Settings Card
-(`settings.plugin.item` / key `tool-adapt`, same disclosure chrome as
-Shell / Agent loop) becomes the writable source of truth. A legacy `plugins/tool-adapt.config.json` is migrated once if the
+`tool-adapt` namespace and an official-style expandable Settings Card (same
+disclosure chrome as Shell / Agent loop) becomes the writable source of truth.
+That card registers on both settings seats DSH has used: the legacy
+`settings.plugin.item` (key `tool-adapt`) on ≤ 0.1.5, and the keyed row seat
+`plugins.row.config` (key `dsh-tool-adapt#tool-adapt`, i.e.
+`<package name>#<row id>`) on ≥ 0.1.7-rc.2, where the **插件** panel (the first
+sidebar panel icon) shows a
+configure control for the row only while that exact key is registered.
+A legacy `plugins/tool-adapt.config.json` is migrated once if the
 settings user layer is empty; the old file is kept for rollback. The
 `GET/POST /api/tool-adapt/status|set` routes remain as a compatibility
 surface (loopback + same-origin fenced, 8 KiB body cap). The pill snaps to
@@ -36,7 +42,8 @@ one of the chat input's four corners (drag to switch); the anchor is
 remembered in `localStorage` (`dsh.toolAdapt.anchor`). The pill mounts inside
 the composer seat (same stacking level as the input box) at a normal
 `z-index`, so DSH web popups (modal / menu / toast) can cover it. The pill
-itself is status-only — edit the full form under Settings → Plugins. The
+itself is status-only — edit the full form in the **插件** panel (on ≤ 0.1.5:
+Settings → Plugins). The
 pill is hidden by DEFAULT: the「显示状态胶囊」switch (`ui.pill`, default
 `false`) at the top of the ADAPT card owns its visibility, and the pill
 follows the hot `/status` config within one poll (or instantly after a save
@@ -44,8 +51,19 @@ in the same tab).
 
 ## 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-tool-adapt
+```
+
+Restart the existing DSH Web process afterwards: the Host scans the browser plugin roster at startup, so the Settings card and the optional pill appear only after that restart. Then open the ADAPT 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-tool-adapt` bundle, and use the `tool-adapt` row's configure control; the「显示状态胶囊」switch (`ui.pill`, default `false`) owns the composer pill's visibility.
+
+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

@@ -2,7 +2,10 @@
 //
 // Browser-only bundle: consumed by the DSH web loader (window.__ModuleLoader__).
 // Not importable in Node. Renders the ADAPT status pill and an official-style
-// expandable Settings Card under settings.plugin.item / key tool-adapt.
+// expandable Settings Card on BOTH settings seats, because DSH moved it when
+// 0.1.7-rc.2 removed the old one: `settings.plugin.item` / key `tool-adapt` on
+// ≤ 0.1.5, and the keyed row seat `plugins.row.config` / key ROW_CONFIG_KEY on
+// ≥ 0.1.7-rc.2.
 //
 // The pill is hidden by DEFAULT: the ui.pill switch in the Settings Card
 // (设置 → 插件 → ADAPT「显示状态胶囊」) owns visibility; the polled /status
@@ -24,6 +27,51 @@ window.__ModuleLoader__.load({
     const React = require('react')
 
     const NS = 'tool-adapt'
+
+    // ── 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
+    // renders a row's configure control only while 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: package.json#name plus the row id this package's
+    // own cordis.patch.yml declares. One constant, exported for inspection;
+    // test/client-source.test.mjs re-derives both halves from those two files and
+    // fails on any drift.
+    const ROW_CONFIG_KEY = 'dsh-tool-adapt#tool-adapt'
+
+    // The rc.2 `view === 'summary'` one-liner carries its style inline on purpose:
+    // the card's style tag is created lazily by a SettingsCard render, and the
+    // summary can render before any SettingsCard ever has.
+    const SUMMARY_STYLE = { color: 'var(--dsw-alias-label-tertiary)', fontSize: '13px', lineHeight: 1.5 }
+
+    // ── 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.
+    // `ctx.get` (never a direct property read) keeps the lookup safe when only
+    // one service is mounted: an uninjected property read throws.
+    // For this plugin the settings namespace and the profile entry id are both
+    // 'tool-adapt', 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
+    }
     const API = '/api/tool-adapt'
     const POLL_MS = 5000
     const e = React.createElement
@@ -388,7 +436,11 @@ window.__ModuleLoader__.load({
     let pillMounted = false
     let pillDispose = null
 
-    function startPill(scope) {
+        // `getScope` is a GETTER: 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.
+    function startPill(getScope) {
       if (typeof document === 'undefined') return
       if (pillMounted) {
         // Previous mount leaked (disposal was skipped). Dispose it first, then
@@ -396,7 +448,7 @@ window.__ModuleLoader__.load({
         const previous = pillDispose
         pillDispose = null
         if (typeof previous === 'function') previous()
-        return startPill()
+        return startPill(getScope)
       }
       pillMounted = true
 
@@ -764,6 +816,7 @@ window.__ModuleLoader__.load({
         applyVisibility()
       }
 
+      const scope = getScope()
       if (scope && typeof scope.subscribe === 'function') {
         // A settings save reaches the host config immediately; re-fetch right
         // away so the pill flips without waiting up to POLL_MS. The 5s poll
@@ -802,23 +855,78 @@ window.__ModuleLoader__.load({
     }
 
     function apply(ctx) {
-      // 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 provided on the Client, 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: 'ADAPT',
-      }, function ToolAdaptCard() {
+      let scope
+      const disposeSlots = []
+
+      // Settings card FIRST (pill mounting waits for the composer seat
+      // asynchronously and must never delay or break the Settings Slot), and
+      // registered from inside the settings-transport callback on the CHILD
+      // context it hands us. Registering `settings.plugin.item` from the bare
+      // apply context puts the entry where the Plugins tab's ledger never sees
+      // it: the tab reads `ctx.slots.entries('settings.plugin.item')` from its
+      // own context, got an empty list, and the card never rendered even though
+      // `register` returned normally. (dshmarket, an out-of-repo bundle that
+      // does render, uses this nested shape.)
+      // Both transport names are awaited WITHOUT gating activation, and whichever
+      // this host mounts resolves; see resolveSettingsScopeFrom.
+      const registerCard = (sctx) => {
+        if (scope !== undefined) return
+        scope = resolveSettingsScopeFrom(sctx, NS)
+        if (scope === undefined) return
+        disposeSlots.push(sctx.slots.inject('settings.plugin.item', () => sctx.slots.register({
+          name: 'settings.plugin.item',
+          key: NS,
+          label: 'ADAPT',
+        }, function ToolAdaptCard() {
+          return e(SettingsCard, { scope, api })
+        })))
+      }
+      // The first wait fires only when settingsScope exists; the second covers a
+      // host that renamed 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 holds
+      // 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: `slots.inject` fires only where its own slot is declared
+      // and disposes the entry when that declaration collapses.
+      //
+      // The page 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 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 keeps 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) => sctx.slots.inject('plugins.row.config', () => sctx.slots.register({
+        name: 'plugins.row.config',
+        key: ROW_CONFIG_KEY,
+      }, function ToolAdaptRowConfig(props) {
+        if (props && props.view === 'summary') {
+          return e('span', { style: SUMMARY_STYLE }, '非 DeepSeek 模型的工具适配开关（守卫 / L2 惯例 / L0 熔断 / 状态胶囊）。')
+        }
         return e(SettingsCard, { scope, api })
       }))
+      ctx.inject(['slots'], registerRowConfig)
 
       // Pill: fully lifecycle-owned. The effect runs startPill() now and the
       // returned disposer on stop / update / HMR, idempotently releasing the
@@ -826,17 +934,24 @@ window.__ModuleLoader__.load({
       // and every listener so the next apply re-mounts from scratch. The pill
       // starts hidden: startPill gates visibility on ui.pill (default false)
       // via the settings scope plus the /status poll fallback.
-      ctx.effect(() => startPill(scope), 'dsh-tool-adapt: composer pill')
+      ctx.effect(() => startPill(() => scope), 'dsh-tool-adapt: 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-tool-adapt: 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
+    // 'settingsScope' and 'configForms' are alternatives, not both-required:
+    // cordis resolves each inject name as its own gate, so activation succeeds on
+    // whichever settings transport the host mounts (0.1.5 vs 0.1.7-rc.1).
+    exports.inject = ['slots', 'remote', 'remote.settings']
     return module.exports
   },
 })

package/lib/index.js

@@ -60,31 +60,122 @@ import {
 export { DEFAULT_CONFIG, SETTINGS_NS, validateConfig } from './config.js'
 
 export const name = 'dsh-tool-adapt'
+// `settings` is deliberately NOT listed here: cordis treats every inject name as a
+// REQUIRED gate, and the settings transport is version-dependent (see the
+// `ctx.inject(['settings'], ...)` wait inside apply).
 export const inject = ['webServer', 'fs', 'systemPrompt']
 
-function createSettingsSchema() {
-  return Schema.object({
+// ── settings schema: one shape, two hosts ────────────────────────────────────
+// ≤ 0.1.5  the schema is handed to `ctx.settings.register()` and plain fields are
+//          enough.
+// ≥ 0.1.7  the same shape must be the entry's own `static Config`, and the
+//          settings service only exposes fields marked `.volatile()`: a schema
+//          without a volatile field produces no settings form at all.
+//
+// `Schema.prototype.volatile` exists only from schemastery 3.18.4 (the 0.1.7
+// corridor); the 0.1.5 line resolves 3.18.2, where it is `undefined` and calling
+// it throws. So it is applied capability-detected, and one expression serves both
+// hosts. Volatility is marked on the individual LEAVES (and on `excludeModels` as
+// a whole) — never on an enclosing object too, because a volatile field inside a
+// volatile field throws at resolve time.
+const volatile = (schema) => (typeof schema?.volatile === 'function' ? schema.volatile() : schema)
+
+// A volatile field's parsed value is a cosmokit wrapper: a `get()` method plus a
+// registered write symbol, and nothing else. Key on the symbol — not on `set`,
+// which does NOT exist (verified against schemastery 3.18.4 + cosmokit 1.8.5).
+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()
+}
+
+function settingsFields() {
+  return {
     guard: Schema.object({
-      enabled: Schema.boolean().default(DEFAULT_CONFIG.guard.enabled),
+      enabled: volatile(Schema.boolean().default(DEFAULT_CONFIG.guard.enabled)),
     }).default(cloneConfig(DEFAULT_CONFIG.guard)),
     l2: Schema.object({
-      enabled: Schema.boolean().default(DEFAULT_CONFIG.l2.enabled),
-      excludeModels: Schema.array(Schema.string().pattern(/^[A-Za-z0-9.*_-]{1,64}$/)).max(50).default(DEFAULT_CONFIG.l2.excludeModels.slice()),
-      block: Schema.string().min(1).max(4000).default(DEFAULT_CONFIG.l2.block),
+      enabled: volatile(Schema.boolean().default(DEFAULT_CONFIG.l2.enabled)),
+      excludeModels: volatile(Schema.array(Schema.string().pattern(/^[A-Za-z0-9.*_-]{1,64}$/)).max(50).default(DEFAULT_CONFIG.l2.excludeModels.slice())),
+      block: volatile(Schema.string().min(1).max(4000).default(DEFAULT_CONFIG.l2.block)),
     }).default(cloneConfig(DEFAULT_CONFIG.l2)),
     l0: Schema.object({
-      enabled: Schema.boolean().default(DEFAULT_CONFIG.l0.enabled),
-      remindAfter: Schema.number().step(1).min(2).max(20).default(DEFAULT_CONFIG.l0.remindAfter),
-      vetoAfter: Schema.number().step(1).min(0).max(20).default(DEFAULT_CONFIG.l0.vetoAfter),
-      reminderText: Schema.string().min(1).max(2000).default(DEFAULT_CONFIG.l0.reminderText),
-      vetoText: Schema.string().min(1).max(2000).default(DEFAULT_CONFIG.l0.vetoText),
+      enabled: volatile(Schema.boolean().default(DEFAULT_CONFIG.l0.enabled)),
+      remindAfter: volatile(Schema.number().step(1).min(2).max(20).default(DEFAULT_CONFIG.l0.remindAfter)),
+      vetoAfter: volatile(Schema.number().step(1).min(0).max(20).default(DEFAULT_CONFIG.l0.vetoAfter)),
+      reminderText: volatile(Schema.string().min(1).max(2000).default(DEFAULT_CONFIG.l0.reminderText)),
+      vetoText: volatile(Schema.string().min(1).max(2000).default(DEFAULT_CONFIG.l0.vetoText)),
     }).default(cloneConfig(DEFAULT_CONFIG.l0)),
     ui: Schema.object({
-      pill: Schema.boolean().default(DEFAULT_CONFIG.ui.pill),
+      pill: volatile(Schema.boolean().default(DEFAULT_CONFIG.ui.pill)),
     }).default(cloneConfig(DEFAULT_CONFIG.ui)),
+  }
+}
+
+// ≤ 0.1.5 registration schema: the live settings section only.
+function createSettingsSchema() {
+  return Schema.object(settingsFields())
+}
+
+// ≥ 0.1.7 entry Config: the live settings section PLUS the row field `configFile`,
+// which is what the mounting row in cordis.patch.yml carries. The settings fields
+// keep the identical names, nesting and defaults, so the client card's reads and
+// writes of `guard.enabled`, `l2.*`, `l0.*` and `ui.pill` work on both hosts.
+function createEntryConfig() {
+  return Schema.object({
+    configFile: Schema.string().default('plugins/tool-adapt.config.json'),
+    ...settingsFields(),
   })
 }
 
+// Project the parsed entry Config onto the live settings shape, reading volatile
+// fields on demand. Never cache the result: the declarative settings service
+// writes volatile fields IN PLACE without remounting the entry, so the value must
+// be re-read at every access.
+function readDeclarativeConfig(raw) {
+  if (raw === null || typeof raw !== 'object') return undefined
+  const guard = readVolatile(raw.guard)
+  const l2 = readVolatile(raw.l2)
+  const l0 = readVolatile(raw.l0)
+  const ui = readVolatile(raw.ui)
+  return {
+    guard: { enabled: readVolatile(guard && guard.enabled) },
+    l2: {
+      enabled: readVolatile(l2 && l2.enabled),
+      excludeModels: readVolatile(l2 && l2.excludeModels),
+      block: readVolatile(l2 && l2.block),
+    },
+    l0: {
+      enabled: readVolatile(l0 && l0.enabled),
+      remindAfter: readVolatile(l0 && l0.remindAfter),
+      vetoAfter: readVolatile(l0 && l0.vetoAfter),
+      reminderText: readVolatile(l0 && l0.reminderText),
+      vetoText: readVolatile(l0 && l0.vetoText),
+    },
+    ui: { pill: readVolatile(ui && ui.pill) },
+  }
+}
+
+// The plugin's own entry Config (`static Config`): what the declarative (≥ 0.1.7)
+// settings service reads as this entry's schema, keyed by the loader entry id
+// 'tool-adapt' — the same key the client half resolves.
+//
+// It is reached two ways, and both must work:
+//   - through the plugin value cordis resolves. The loader's `unwrapExports`
+//     collapses a namespace carrying a `default` export down to that single value,
+//     so this module deliberately exports NO `default`: with none, the namespace
+//     itself is the plugin object, `resolve()` finds `apply`, and `plugin.Config`
+//     is read off that same namespace.
+//   - as a plain named export, so a host half loaded directly (the workspace's
+//     `scripts/settings-host-portability-check.mjs`) reads `module.Config`.
+// `Config` is therefore the single shared schema instance attached to the exported
+// `apply`. Function declarations are hoisted, so this is safe even though `apply`
+// is defined further down, and the ≤ 0.1.5 line simply never reads it.
+export const Config = createEntryConfig()
+Object.assign(apply, { Config })
+
 async function readLegacyFile(ctx, configFile) {
   try {
     const target = await ctx.fs.resolve(configFile)
@@ -187,14 +278,71 @@ export function apply(ctx, config) {
     },
   }
 
-  if (ctx.get('settings') === undefined) {
+  // Validate an already-projected live config; on any failure fall back to the
+  // shipped defaults, exactly like the legacy registration path.
+  function liveOrDefault(raw) {
+    const validated = validateConfig(raw)
+    return validated.ok ? validated.config : entry
+  }
+
+  // ── settings transport: two independent hosts ─────────────────────────────
+  //
+  // ≤ 0.1.5  `ctx.settings.register(namespace, schema, opts)` exists. This plugin
+  //          owns the `tool-adapt` namespace, its plain schema is enough, and a
+  //          legacy `settings.yaml` may still be migrated into it.
+  //
+  // ≥ 0.1.7  register() is gone. A settings namespace exists only as the plugin
+  //          entry's own `Config` schema (the `static Config` attached to `apply`
+  //          at module scope), keyed by the loader entry id — which is
+  //          `tool-adapt`, the same key the client half resolves. Only
+  //          `.volatile()` fields are exposed, so the entry Config marks the
+  //          editable leaves volatile and no schema is registered here. The
+  //          settings service writes those fields IN PLACE, without remounting the
+  //          entry, so `source` must re-read the parsed `config` argument on every
+  //          access rather than cache it. The legacy `settings.yaml` migration does
+  //          not apply on this host: the entry Config is the storage.
+  //
+  // Both branches keep `source` non-throwing and fall back to the shipped
+  // defaults; with no settings service at all the legacy JSON file is the store.
+  const settingsApi = ctx.get('settings')
+  const declarative = settingsApi !== undefined
+    && typeof settingsApi.register !== 'function'
+    && typeof settingsApi.configure === 'function'
+
+  if (settingsApi === undefined) {
+    // No settings transport: the legacy JSON file stays authoritative.
     void loadLegacyFile(ctx, configFile, state)
   }
 
   ctx.inject(['settings'], (sctx) => {
+    if (declarative) {
+      try {
+        // Suppress the official UI's generated generic page for this entry: the
+        // plugin ships its own settings card. `auto: false` only affects that
+        // generated page — the namespace still reaches the client mirror, so the
+        // custom card keeps working. `configure` throws if called twice for one
+        // fiber, so the effect owns the call and disposes it.
+        sctx.effect(() => sctx.settings.configure({ auto: false }, ctx.fiber), 'dsh-tool-adapt: settings presentation')
+        source = () => liveOrDefault(readDeclarativeConfig(config))
+        state.settingsReady = true
+        sctx.effect(() => () => {
+          state.settingsReady = false
+          source = () => entry
+        }, 'dsh-tool-adapt: settings fallback')
+      } catch (err) {
+        state.fileError = String((err && err.message) || err)
+        source = () => entry
+      }
+      return
+    }
+
+    if (!settingsApi || typeof settingsApi.register !== 'function') {
+      source = () => entry
+      return
+    }
     try {
       const schema = createSettingsSchema()
-      const scope = sctx.settings.register(SETTINGS_NS, schema, {
+      const scope = settingsApi.register(SETTINGS_NS, schema, {
         base: entry,
         applies: 'live',
         validate: (value) => {
@@ -202,11 +350,7 @@ export function apply(ctx, config) {
           if (!validated.ok) throw new Error((validated.errors || []).join('; '))
         },
       })
-      source = () => {
-        const resolved = scope.get()
-        const validated = validateConfig(resolved)
-        return validated.ok ? validated.config : entry
-      }
+      source = () => liveOrDefault(scope.get())
       state.settingsReady = true
       sctx.effect(() => scope.watch(() => {}), 'dsh-tool-adapt: settings watch')
       sctx.effect(() => () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tool-adapt",
-  "version": "0.2.5",
+  "version": "0.2.9",
   "description": "EN: Compatibility and safety adaptation layer for non-DeepSeek models in DeepSeek Harness Web. ZH: 面向 DeepSeek Harness Web 非 DeepSeek 模型的兼容与安全适配层。",
   "type": "module",
   "main": "lib/index.js",