@aryacode/dsh-aryacode-polish 0.0.0-stage → 0.2.4

package/CHANGELOG.md

@@ -0,0 +1,96 @@
+# Changelog
+
+## [0.2.4] - 2026-10-27
+
+### Changed
+
+- **The card leads with the number it is about.** It now opens with the
+  "Estimated session cost" heading and the live `≈$…` amount, then a stacked bar
+  showing how the session's tokens split between cached input, uncached input,
+  cache writes and output, then the rows: cache hit, tokens, model, provider,
+  requests, and the estimate again above the footnote. Model and provider are
+  always named (they were only listed when a session had more than one), so a
+  first look says which route the money was spent on.
+
+## [0.2.3] - 2026-10-27
+
+### Fixed
+
+- **A sub-cent turn no longer reads `≈$0`.** `formatMoney` rounded to three
+  decimals, so a real 22.1K-token turn whose actual cost was about $0.000095
+  showed as zero. Amounts under a cent now keep two significant digits
+  (`≈$0.000095`), cents keep three decimals, and dollars keep two.
+
+## [0.2.2] - 2026-10-27
+
+### Fixed
+
+- The pill's `≈` was stored as cp1252 mojibake (`≈`), so a real turn rendered
+  `≈$0.003` instead of `≈$0.003`. Same cause as the two strings repaired in
+  0.2.1 — a PowerShell round-trip over the face source — and the last of that
+  damage. Verified against a real turn in Dev AryaCode.
+
+## [0.2.1] - 2026-10-27
+
+### Fixed
+
+- **The Configure page found no form.** The page body asked
+  `configForms.get('<package>#<row>')`, but the Plugins page builds a row's form
+  from the **row id** alone (`PluginManagerPage.tsx:1735` passes
+  `form={formFor(openRow.rowId)}`, and `formFor` matches `view.ns === id`). The
+  lookup now asks for `polish`, so the row's page reads the live form instead of
+  saying the row has no configuration to change. The `plugins.row.config`
+  registration key is unchanged: that one is still `<package>#<row>`.
+- Two strings that a PowerShell round-trip had written as cp1252 mojibake
+  (`Loading configuration…`, `Saving…`, and an em dash) are back to UTF-8.
+
+## [0.2.0] - 2026-10-27
+
+### Added
+
+- **Estimated session cost.** A composer-dock pill (`≈$0.39`) that opens a
+  breakdown card: cache hit, uncached input, cached input, output, requests, and
+  the estimate itself, with the same "your provider's bill is authoritative"
+  footnote. The money is computed **host-side**: `entries/usage.js` folds
+  model-attributed usage out of the durable session log, and `entries/cost.js`
+  registers a `polishCost` projection whose wire view is already priced at the
+  published DeepSeek rates (off-peak table, peak at 2×, cache writes billed as
+  misses). The browser half only formats numbers, so no rate table ships to the
+  client and an unknown model or provider leaves the estimate marked incomplete
+  instead of quietly reporting a wrong number.
+- **`test/cost.spec.mjs`.** Fold and pricing coverage: peak/off-peak, cache
+  rates, cache writes as misses, unknown route handling, retry accounting, and
+  the empty-session wire view.
+
+## [0.1.1] - 2026-10-27
+
+### Added
+
+- **The row's Configure page.** `lib/client.js` is the bundle's browser face: it
+  registers the `polish` row's configuration page, so the row now has a page of
+  its own that reads the row's live config form and writes it back with the
+  Host's revision. With no feature landed yet the page states that plainly
+  instead of showing a switch that toggles nothing.
+- **`client/switches.json`.** The browser half of the feature seam: one entry per
+  switch, and `test/client-face.spec.mjs` fails when it and `entries/registry.js`
+  disagree in either direction.
+
+## [0.1.0] - 2026-10-27
+
+### Added
+
+- **AryaCode Polish bundle.** One package, one row (`polish`), one switch per
+  quality-of-life feature, so each refinement can be turned off from its
+  Configure page without uninstalling the bundle.
+- **Feature seam.** `entries/registry.js` is the single list of features, and the
+  row's config schema is derived from it: a new entry gains its volatile switch
+  with no second registration, and switching a feature off disposes its host
+  half instead of merely hiding it.
+- **`docs/parked-spellcheck.md`.** Records why right-click spelling corrections
+  cannot be a plugin, and the exact shell change that would restore them.
+
+### Not shipped
+
+- Right-click spelling corrections. The candidates came from Chromium's
+  spellchecker through the Electron main process; the shell no longer reads
+  them, and no plugin contract can reach that menu. Parked with evidence.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 KonnectSuite
+
+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,135 @@
-# Temporary Holding Version
+# AryaCode Polish
 
