@maci0/dsh-ponytail 0.0.0-stage → 0.18.2

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 dsh-ponytail contributors
+Copyright (c) 2026 DietrichGebert (https://github.com/DietrichGebert/ponytail)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,185 @@
-# Temporary Holding Version
+# dsh-ponytail
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Your agent adds a cache class, a config flag, and a factory for one product. This
+plugin makes it stop and write the one line that works instead. The ladder:
+question whether the thing needs to exist, reuse what is already in the repo, then
+the standard library, then the platform, then an installed dependency, then one
+line. Stop at the first rung that holds. Adapted from
+[DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail) (MIT): "He
+says nothing. He writes one line. It works."
+
+## What you get
+
+- **The ladder on every request.** While any level except `off` is active, the
+  mode-filtered ruleset joins the system prompt.
+- **Six skills** the `skill` tool can load, so they also appear as
+  `/ponytail-review`, `/ponytail-audit`, … in the composer: `ponytail`,
+  `ponytail-review`, `ponytail-audit`, `ponytail-debt`, `ponytail-gain`,
+  `ponytail-help`.
+- **Two ways to switch level.** The model calls the `ponytail` tool; you type
+  `/ponytail <level>` or just say **stop ponytail**.
+- **A settings card and a composer chip**, so the level is visible without opening Settings.
+- **No unrequested abstractions, no boilerplate.** Deletion over addition, boring
+  over clever.
+
+## Install
+
+> **Install it as a bundle.** `dsh plugin add …` mounts the row from the
+> package's own patch layer, which is what the settings editor can write to. A
+> row added with `--patch` is an overlay: it disappears at the next start, and
+> the Plugins card cannot save into it (the editor refuses a write an overlay
+> would win).
+
+```sh
+dsh plugin --profile web add @maci0/dsh-ponytail@0.18.2
+```
+
+This installs the public npm package; no GitHub token or `~/.secrets` setup is needed.
+The version is pinned. To upgrade, run the same command with a newer version,
+then restart `dsh web` (bundle layers compose at boot).
+
+## Use it
+
+```
+/ponytail ultra   -> Ponytail level: ultra (was full).
+/ponytail         -> Ponytail level: ultra.
+/ponytail off     -> Ponytail off (was ultra). Normal behavior.
+```
+
+Then ask for the work. This is the `full` example from the skill itself:
+
+```
+> Add a cache for these API responses.
+
+`@lru_cache(maxsize=1000)` on the fetch function. Skipped custom cache class,
+add when lru_cache measurably falls short.
+```
+
+Model side, the tool takes one optional argument: `{"mode": "lite"}` sets and
+persists a level, and calling it with no argument reports the current one.
+
+Typing **stop ponytail** or **normal mode** as an ordinary message has the same
+effect as `/ponytail off`, and it lands on the turn that carried it. Only the
+human's own words count: injected context riding the same event stream cannot
+toggle the level, and the message must *be* the command, so "add a normal mode
+toggle" is left alone.
+
+### Levels
+
+| Level | Behavior | Persisted |
+|---|---|---|
+| `lite` | Build what was asked, name the lazier alternative in one line. | yes |
+| `full` | The ladder enforced. Default. | yes |
+| `ultra` | YAGNI extremist: challenge the requirement before building it. | yes |
+| `review` | Over-engineering review; points at the `ponytail-review` skill. | no, session only |
+| `off` | No injection. Normal behavior. | yes |
+
+The four persistable levels live in the `ponytail` settings namespace, so the
+card, the chip, the tool, and `/ponytail` agree and the choice survives a
+restart. `review` stays session-only because it is a review mode, not a level a
+deployment should start in; the tool and the command still accept it. The card
+and the chip show the level the host is using, so they show `review`, and any level
+kept only for this session because the settings write failed, labelled as
+session-only.
+
+Lazy is not negligent. Understanding the problem, trust-boundary validation,
+data-loss handling, security, and accessibility are never on the chopping block.
+
+## Configure
+
+| Field | Default | Meaning |
+|---|---|---|
+| `defaultMode` | `full` | Startup level. Must be `off`, `lite`, `full`, or `ultra`. |
+
+The exported `Config` schema defaults the field, so a row that omits `defaultMode`
+starts in `full`. The user's settings namespace overrides it once a level is chosen
+in the card or by `/ponytail`. An invalid level fails while the plugin loads rather
+than quietly doing the wrong thing: the loader validates the row against the
+exported schema.
+
+To set the startup level from the environment, override the row in your profile's
+`cordis.patch.yml` with a `!!js` expression (same `id`, which replaces the row's
+whole `config`):
+
+```yaml
+- id: ponytail
+  config:
+    defaultMode: !!js process.env.PONYTAIL_DEFAULT_MODE ?? 'full'
+```
+
+Override the row this way; do **not** paste the bundle's `insert` of the
+`id: ponytail` row into your profile's `cordis.patch.yml`: `insert` does not
+dedupe ids, and a second row mounts the plugin twice.
+
+## How it works
+
+The package declares `dsh.bundle`, so `dsh plugin add` appends it to
+`dsh.profile.bundles` and the row in its own `cordis.patch.yml` applies as a layer.
+
+The host half mounts through public Cordis extension points: `systemPrompt.section`,
+`skills.registerProvider`, `tools.register`, `commands.register`,
+`loader/volatile-update` (the settings document writes the row's volatile
+`defaultMode`), `session/event` for the message switch, and `webServer` for
+`GET /ponytail/level`, which answers `{ mode, source }` (`settings` or `session`)
+behind the `connection` trust fence. The browser half reads that route on every
+settings change and every 5 seconds, draws its card into the public `plugins.row.config` slot from `configForms`, registers its
+copy through `locale.register`, and draws its chip into `conversation.input.left`, so
+this plugin needs no client change of its own.
+
+The entry point is the built `lib/index.js` (declarations in `lib/types/`); `bun run
+build` regenerates it from `src/`. `lib/client.js` is hand-authored plain JavaScript:
+the client module system serves it as a lazy-CJS factory on `window.__ModuleLoader__`
+because the package exports `./client`, and it is not built. Skills come from
+`skills/<name>/SKILL.md` with frontmatter parsed by `yaml`; the provider takes its rank
+and name grammar from `@deepseek-ai/dsh-skill`, projects `disable-model-invocation`,
+`user-invocable`, and `whenToUse`, and settles on the lookup's abort signal. Tools use
+`defineTool` from `@deepseek-ai/dsh-tools` and forward `exec.signal`. Only
+`skills/ponytail/SKILL.md` is the source of truth for the ruleset; this README keeps no
+second copy.
+
+## Limits
+
+- **It does not skip comprehension.** The ladder shortens the solution, never the
+  reading. The skill says so in its own text.
+- **The level is process-wide.** One prompt section, one namespace value: every
+  agent in the process shares it.
+- **External subagents ignore it.** In-process children inherit the ruleset, but
+  `subagent-claude-code` and `subagent-codex` spawn their own CLI with its own
+  system prompt, and no harness extension point wraps a spawn.
+- **Two locales.** The card and the chip ship `en` and `zh`; any other locale
+  falls back through the service's own chain.
+- **Host source edits need `bun run build` and a restart**, because the Loader
+  loads `lib/index.js` and a bundle layer composes at boot.
+- **Browser-half edits need a page refresh.**
+- **A level change is not a session event.** A replayed session shows the ruleset
+  each request already carried.
+
+## Development
+
+```sh
+bun install         # the client packages are optional peers and stay uninstalled
+bun run build       # tsc -p tsconfig.build.json -> lib/index.js + lib/types/
+bun test            # every tests/*.test.ts, no build step
+bun run typecheck   # tsc -p tsconfig.json
+```
+
+dsh loads plugins on Node ^22.19.0 || >=24.0.0; development and tests run on bun.
+
+For local development, install the checkout into a profile with
+`dsh plugin --profile <name> add <path-to-checkout>`.
+
+The suite covers level normalization and filtering, the fake-host surface, the skills
+provider, the client card, and a real Cordis composition mount next to the real skill
+registry. To uninstall, run `dsh plugin --profile web remove @maci0/dsh-ponytail`; that removes
+the dependency and the bundle layer together.
+
+## Attribution and license
+
+MIT. Skill content and mode semantics: © DietrichGebert
+([ponytail](https://github.com/DietrichGebert/ponytail)). DSH port: see `LICENSE`.
+
+The six `skills/*/SKILL.md` files are verbatim copies, so they carry upstream's figures
+and citations rather than this package's. `/ponytail-gain` therefore reports the original
+five-task single-shot benchmark (80–94% fewer lines, 47–77% cheaper, 3–6× faster),
+which upstream's own README has since revised to roughly 54% fewer lines, 20% cheaper
+and 27% faster on its agentic benchmark.

package/cordis.patch.yml

@@ -0,0 +1,15 @@
+# The dsh-ponytail bundle patch: applied automatically when a profile lists
+# this bundle (`dsh plugin add`/`update` appends the package to
+# dsh.profile.bundles). Users override this row from their profile's own
+# cordis.patch.yml (live-watched; dsh.profile.bundles is frozen at boot) with a
+# `- id: ponytail` row, which replaces the row's whole `config`.
+# `name` stays a bare package specifier: the browser half is served by the
+# client module system, which resolves the Loader entry's package, reads its
+# `dsh.client` manifest, and serves `exports["./client"]`.
+# Do not also insert this same row into the profile patch: insert does not
+# dedupe ids, and a second row would register the plugin twice.
+- insert:
+    - id: ponytail
+      name: '@maci0/dsh-ponytail'
+      config:
+        defaultMode: full

package/icon.svg

@@ -0,0 +1,5 @@
+<svg width="36" height="36" viewBox="0 0 36 36" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <circle cx="12" cy="11.5" r="4.2" stroke="#0F6E56" stroke-width="2.2"/>
+  <circle cx="12" cy="24.5" r="4.2" stroke="#0F6E56" stroke-width="2.2"/>
+  <path d="M15.4 13.8L28 25.5M15.4 22.2L28 10.5" stroke="#1F8A70" stroke-width="2.2" stroke-linecap="round"/>
+</svg>

package/lib/client.js

@@ -0,0 +1,376 @@
+/**
+ * dsh-ponytail browser half.
+ *
+ * Two surfaces read one settings namespace:
+ *
+ * - the Ponytail card on the Plugins page, keyed on the
+ *   `ponytail` namespace the host half registers; and
+ * - a read-only level chip in the composer tool row (`conversation.input.left`),
+ *   so the active level is visible without opening Settings.
+ *
+ * Both read `ctx.configForms`, so they cannot disagree, and both take their
+ * copy from the `ponytail` locale namespace registered here (en/zh), which is
+ * also why every label has an English and a Chinese entry.
+ *
+ * Chrome is a stylesheet, not inline style objects: the module system claims
+ * every `<style>` tag a factory appends while it materializes and removes it
+ * when the package unloads, so the tags cost nothing to own. It also keeps
+ * state changes out of React's inline-style diffing, which is what silently
+ * blanked a deselected pill's border (a longhand removed against a set
+ * shorthand decomposes the shorthand).
+ *
+ * This file is plain JavaScript on purpose. The client module system serves a
+ * package's `exports["./client"]` artifact as a lazy-CJS factory registered on
+ * `window.__ModuleLoader__`, and that is the whole format: an out-of-tree
+ * plugin can author it directly instead of reproducing the repository's tsdown
+ * client preset. `react` is provided by the module system; nothing else is
+ * required here.
+ */
+
+window.__ModuleLoader__.load({
+  id: '@maci0/dsh-ponytail',
+
+  factory: (require) => {
+    var module = { exports: {} }
+    var exports = module.exports
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' })
+
+    const React = require('react')
+
+    /** Settings namespace shared with the host half; also this card's slot key. */
+    const NAMESPACE = 'ponytail'
+
+    /** Locale namespace for this plugin's copy: both surfaces read one dictionary. */
+    const LOCALE_NS = 'ponytail'
+
+    /**
+     * The host half's route reporting the level in use and its source. Same
+     * origin, so the session cookie rides along.
+     */
+    const LEVEL_ROUTE = '/ponytail/level'
+
+    /**
+     * How often a mounted surface re-reads the route. A session-local level
+     * changes without a settings write, so no snapshot change announces it.
+     */
+    const LEVEL_POLL_MS = 5000
+
+    /** Every class is `dp-`-prefixed: the sheet lands in the page's own document. */
+    const CSS = [
+      '.dp-page{display:flex;flex-direction:column;gap:10px}',
+      '.dp-body{border-top:0.5px solid var(--dsw-alias-border-l2);margin:0 16px;padding:12px 0 8px;display:flex;flex-direction:column;gap:10px}',
+      '.dp-row{display:flex;flex-wrap:wrap;gap:8px}',
+      '.dp-pill{appearance:none;font:inherit;font-size:13px;line-height:1.5;padding:5px 14px;cursor:pointer;color:var(--dsw-alias-label-secondary);background:none;border:1px solid var(--dsw-alias-border-l2);border-radius:999px}',
+      '.dp-pill-selected{color:var(--dsw-alias-label-primary);border-color:var(--dsw-alias-label-primary);background:var(--dsw-alias-bg-layer-4)}',
+      '.dp-pill:disabled{cursor:default;opacity:.5}',
+      '.dp-hint{font-size:12px;line-height:1.5;color:var(--dsw-alias-label-tertiary)}',
+      '.dp-status{display:flex;align-items:center;gap:8px;font-size:12px;line-height:1.5;color:var(--dsw-alias-label-tertiary)}',
+      '.dp-reset{appearance:none;font:inherit;font-size:12px;line-height:1.5;padding:3px 10px;cursor:pointer;color:var(--dsw-alias-label-secondary);background:none;border:1px solid var(--dsw-alias-border-l2);border-radius:8px}',
+      '.dp-error{font-size:12px;line-height:1.5;color:var(--dsw-alias-label-error)}',
+      '.dp-chip{display:inline-flex;align-items:center;height:24px;padding:0 10px;max-width:180px;overflow:hidden;white-space:nowrap;text-overflow:ellipsis;font-size:12px;line-height:1.4;color:var(--dsw-alias-label-secondary);background:var(--dsw-alias-bg-module-platform);border:1px solid var(--dsw-alias-border-l2);border-radius:999px}',
+    ].join('')
+
+    // Appended while the factory materializes: the module system claims the tag
+    // for this package and disposes it on unload. Guarded because the node unit
+    // tests evaluate this file without a DOM.
+    if (typeof document !== 'undefined') {
+      const style = document.createElement('style')
+      style.textContent = CSS
+      document.head.append(style)
+    }
+
+    const en = {
+      description: 'Lazy senior dev mode, level: {level}{note}.',
+      overridden: ' (overridden)',
+      fromSession: ' (this session only)',
+      sourceSession: 'Active for this session only; it is not saved in your settings.',
+      levelReview: 'Review',
+      hintReview: 'Over-engineering review: the model loads the ponytail-review skill.',
+      levelGroup: 'Ponytail level',
+      indicator: 'Ponytail: {level}',
+      levelOff: 'Off',
+      levelLite: 'Lite',
+      levelFull: 'Full',
+      levelUltra: 'Ultra',
+      hintOff: 'No ruleset injected. Normal behavior.',
+      hintLite: 'Build what was asked, and name the lazier alternative in one line.',
+      hintFull: 'The ladder enforced: YAGNI, reuse, stdlib, native platform, one line, then the minimum that works.',
+      hintUltra: 'Challenge whether the requirement needs to exist before building it.',
+      persists: 'Applies to every request and persists in your settings.',
+      readOnly: 'Read-only: settings are not persisted in this deployment.',
+      reset: 'Reset',
+      refused: 'The Host refused the change. Try again.',
+    }
+
+    const zh = {
+      description: '懒人资深开发模式，级别：{level}{note}。',
+      overridden: '（已覆盖）',
+      fromSession: '（仅本会话）',
+      sourceSession: '仅在本会话生效，不会保存到你的设置中。',
+      levelReview: '审查',
+      hintReview: '过度设计审查：模型加载 ponytail-review 技能。',
+      levelGroup: 'Ponytail 级别',
+      indicator: 'Ponytail：{level}',
+      levelOff: '关闭',
+      levelLite: '轻量',
+      levelFull: '完整',
+      levelUltra: '极端',
+      hintOff: '不注入任何规则集，行为如常。',
+      hintLite: '按要求实现，并用一行指出更省的做法。',
+      hintFull: '强制执行阶梯：YAGNI、复用、标准库、平台原生、已装依赖、一行，然后才是能用的最少代码。',
+      hintUltra: '动手之前先质疑这个需求是否必须存在。',
+      persists: '对每个请求生效，并保存在你的设置中。',
+      readOnly: '只读：此部署不会持久化设置。',
+      reset: '重置',
+      refused: 'Host 拒绝了更改，请重试。',
+    }
+
+    /** Levels a user may persist. `review` is session-only and lives on the command. */
+    const LEVELS = [
+      { value: 'off', label: 'levelOff', hint: 'hintOff' },
+      { value: 'lite', label: 'levelLite', hint: 'hintLite' },
+      { value: 'full', label: 'levelFull', hint: 'hintFull' },
+      { value: 'ultra', label: 'levelUltra', hint: 'hintUltra' },
+    ]
+
+    /** Every level the host may report: the persisted ones plus session-only `review`. */
+    const KNOWN_LEVELS = [...LEVELS, { value: 'review', label: 'levelReview', hint: 'hintReview' }]
+
+    /**
+     * Localized name of a level, falling back to the raw value for one this card
+     * does not offer (a hand-edited document, a future level).
+     * @param t - translate function bound to this plugin's namespace.
+     * @param mode - level value.
+     * @returns the display name.
+     */
+    function levelLabel(t, mode) {
+      const level = KNOWN_LEVELS.filter((candidate) => candidate.value === mode)[0]
+      return level === undefined ? mode : t(level.label)
+    }
+
+    /**
+     * Bind one scope to a React subscription.
+     * @param scope - a scope bound to the ponytail settings namespace.
+     * @returns a hook reading that scope's current snapshot.
+     */
+    function useScope(scope) {
+      const subscribe = (listener) => scope.subscribe(listener)
+      const getSnapshot = () => scope.getSnapshot()
+      return () => React.useSyncExternalStore(subscribe, getSnapshot)
+    }
+
+    /**
+     * Read a snapshot's level. A namespace the deployment does not serve reports
+     * no value, which every surface renders as nothing.
+     * @param snapshot - the settings scope snapshot.
+     * @returns the active level value, or `undefined` when unreadable.
+     */
+    function modeOf(snapshot) {
+      if (snapshot.status !== 'ready') return undefined
+      const value = snapshot.value !== null && typeof snapshot.value === 'object' ? snapshot.value : {}
+      return typeof value.defaultMode === 'string' ? value.defaultMode : 'full'
+    }
+
+    /**
+     * Read the level the host half is using, re-reading on every settings
+     * change and on a timer. `null` until the route answers, and whenever it
+     * cannot (an older host half, a rejected request): the surfaces then fall
+     * back to the settings document.
+     * @param snapshot - the settings scope snapshot; a new one triggers a read.
+     * @returns `{ mode, source }` from the host, or `null`.
+     */
+    function useHostLevel(snapshot) {
+      const [level, setLevel] = React.useState(null)
+      React.useEffect(() => {
+        let live = true
+        const controller = new AbortController()
+        const read = () => {
+          fetch(LEVEL_ROUTE, { headers: { accept: 'application/json' }, signal: controller.signal })
+            .then((response) => (response.ok ? response.json() : null))
+            .then((body) => { if (live) setLevel(hostLevelOf(body)) })
+            .catch(() => { if (live) setLevel(null) })
+        }
+        read()
+        const timer = setInterval(read, LEVEL_POLL_MS)
+        return () => {
+          live = false
+          controller.abort()
+          clearInterval(timer)
+        }
+      }, [snapshot])
+      return level
+    }
+
+    /**
+     * Validate the route's answer: a JSON body is input from the wire.
+     * @param body - the parsed response.
+     * @returns `{ mode, source }` when both are strings, else `null`.
+     */
+    function hostLevelOf(body) {
+      if (body === null || typeof body !== 'object') return null
+      if (typeof body.mode !== 'string' || typeof body.source !== 'string') return null
+      return { mode: body.mode, source: body.source }
+    }
+
+    /**
+     * The level a surface shows: the host's when it answered, else the
+     * settings document's. `undefined` while the namespace is not served.
+     * @param snapshot - the settings scope snapshot.
+     * @param host - the route's answer, or `null`.
+     * @returns the level value, or `undefined`.
+     */
+    function shownMode(snapshot, host) {
+      const documented = modeOf(snapshot)
+      if (documented === undefined) return undefined
+      return host === null ? documented : host.mode
+    }
+
+    /**
+     * Build the card component over one bound settings scope.
+     * @param scope - the scope bound to the ponytail namespace.
+     * @param t - translate function bound to this plugin's locale namespace.
+     * @returns the component the slot renders.
+     */
+    function createCard(scope, t) {
+      const usePonytail = useScope(scope)
+
+      return function PonytailCard(props) {
+        const snapshot = usePonytail()
+        const [error, setError] = React.useState(null)
+        const [pending, setPending] = React.useState(false)
+        const host = useHostLevel(snapshot)
+
+        const current = shownMode(snapshot, host)
+        // A namespace this deployment does not serve renders no trace of itself.
+        if (current === undefined) return null
+
+        const user = snapshot.user !== null && typeof snapshot.user === 'object' ? snapshot.user : {}
+        const overridden = Object.prototype.hasOwnProperty.call(user, 'defaultMode')
+        const disabled = !snapshot.writable || pending
+        const selected = KNOWN_LEVELS.filter((level) => level.value === current)[0]
+        const sessionOnly = host !== null && host.source === 'session'
+        if (props != null && props.view === 'summary') {
+          return t('description', {
+            level: levelLabel(t, current),
+            note: sessionOnly ? t('fromSession') : overridden ? t('overridden') : '',
+          })
+        }
+
+        const report = (cause) => {
+          setError(cause instanceof Error ? cause.message : String(cause))
+        }
+        const write = (run) => {
+          if (disabled) return
+          setError(null)
+          setPending(true)
+          new Promise((resolve) => { resolve(run()) }).then((accepted) => {
+            if (accepted === false) setError(t('refused'))
+          }).catch(report).finally(() => { setPending(false) })
+        }
+
+        return React.createElement(
+          'div',
+          { className: 'dp-page' },
+          React.createElement(
+            'div',
+            { className: 'dp-body' },
+              React.createElement(
+                'div',
+                { className: 'dp-row', role: 'radiogroup', 'aria-label': t('levelGroup') },
+                LEVELS.map((level) => React.createElement(
+                  'button',
+                  {
+                    key: level.value,
+                    type: 'button',
+                    role: 'radio',
+                    'aria-checked': current === level.value,
+                    disabled,
+                    className: `dp-pill${current === level.value ? ' dp-pill-selected' : ''}`,
+                    onClick: () => { write(() => scope.set('defaultMode', level.value)) },
+                  },
+                  t(level.label),
+                )),
+              ),
+              selected === undefined ? null : React.createElement('div', { className: 'dp-hint' }, t(selected.hint)),
+              sessionOnly ? React.createElement('div', { className: 'dp-hint' }, t('sourceSession')) : null,
+              React.createElement(
+                'div',
+                { className: 'dp-status' },
+                snapshot.writable ? t('persists') : t('readOnly'),
+                overridden
+                  ? React.createElement(
+                    'button',
+                    {
+                      type: 'button',
+                      className: 'dp-reset',
+                      disabled,
+                      onClick: () => { write(() => scope.unset('defaultMode')) },
+                    },
+                    t('reset'),
+                  )
+                  : null,
+              ),
+              error === null ? null : React.createElement('div', { className: 'dp-error' }, error),
+            ),
+        )
+      }
+    }
+
+    /**
+     * Build the read-only level chip for the composer tool row.
+     *
+     * It reads the same settings scope the card edits, so the two surfaces can
+     * never disagree; it renders nothing while the namespace is unavailable or
+     * the level is `off`, where a chip would only say "nothing is injected".
+     * @param scope - the scope bound to the ponytail namespace.
+     * @param t - translate function bound to this plugin's locale namespace.
+     * @returns the component the composer slot renders.
+     */
+    function createIndicator(scope, t) {
+      const usePonytail = useScope(scope)
+
+      return function PonytailIndicator() {
+        const snapshot = usePonytail()
+        const current = shownMode(snapshot, useHostLevel(snapshot))
+        if (current === undefined || current === 'off') return null
+
+        const text = t('indicator', { level: levelLabel(t, current) })
+        return React.createElement('span', { className: 'dp-chip', title: text }, text)
+      }
+    }
+
+    /**
+     * Mount both browser surfaces: the Plugins card and the composer chip.
+     * @param ctx - the browser plugin context.
+     */
+    function apply(ctx) {
+      const t = ctx.locale.bind(LOCALE_NS)
+      ctx.effect(
+        () => ctx.locale.register(LOCALE_NS, { en, zh }),
+        'dsh-ponytail: locale dictionary',
+      )
+
+      const scope = ctx.configForms.get(NAMESPACE)
+      const Card = createCard(scope, t)
+      const Indicator = createIndicator(scope, t)
+
+      // Each owner declares its own slot; injecting waits for it to exist, so
+      // these registrations do not depend on plugin load order.
+      ctx.slots.inject('plugins.row.config', () => ctx.slots.register({
+        name: 'plugins.row.config',
+        key: '@maci0/dsh-ponytail#ponytail',
+        locale: LOCALE_NS,
+      }, Card))
+
+      ctx.slots.inject('conversation.input.left', () => ctx.slots.register({
+        name: 'conversation.input.left',
+        id: 'ponytail-level',
+        order: 20,
+      }, Indicator))
+    }
+
+    exports.apply = apply
+    exports.inject = ['slots', 'configForms', 'locale']
+    return module.exports
+  },
+})