-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.
+One install for the small things that make AryaCode feel finished.
+
+AryaCode Polish is a plugin **bundle**: it adds surfaces to the app it is
+installed into and patches nothing. It is one package, one Plugins row, and one
+switch per feature, so a refinement that turns out to be wrong for a machine can
+be turned off without uninstalling anything.
+
+Status: **0.2.0.** One feature shipped: the estimated session cost pill.
+
+## What it is
+
+- **One row.** The bundle inserts a single row, id `polish`, into the profile's
+  composition (`cordis.patch.yml`). That row is the install surface: it mounts
+  the host half of every enabled feature and names the bare package specifier so
+  the Shell can find the browser face.
+- **One switch per feature.** Every feature is gated by its own boolean in the
+  row's Configure page, on by default. Turning it off disposes that feature only.
+- **Additive.** No fork of the shell, no edits to `app.asar`, no patched
+  installed app, no DOM hacks against private class names.
+
+## Switches
+
+Row: **AryaCode Polish** (`polish`).
+
+Each entry in `entries/registry.js` becomes one volatile boolean in this
+Configure page automatically.
+
+| Switch | Default | What it does |
+| --- | --- | --- |
+| **Estimated session cost** (`sessionCost`) | On | A `≈$0.39` pill in the composer dock that opens a breakdown card — cache hit, uncached input, cached input, output, requests, and the estimate — priced from the session's recorded usage at the published DeepSeek rates. |
+
+### How the cost is computed
+
+The numbers come from the Host, never from the browser:
+
+- `entries/usage.js` folds model-attributed provider usage out of the durable
+  session log, one row per provider, model, and hour, and tags each band as peak
+  or off-peak (Beijing weekdays 09–12 and 14–18 are billed at 2×).
+- `entries/cost.js` registers the `polishCost` projection and prices that fold:
+  cache reads at the cache rate, uncached input and cache writes at the miss
+  rate, output at the output rate. The wire view is already money, so no rate
+  table reaches the client.
+- An unknown provider, model, or rate period keeps its tokens and marks the
+  estimate **incomplete** — the pill says so rather than reporting a number it
+  cannot stand behind.
+- The rate table is dated and lives in one place. When DeepSeek changes prices,
+  append a period; do not edit history.
+
+## Declaring a feature
+
+`entries/registry.js` is the single list of features. One entry is one feature:
+
+```js
+{
+  id: 'spellcheck',              // becomes the config field and the switch
+  label: 'Spelling corrections',
+  description: 'Right-click a misspelled word to pick a correction.',
+  defaultOn: true,
+  mount: spellcheck,             // optional host half: a Cordis plugin
+}
+```
+
+The row's `Config` schema is derived from that list, so a new entry gains its
+volatile switch with no second registration. `mount` is plugged in when the
+switch is on and disposed when it is off, so a disabled feature stops costing the
+app rather than merely hiding. A feature that only draws UI omits `mount` and
+contributes a client face instead.
+
+## Parked
+
+**Right-click spelling corrections** — investigated and not shipped. The
+candidates you saw in AryaAI came from Chromium's spellchecker through the
+Electron main process, which the AryaCode shell no longer reads; a plugin cannot
+reach it. The finding, the exact 10-line shell change that would restore it, and
+why the plugin alternatives were rejected are in
+[`docs/parked-spellcheck.md`](docs/parked-spellcheck.md).
+
+## Install
+
+From the AryaCode Plugins market: open the market, find **AryaCode Polish**,
+install, then quit and reopen AryaCode — the market registry is cached in the
+running process.
+
+Manual, for development only:
+
+```bash
+node --import tsx/esm apps/cli/src/bin.ts plugin --profile web add <path-to-tgz>
+```
+
+## Requirements
+
+- AryaCode with the Cordis plugin API (`@deepseek-ai/cordis ~4.0.4`).
+- Node `^22.19.0 || >=24.0.0` to build from source.
+
+## Development
+
+```bash
+pnpm install
+pnpm test        # patch shape, config accessors, feature seam, docs parity
+pnpm pack        # produces aryacode-dsh-aryacode-polish-<version>.tgz
+```
+
+Test on **Dev AryaCode** (`%LOCALAPPDATA%\AryaCode-dev\home`), never on the
+installed app.
+
+## Layout
+
+```
+cordis.patch.yml     one insert, one row
+entries/polish.js    the row: Config derived from the registry, apply()
+entries/registry.js  the feature list — the one place a feature is declared
+entries/usage.js     the fold: model-attributed usage out of the session log
+entries/cost.js      the polishCost projection: rates, pricing, host mount
+entries/features/    one module per feature
+entries/config.js    volatile-reference accessors (resolve/flag/list/text)
+lib/index.js         mount point re-exporting the row
+client/face.js       browser face source: the Configure page and every surface
+client/switches.json the browser half of the seam — one entry per switch
+scripts/build-client.mjs  wraps client/face.js into lib/client.js
+lib/client.js        generated: the bundle the Shell loads
+locale/              card title and description (en, zh)
+docs/                parked investigations
+test/                node --test specs
+```
+
+The Configure page is generated, not hand-maintained: `lib/client.js` is built
+from `client/face.js` and `client/switches.json` by `pnpm build:client` (which
+`pnpm pack` runs), and `test/client-face.spec.mjs` fails when `switches.json` and
+`entries/registry.js` disagree in either direction.
+
+## Licence
+
+MIT © KonnectSuite

package/client/face.js

@@ -0,0 +1,342 @@
+/**
+ * AryaCode Polish — the browser face.
+ *
+ * This file is deliberately not a module. `scripts/build-client.mjs` wraps it in
+ * the Shell's `__ModuleLoader__.load({ id, factory })` factory and prepends the
+ * switch list from `client/switches.json`, so `require` is the Shell's frozen
+ * module table and never Node's `require`. Keep `require(...)` limited to names
+ * the Shell answers; anything else must be inlined here.
+ *
+ * The Configure page is the point of this package: one boolean per feature, on
+ * by default, and the host half of a feature is disposed when its switch turns
+ * off. The page reads the row's live config form, so adding a feature needs no
+ * second registration here — one line in `client/switches.json` and a matching
+ * entry in `entries/registry.js`, and the tests fail if the two disagree.
+ */
+
+const React = require('react')
+
+/** Shared spacing for the page's prose. */
+const SPACING = { margin: '0 0 10px', opacity: 0.85, lineHeight: '1.5' }
+
+/**
+ * Read one switch out of a configuration object.
+ * @param value - the row's configuration object, when it has loaded.
+ * @param entry - the declared switch.
+ * @returns the boolean the switch holds, falling back to its declared default.
+ */
+function switchValue(value, entry) {
+  const current = value === undefined || value === null ? undefined : value[entry.key]
+  if (typeof current === 'boolean') return current
+  return entry.defaultOn !== false
+}
+
+/**
+ * Subscribe to one switch of this row's live configuration.
+ * @param configForms - the Shell's config-form service, or a getter for it.
+ * @param key - the switch to read.
+ * @param fallback - the value to use while the row's configuration has not loaded.
+ * @returns the switch's boolean value.
+ */
+function useSwitch(configForms, key, fallback) {
+  const resolved = typeof configForms === 'function' ? configForms() : configForms
+  const live = resolved === undefined ? undefined : resolved.get(ROW_ID)
+  const subscribe = React.useCallback(
+    listener => (live === undefined ? () => {} : live.subscribe(listener)),
+    [live],
+  )
+  const snapshot = React.useCallback(
+    () => (live === undefined ? undefined : live.getSnapshot()),
+    [live],
+  )
+  const state = React.useSyncExternalStore(subscribe, snapshot)
+  const value = state?.value
+  const current = value === undefined || value === null ? undefined : value[key]
+  return typeof current === 'boolean' ? current : fallback
+}
+
+/**
+ * The row's Configure page and its one-line summary.
+ * @param props - the page's `view`, the Host's `form`, and our lazy `configForms`.
+ * @returns the page node, the summary node, or a status line.
+ */
+function PolishConfig(props) {
+  const { form, view } = props
+
+  // Resolved lazily: the Settings page's own client half may load after this face.
+  const configForms = typeof props.configForms === 'function' ? props.configForms() : props.configForms
+  const live = configForms === undefined ? undefined : configForms.get(ROW_ID)
+  const subscribe = React.useCallback(
+    listener => (live === undefined ? () => {} : live.subscribe(listener)),
+    [live],
+  )
+  const snapshot = React.useCallback(
+    () => (live === undefined ? form?.state : live.getSnapshot()),
+    [live, form],
+  )
+  const state = React.useSyncExternalStore(subscribe, snapshot)
+  const [draft, setDraft] = React.useState(null)
+  const [saving, setSaving] = React.useState(false)
+  const [notice, setNotice] = React.useState('')
+
+  const count = SWITCHES.length
+  const summary = count === 0 ? 'No switch registered yet.' : count === 1 ? '1 switch.' : count + ' switches.'
+
+  if (view === 'summary') return React.createElement('span', null, summary)
+
+  if (count === 0) {
+    return React.createElement('div', null,
+      React.createElement('p', { style: SPACING },
+        'No switch is registered yet. This page grows one checkbox per feature as features land; '
+        + 'there is nothing here that can be toggled into a half-installed state.'),
+      React.createElement('p', { style: SPACING },
+        'A feature needs two lines: an entry in ',
+        React.createElement('code', null, 'entries/registry.js'),
+        ' that declares its switch and host half, and a matching entry in ',
+        React.createElement('code', null, 'client/switches.json'),
+        ' that names it here. The tests fail if the two disagree.'),
+    )
+  }
+
+  if (state === undefined) {
+    return React.createElement('p', { style: SPACING }, 'This row does not expose its configuration to the Plugins page.')
+  }
+  const value = state.value
+  if (value === undefined) {
+    return React.createElement('p', { style: SPACING },
+      state.status === 'unavailable' ? 'This row has no configuration to change.' : 'Loading configuration…')
+  }
+
+  const current = draft === null ? value : draft
+  const dirty = SWITCHES.some(entry => switchValue(current, entry) !== switchValue(value, entry))
+  const writable = state.writable === true
+  const setSwitch = (key, next) => {
+    setDraft({ ...current, [key]: next })
+    setNotice('')
+  }
+  const save = async () => {
+    if (saving || !dirty) return
+    setSaving(true)
+    setNotice('')
+    try {
+      const ops = SWITCHES.map(entry => ({ op: 'set', path: [entry.key], value: switchValue(current, entry) }))
+      const owner = live === undefined ? form : live
+      const accepted = await owner.mutate(ops, state.revision)
+      if (accepted) {
+        setDraft(null)
+        setNotice('Saved. A feature switched off stops running now, not after a restart.')
+      } else {
+        setNotice('The Host refused the change.')
+      }
+    } catch (error) {
+      setNotice(error instanceof Error ? error.message : String(error))
+    }
+    setSaving(false)
+  }
+
+  return React.createElement('div', { style: { display: 'grid', gap: '16px' } },
+    React.createElement('p', { style: SPACING },
+      'Every switch is additive and on by default. Switching one off disposes that feature only — '
+      + 'it stops costing the app instead of merely hiding.'),
+    React.createElement('div', { style: { display: 'grid', gap: '14px' } },
+      SWITCHES.map(entry => React.createElement('label', {
+        key: entry.key,
+        style: { display: 'grid', gridTemplateColumns: 'auto 1fr', gap: '10px', alignItems: 'start', cursor: writable ? 'pointer' : 'default' },
+      },
+      React.createElement('input', {
+        type: 'checkbox',
+        checked: switchValue(current, entry),
+        disabled: !writable || saving,
+        onChange: event => setSwitch(entry.key, event.target.checked),
+      }),
+      React.createElement('span', null,
+        React.createElement('span', { style: { display: 'block', fontWeight: 600 } }, entry.label),
+        React.createElement('span', { style: { display: 'block', opacity: 0.8, lineHeight: '1.45' } }, entry.description),
+      ))),
+    ),
+    React.createElement('div', { style: { display: 'flex', gap: '10px', alignItems: 'center' } },
+      React.createElement('button', {
+        type: 'button',
+        disabled: !writable || saving || !dirty,
+        onClick: save,
+      }, saving ? 'Saving…' : 'Save'),
+      React.createElement('span', { style: { opacity: 0.8 } },
+        notice !== '' ? notice : writable ? '' : 'This row is read-only in the current composition.')),
+  )
+}
+
+/** Money from the wire view, which already did the arithmetic host-side. */
+function formatMoney(value) {
+  const amount = Number(value)
+  if (!Number.isFinite(amount) || amount <= 0) return ''
+  // Pennies matter at the top and single tokens matter at the bottom: a small
+  // turn really does cost a fraction of a cent, and "$0" would hide it.
+  const fixed = amount >= 1 ? amount.toFixed(2)
+    : amount >= 0.01 ? amount.toFixed(3)
+      : amount.toPrecision(2)
+  const text = fixed.includes('e') ? amount.toFixed(8) : fixed
+  return '$' + text.replace(/(\.\d*?)0+$/, '$1').replace(/\.$/, '')
+}
+
+/** Token counts, grouped, the way the harness pill next to ours reads. */
+function formatTokens(value) {
+  const count = Number(value)
+  return Number.isFinite(count) ? new Intl.NumberFormat('en-US').format(count) + ' tok' : ''
+}
+
+/** One label/value line of the breakdown card. */
+function detailRow(label, value, key) {
+  return React.createElement('div', {
+    key,
+    style: { display: 'flex', justifyContent: 'space-between', gap: '16px', padding: '2px 0' },
+  },
+  React.createElement('span', { style: { opacity: 0.75 } }, label),
+  React.createElement('span', null, value))
+}
+
+/** The small text under the card that keeps the number honest. */
+const COST_FOOTNOTE = 'Based on recorded usage and published rates. Your provider\'s bill is authoritative.'
+
+/**
+ * The composer-dock pill, and the breakdown card it opens.
+ * Reads the priced projection the Host registers, so no rate table or money
+ * arithmetic runs in the browser.
+ * @param props - standard session props plus our lazy `configForms`.
+ * @returns the pill, or nothing while the feature is off or the session has no usage.
+ */
+function CostPill(props) {
+  const switched = useSwitch(props.configForms, 'sessionCost', true)
+  const usage = typeof props.useProjection === 'function' ? props.useProjection('polishCost') : undefined
+  const [open, setOpen] = React.useState(false)
+  const root = React.useRef(null)
+
+  React.useEffect(() => {
+    if (!open) return undefined
+    const close = event => {
+      if (root.current !== null && !root.current.contains(event.target)) setOpen(false)
+    }
+    document.addEventListener('pointerdown', close)
+    return () => document.removeEventListener('pointerdown', close)
+  }, [open])
+
+  if (!switched) return null
+  const tokens = typeof usage?.tokens === 'number' ? usage.tokens : 0
+  if (tokens === 0) return null
+  const money = formatMoney(usage.costUsd)
+  const label = money === '' ? 'Not priced' : (usage.incomplete ? '≈' + money + ' partially priced' : '≈' + money)
+  const cacheHit = tokens === 0 ? 0 : Math.round((usage.cacheRead ?? 0) / tokens * 100)
+  const models = Array.isArray(usage.models) ? usage.models : []
+
+  const modelName = models.length === 0 ? 'unknown'
+    : models.length === 1 ? models[0].model
+      : models.length + ' models'
+  const providerName = models.length === 0 ? 'unknown'
+    : models.length === 1 ? models[0].provider
+      : models.length + ' providers'
+  const segment = (value, shade, key) => {
+    const countValue = Number(value ?? 0)
+    if (!Number.isFinite(countValue) || countValue <= 0) return null
+    return React.createElement('div', {
+      key,
+      style: { flexGrow: countValue, background: 'color-mix(in srgb, CanvasText ' + shade + '%, transparent)' },
+    })
+  }
+  const bar = React.createElement('div', {
+    style: {
+      display: 'flex',
+      height: '6px',
+      margin: '10px 0 12px',
+      borderRadius: '999px',
+      overflow: 'hidden',
+      background: 'color-mix(in srgb, CanvasText 10%, transparent)',
+    },
+  },
+  segment(usage.cacheRead, 22, 'bar-cached'),
+  segment(usage.uncached, 48, 'bar-uncached'),
+  segment(usage.cacheWrite, 62, 'bar-cache-write'),
+  segment(usage.output, 82, 'bar-output'))
+
+  return React.createElement('div', {
+    ref: root,
+    style: { position: 'relative', display: 'inline-flex', alignItems: 'center' },
+  },
+  React.createElement('button', {
+    type: 'button',
+    onClick: () => setOpen(!open),
+    title: 'Estimated session cost',
+    style: {
+      background: 'transparent',
+      border: 'none',
+      color: 'inherit',
+      cursor: 'pointer',
+      font: 'inherit',
+      padding: '0 2px',
+      opacity: 0.8,
+    },
+  }, label),
+  open
+    ? React.createElement('div', {
+      style: {
+        position: 'absolute',
+        bottom: '100%',
+        left: 0,
+        marginBottom: '8px',
+        width: '320px',
+        padding: '14px',
+        borderRadius: '10px',
+        border: '1px solid color-mix(in srgb, CanvasText 16%, transparent)',
+        background: 'Canvas',
+        color: 'CanvasText',
+        boxShadow: '0 10px 30px color-mix(in srgb, CanvasText 18%, transparent)',
+        fontSize: '12px',
+        lineHeight: '1.5',
+        zIndex: 40,
+      },
+    },
+    React.createElement('div', {
+      style: { display: 'flex', justifyContent: 'space-between', gap: '16px', fontWeight: 500 },
+    },
+    React.createElement('span', null, 'Estimated session cost'),
+    React.createElement('span', null, label)),
+    bar,
+    detailRow('Cache hit', cacheHit + '%', 'cache-hit'),
+    detailRow('Uncached input', formatTokens(usage.uncached), 'uncached'),
+    detailRow('Cached input', formatTokens(usage.cacheRead), 'cached'),
+    (usage.cacheWrite ?? 0) > 0 ? detailRow('Cache write', formatTokens(usage.cacheWrite), 'cache-write') : null,
+    detailRow('Output', formatTokens(usage.output), 'output'),
+    detailRow('Model', modelName, 'model'),
+    detailRow('Provider', providerName, 'provider'),
+    detailRow('Requests', String(usage.requests ?? 0), 'requests'),
+    React.createElement('div', { style: { borderTop: '1px solid color-mix(in srgb, CanvasText 12%, transparent)', margin: '8px 0' } }),
+    detailRow('Estimated session cost', money === '' ? 'Not priced' : money, 'cost'),
+    React.createElement('p', { style: { margin: '10px 0 0', opacity: 0.7, fontSize: '11px' } }, COST_FOOTNOTE))
+    : null)
+}
+
+return {
+  inject: ['slots'],
+  /**
+   * Register this bundle's surfaces.
+   * @param ctx - the browser plugin context.
+   */
+  apply(ctx) {
+    const configForms = () => {
+      try {
+        return ctx.get('configForms')
+      } catch {
+        return undefined
+      }
+    }
+    ctx.slots.inject('plugins.row.config', () => ctx.slots.register({
+      name: 'plugins.row.config',
+      key: ROW_KEY,
+      inject: () => ({ configForms }),
+    }, PolishConfig))
+    ctx.slots.inject('conversation.composer.dock', () => ctx.slots.register({
+      name: 'conversation.composer.dock',
+      id: 'polish-cost',
+      order: 2,
+      inject: () => ({ configForms }),
+    }, CostPill))
+  },
+}

package/client/switches.json

@@ -0,0 +1,11 @@
+{
+  "row": "polish",
+  "switches": [
+    {
+      "key": "sessionCost",
+      "label": "Estimated session cost",
+      "description": "Show what the open session has cost so far, priced from recorded usage at the published DeepSeek rates.",
+      "defaultOn": true
+    }
+  ]
+}

package/cordis.patch.yml

@@ -0,0 +1,17 @@
+# AryaCode Polish bundle.
+#
+# One row. The row is the install surface: mounting it mounts the host half of
+# every feature, and it names the bare package specifier because the Shell
+# classifies a client row by `exactPackageSpecifier` — a subpath such as
+# `@aryacode/dsh-aryacode-polish/polish` is rejected and yields no client entry.
+#
+# The feature switches are the row's config, not separate rows:
+#
+#   spellcheck → right-click spelling corrections in the composer   (on)
+#
+# The patch only ever inserts. It must never target a row another bundle owns:
+# a profile without that row makes composition fail ("patch: entry ... not
+# found"), which is why the patch is kept to its own one row.
+- insert:
+    - id: polish
+      name: '@aryacode/dsh-aryacode-polish'