@linxin666/dsh-pet 0.1.14 → 0.1.15

package/lib/types/service.js

@@ -1,136 +1,44 @@
 /**
- * Pet host service — the `pet.*` RPC domain. Owns the state machine wiring
- * (projects official session events and accepts legacy `activity/status`), the
- * affinity ledger, and the persisted display config. The API gateway maps
- * this service's methods onto `pet.state` / `pet.interact` /
- * `pet.setVisible` / `pet.setConfig` for browser consumers.
+ * Pet host service — the `pet.*` RPC domain. A composition facade: it wires
+ * the pure event projection (`event-projection`) onto the state machine,
+ * delegates the affinity economy to the ledger (`ledger`), and routes
+ * persistence through `persist`. The API gateway maps these methods onto
+ * `pet.state` / `pet.interact` / `pet.setVisible` / `pet.setConfig` for
+ * browser consumers.
  * @module @linxin666/dsh-pet/service
  */
 import { Service } from '@deepseek-ai/cordis';
-import { applyInteraction, applyTurnReward, defaultAffinityConfig, rankOf, } from "./affinity.js";
-import { loadPetPersist, petHomeDir, savePetPersist, DISPLAY_SIZE_MAX, DISPLAY_SIZE_MIN, DISPLAY_INSET_MAX, PET_NAME_MAX_LENGTH, } from "./persist.js";
-import { defaultTreatConfig, settleTreatGrants, consumeTreat, } from "./treats.js";
+import { emptyProjectionRuntime, isActivityPhase, projectOfficialEvent, } from "./event-projection.js";
+import { PetLedger } from "./ledger.js";
+import { DISPLAY_INSET_MAX, DISPLAY_SIZE_MAX, DISPLAY_SIZE_MIN, PET_NAME_MAX_LENGTH, loadPetPersist, petHomeDir, savePetPersist, } from "./persist.js";
 import { defaultPetStateConfig, PetStateMachine, } from "./state.js";
 /** Settings namespace of the pet capability. Spelled here rather than imported: the browser half spells the same value. */
 export const PET_SETTINGS_NAMESPACE = 'pet';
-/** Keep tool names readable inside the compact status bubble. */
-function displayToolName(name) {
-    const compact = name.replace(/\s+/g, ' ').trim() || '工具';
-    return compact.length <= 24 ? compact : `${compact.slice(0, 21)}...`;
-}
-/** Whether a legacy phase is part of the pet's supported vocabulary. */
-function isActivityPhase(phase) {
-    return ['idle', 'waiting', 'thinking', 'tool', 'review', 'done', 'failed'].includes(phase);
-}
-/**
- * Project the durable DSH session vocabulary into the pet's visual phases.
- * Unknown and log-only events do not disturb the last meaningful activity.
- */
-function projectOfficialEvent(event, runtime) {
-    switch (event.type) {
-        case 'turn/start':
-            runtime.activeTools.clear();
-            runtime.stepHadFailure = false;
-            return { input: { phase: 'waiting', line: '准备开始' } };
-        case 'step/start':
-            runtime.activeTools.clear();
-            runtime.stepHadFailure = false;
-            return { input: { phase: 'waiting', line: '等待模型响应' } };
-        case 'assistant/chunk': {
-            const { chunk } = event.data;
-            if (chunk.type === 'reasoning-delta' && chunk.text.length > 0) {
-                return { input: { phase: 'thinking', line: '正在思考' } };
-            }
-            if (chunk.type === 'text-delta' && chunk.text.length > 0) {
-                return { input: { phase: 'review', line: '整理回复中' } };
-            }
-            return undefined;
-        }
-        case 'assistant/message':
-            return { input: { phase: 'review', line: '整理回复中' } };
-        case 'tool/call':
-            runtime.activeTools.add(String(event.data.callId));
-            return {
-                input: {
-                    phase: 'tool',
-                    line: `正在使用 ${displayToolName(event.data.name)}`,
-                },
-            };
-        case 'tool/result': {
-            const block = event.data.message.content[0];
-            runtime.activeTools.delete(String(event.data.message.source.callId));
-            runtime.stepHadFailure ||= event.data.error !== undefined || block.isError === true;
-            if (runtime.activeTools.size > 0) {
-                return {
-                    input: {
-                        phase: 'tool',
-                        line: `还有 ${runtime.activeTools.size} 个工具运行中`,
-                    },
-                };
-            }
-            return runtime.stepHadFailure
-                ? { input: { phase: 'failed', line: '工具执行失败' } }
-                : { input: { phase: 'thinking', line: '处理工具结果' } };
-        }
-        case 'turn/end': {
-            runtime.activeTools.clear();
-            switch (event.data.reason.kind) {
-                case 'completed':
-                    return {
-                        input: { phase: 'done', line: '完成啦' },
-                        completedTurn: event.data.turn,
-                    };
-                case 'error':
-                    return { input: { phase: 'failed', line: '执行失败' } };
-                case 'max-tokens':
-                    return { input: { phase: 'failed', line: '达到输出上限' } };
-                case 'interrupted':
-                    return { input: { phase: 'failed', line: '执行意外中断' } };
-                case 'blocked':
-                    return { input: { phase: 'waiting', line: '等待继续' } };
-                case 'aborted':
-                    return { input: { phase: 'idle', line: '已停止' } };
-                default:
-                    // TurnEndReasonMap is merge-extensible; a newer ending must not
-                    // leave the pet showing stale in-progress work.
-                    return { input: { phase: 'idle' } };
-            }
-        }
-        default:
-            return undefined;
-    }
-}
 /**
  * Cordis service exposing the pet RPC domain. Lazy: nothing is scanned or
- * written until a query or interaction arrives; event listeners update only
- * in-memory state, and persistence happens on interaction/config changes
- * plus every completed turn.
+ * written until an economic event or interaction arrives; event listeners
+ * update only in-memory state, and persistence happens on economic changes
+ * (turn rewards, feeds, config/name changes) — never on a read.
  */
 export class PetService extends Service {
     static inject = [];
     machine;
-    affinityConfig;
-    treatConfig;
+    ledger;
     persistDir;
-    persist;
-    /** Completed turns already rewarded, per session (turn numbers are per-session). */
-    rewardedTurns = new Map();
     enabled;
     disposeActivity;
     /** Session whose most recent meaningful event currently drives the global pet. */
     displaySession;
     sessionActivity = new WeakMap();
-    lastLegacyTurnRewardAt = 0;
     constructor(ctx, config = {}) {
         super(ctx, 'pet');
         this.persistDir = config.persistDir ?? petHomeDir();
-        this.affinityConfig = { ...defaultAffinityConfig, ...(config.affinity ?? {}) };
-        this.treatConfig = { ...defaultTreatConfig, ...(config.treats ?? {}) };
+        const ledgerConfig = { affinity: config.affinity, treats: config.treats };
+        this.ledger = new PetLedger(loadPetPersist(this.persistDir), ledgerConfig);
         this.machine = new PetStateMachine({
             ...defaultPetStateConfig,
             ...(config.state ?? {}),
         });
-        this.persist = loadPetPersist(this.persistDir);
         this.enabled = config.enabled ?? true;
         this.syncActivity();
     }
@@ -144,11 +52,11 @@ export class PetService extends Service {
     }
     /** Current persisted display config (read-only view). */
     display() {
-        return { ...this.persist.display };
+        return { ...this.ledger.snapshot.display };
     }
     /** Current persisted pet name (read-only view). */
     petName() {
-        return this.persist.name;
+        return this.ledger.snapshot.name;
     }
     /** Start or stop the session-activity listeners that drive the pet. */
     setEnabled(enabled) {
@@ -210,11 +118,7 @@ export class PetService extends Service {
     activityRuntime(session) {
         let runtime = this.sessionActivity.get(session);
         if (runtime === undefined) {
-            runtime = {
-                activeTools: new Set(),
-                officialEventsSeen: false,
-                stepHadFailure: false,
-            };
+            runtime = emptyProjectionRuntime();
             this.sessionActivity.set(session, runtime);
         }
         return runtime;
@@ -228,52 +132,28 @@ export class PetService extends Service {
     /** RPC: pet or feed the pet. */
     async interact(kind) {
         const nowMs = Date.now();
-        // Feeding consumes a treat: settle the economy first (work + time
-        // output since the last settlement), then gate on the feed cooldown
-        // BEFORE spending stock — a feed inside the cooldown must not burn a
-        // treat for nothing.
-        if (kind === 'feed')
-            this.settleTreats(nowMs);
-        const outcome = applyInteraction(this.persist.affinity, kind, nowMs, this.affinityConfig);
-        if (kind === 'feed' && !outcome.accepted) {
-            return { reaction: outcome.reaction, delta: 0, affinity: this.affinityView(this.persist.affinity) };
-        }
-        if (kind === 'feed') {
-            const consume = consumeTreat(this.persist.treats);
-            if (!consume.ok) {
-                const affinity = this.affinityView(this.persist.affinity);
-                return {
-                    reaction: '没有小鱼干了，多陪鲸鱼娘工作一会儿吧～',
-                    delta: 0,
-                    affinity,
-                };
-            }
-            this.persist = { ...this.persist, treats: consume.ledger };
-        }
-        if (outcome.accepted) {
-            this.persist = { ...this.persist, affinity: outcome.affinity };
+        const result = this.ledger.interact(kind, nowMs);
+        if (this.ledger.takeDirty())
             this.flush();
-        }
-        const affinity = this.affinityView(outcome.affinity);
-        return { reaction: outcome.reaction, delta: outcome.delta, affinity };
+        return result;
     }
     /** RPC: show or hide the pet. */
     async setVisible(visible) {
-        this.persist = { ...this.persist, display: { ...this.persist.display, visible } };
+        this.ledger.setDisplay({ ...this.ledger.snapshot.display, visible });
         this.flush();
         this.syncSettingsFromPet();
-        return { ok: true, display: this.persist.display };
+        return { ok: true, display: this.ledger.snapshot.display };
     }
     /** RPC: update display config (size / position). Values are clamped to whole pixels. */
     async setConfig(patch) {
-        const next = { ...this.persist.display, ...patch };
+        const next = { ...this.ledger.snapshot.display, ...patch };
         next.size = Math.round(Math.min(DISPLAY_SIZE_MAX, Math.max(DISPLAY_SIZE_MIN, next.size)));
         next.right = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, next.right)));
         next.bottom = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, next.bottom)));
-        this.persist = { ...this.persist, display: next };
+        this.ledger.setDisplay(next);
         this.flush();
         this.syncSettingsFromPet();
-        return { ok: true, display: this.persist.display };
+        return { ok: true, display: this.ledger.snapshot.display };
     }
     /** RPC: rename the pet (trimmed, 1–20 chars). */
     async setName(name) {
@@ -282,7 +162,7 @@ export class PetService extends Service {
             return { ok: false, error: 'name-empty' };
         if (trimmed.length > PET_NAME_MAX_LENGTH)
             return { ok: false, error: 'name-too-long' };
-        this.persist = { ...this.persist, name: trimmed };
+        this.ledger.setName(trimmed);
         this.flush();
         this.syncSettingsFromPet();
         return { ok: true, name: trimmed };
@@ -294,12 +174,13 @@ export class PetService extends Service {
      * @param section - the resolved settings section.
      */
     applySettingsSection(section) {
-        const next = { ...this.persist.display };
+        const next = { ...this.ledger.snapshot.display };
         next.visible = section.visible && (section.enabled ?? true);
         next.size = Math.round(Math.min(DISPLAY_SIZE_MAX, Math.max(DISPLAY_SIZE_MIN, section.size)));
         next.right = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, section.right)));
         next.bottom = Math.round(Math.min(DISPLAY_INSET_MAX, Math.max(0, section.bottom)));
-        this.persist = { ...this.persist, display: next, name: section.name.trim() };
+        this.ledger.setDisplay(next);
+        this.ledger.setName(section.name.trim());
         this.flush();
     }
     /** Mirror the persisted display config into the settings document (best-effort). */
@@ -307,86 +188,48 @@ export class PetService extends Service {
         const settings = this.ctx.get('settings', false);
         if (settings === undefined)
             return;
+        const snapshot = this.ledger.snapshot;
         void settings.update(PET_SETTINGS_NAMESPACE, {
-            visible: this.persist.display.visible,
-            size: this.persist.display.size,
-            right: this.persist.display.right,
-            bottom: this.persist.display.bottom,
-            name: this.persist.name,
+            visible: snapshot.display.visible,
+            size: snapshot.display.size,
+            right: snapshot.display.right,
+            bottom: snapshot.display.bottom,
+            name: snapshot.name,
         }).catch(() => {
             // A settings write failure must not break the pet's own persistence.
         });
     }
     /** Award the turn reward once per completed turn (idempotent per session + turn). */
     rewardTurn(sessionId, turn) {
-        const last = this.rewardedTurns.get(sessionId) ?? 0;
-        if (turn <= last)
-            return;
-        this.rewardedTurns.set(sessionId, turn);
-        this.applyTurnReward();
+        if (this.ledger.rewardTurn(sessionId, turn, Date.now()))
+            this.flush();
     }
     /** Preserve turn rewards for installations that only emit legacy activity. */
     rewardLegacyTurn() {
-        const nowMs = Date.now();
-        // A legacy `done` snapshot may repeat during the celebration window.
-        if (nowMs - this.lastLegacyTurnRewardAt < 5_000)
-            return;
-        this.lastLegacyTurnRewardAt = nowMs;
-        this.applyTurnReward();
-    }
-    /** Persist one accepted completed-turn reward. */
-    applyTurnReward() {
-        this.persist = { ...this.persist, affinity: applyTurnReward(this.persist.affinity, this.affinityConfig) };
-        this.flush();
-    }
-    /**
-     * Settle the treat economy (work + time output since the last settlement)
-     * and persist whenever the ledger changed. A zero-gain first settlement
-     * still starts the time clock (anchor write), which is what lets the
-     * 30-minute time output ever accrue.
-     */
-    settleTreats(nowMs) {
-        const settlement = settleTreatGrants(this.persist.treats, this.persist.affinity.turns, nowMs, this.treatConfig);
-        if (settlement.ledger !== this.persist.treats) {
-            this.persist = { ...this.persist, treats: settlement.ledger };
+        if (this.ledger.rewardLegacyTurn(Date.now()))
             this.flush();
-        }
     }
     view() {
         const snapshot = this.machine.render();
-        // Time-output treats accrue while the host is idle too; settle on read.
-        this.settleTreats(Date.now());
+        // Read-only: the ledger settles on economic events only, never on a read,
+        // so polling the state cannot trigger pet.json writes.
         return {
             animation: snapshot.animation,
             ...(snapshot.bubble === undefined ? {} : { bubble: snapshot.bubble }),
             phase: snapshot.phase,
             sessionActive: snapshot.sessionActive,
-            affinity: this.affinityView(this.persist.affinity),
-            display: { ...this.persist.display },
-            name: this.persist.name,
+            affinity: this.ledger.affinityView(Date.now()),
+            display: { ...this.ledger.snapshot.display },
+            name: this.ledger.snapshot.name,
             treats: {
-                stocked: this.persist.treats.treats,
-                max: this.treatConfig.maxTreats,
+                stocked: this.ledger.snapshot.treats.treats,
+                max: this.ledger.treatMax,
             },
         };
     }
-    affinityView(affinity) {
-        const nowMs = Date.now();
-        const rank = rankOf(affinity.points);
-        return {
-            points: affinity.points,
-            rank: rank.name,
-            rankEmoji: rank.emoji,
-            pets: affinity.pets,
-            feeds: affinity.feeds,
-            turns: affinity.turns,
-            petCooldown: nowMs - affinity.lastPetAt < this.affinityConfig.petCooldownMs,
-            feedCooldown: nowMs - affinity.lastFeedAt < this.affinityConfig.feedCooldownMs,
-        };
-    }
     flush() {
         try {
-            savePetPersist(this.persist, this.persistDir);
+            savePetPersist(this.ledger.snapshot, this.persistDir);
         }
         catch {
             // Persistence is best-effort; the in-memory ledger keeps working.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@linxin666/dsh-pet",
   "description": "鲸鱼娘宠物插件 for the dsh web GUI: a soft healing whale-girl companion that reacts to model activity (idle/waiting/thinking/tool/done), with petting/feeding interactions and an affinity score",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "type": "module",
   "engines": {
     "node": "^22.19.0 || >=24.0.0"

package/src/affinity.ts

@@ -84,6 +84,39 @@ export function rankOf(points: number): (typeof AFFINITY_RANKS)[number] {
   return rank
 }
 
+/** Read-only affinity snapshot suited for the RPC view shape. */
+export interface PetAffinityView {
+  points: number
+  rank: string
+  rankEmoji: string
+  pets: number
+  feeds: number
+  turns: number
+  /** True while the pet interaction is inside its cooldown. */
+  petCooldown: boolean
+  /** True while the feed is inside its cooldown. */
+  feedCooldown: boolean
+}
+
+/** Derive the read-only view of one affinity state at a wall-clock instant. */
+export function affinityViewOf(
+  state: AffinityState,
+  nowMs: number,
+  config: AffinityConfig = defaultAffinityConfig,
+): PetAffinityView {
+  const rank = rankOf(state.points)
+  return {
+    points: state.points,
+    rank: rank.name,
+    rankEmoji: rank.emoji,
+    pets: state.pets,
+    feeds: state.feeds,
+    turns: state.turns,
+    petCooldown: nowMs - state.lastPetAt < config.petCooldownMs,
+    feedCooldown: nowMs - state.lastFeedAt < config.feedCooldownMs,
+  }
+}
+
 function clamp(points: number): number {
   return Math.min(AFFINITY_MAX, Math.max(0, points))
 }

package/src/client/PluginSettingsCard.tsx

@@ -1,25 +1,44 @@
+// Generated by scripts/sync-shared.mjs from shared/client/settings/PluginSettingsCard.tsx. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
 /**
- * Shared chrome for the plugin settings card: a disclosure header naming the
- * plugin and what its settings govern, the controls inside, and the save that
- * writes them. Renders nothing while the namespace is unavailable — a
+ * Family-shared chrome for plugin settings cards: a disclosure header naming
+ * the plugin and what its settings govern, the controls inside, and the save
+ * that writes them. Renders nothing while the namespace is unavailable — a
  * deployment that does not compose the owning plugin should show no trace of
- * it. Mirrors the official ui-plugin-config PluginCard in a self-contained
- * slice (this package must not depend on a sibling UI package).
+ * it. Inlined into each consumer's client bundle; mirrors the official
+ * ui-plugin-config PluginCard in a self-contained slice.
  */
 
 import { useState, type ReactNode } from 'react'
 import type { CardShell } from './settings-form.ts'
-import type { SettingsCardKey } from './locales.ts'
 import css from './settings-card.module.css'
 
+/** Copy keys the card chrome itself reads; every consumer locale carries this shared vocabulary. */
+export const CARD_COPY_KEYS = [
+  'settings.collapse',
+  'settings.expand',
+  'settings.notExposed',
+  'settings.unsaved',
+  'settings.readOnly',
+  'settings.saveFailed',
+  'settings.discard',
+  'settings.save',
+  'settings.saving',
+] as const
+
+/** Copy key the card chrome itself reads. */
+export type CardCopyKey = (typeof CARD_COPY_KEYS)[number]
+
+/** Key domain for the plugin's own copy (inferred per consumer). */
+export type SettingsCardKey<TKey extends string = string> = TKey | CardCopyKey
+
 /** Card chrome shared by every plugin settings card. */
-export interface PluginSettingsCardProps {
+export interface PluginSettingsCardProps<TKey extends string = string> {
   /** Locale reader for this card's copy. */
-  t: (key: SettingsCardKey) => string
+  t: (key: SettingsCardKey<TKey>, params?: Record<string, string | number>) => string
   /** Locale key of the plugin's name. */
-  titleKey: SettingsCardKey
+  titleKey: TKey
   /** Locale key of the line describing what this plugin's settings govern. */
-  descriptionKey: SettingsCardKey
+  descriptionKey: TKey
   /** The card's form state: availability, writability, and what a save would do. */
   state: CardShell
   /** Write every staged edit. */
@@ -35,11 +54,12 @@ export interface PluginSettingsCardProps {
  * @param props - the plugin's copy keys, its form state, and its controls.
  * @returns the card, or nothing while the namespace is still loading.
  */
-export function PluginSettingsCard(props: PluginSettingsCardProps) {
+export function PluginSettingsCard<TKey extends string = string>(props: PluginSettingsCardProps<TKey>) {
   const [open, setOpen] = useState(false)
   const { state } = props
   if (!state.available) return null
   const title = props.t(props.titleKey)
+  const description = props.t(props.descriptionKey)
   const blocked = !state.dirty || state.invalid || state.saving
   const cardClass = open ? `${css.cardOpen} ${css.card}` : css.card
   // The namespace exists but the Host does not serve it to this client (the
@@ -57,8 +77,8 @@ export function PluginSettingsCard(props: PluginSettingsCardProps) {
           onClick={() => { setOpen(!open) }}
         >
           <span className={css.headText}>
-            <span className={css.name}>{title}</span>
-            <span className={css.description}>{props.t(props.descriptionKey)}</span>
+            <span className={css.name} title={title}>{title}</span>
+            <span className={css.description} title={description}>{description}</span>
           </span>
           <svg
             width="14"
@@ -94,10 +114,10 @@ export function PluginSettingsCard(props: PluginSettingsCardProps) {
         onClick={() => { setOpen(!open) }}
       >
         <span className={css.headText}>
-          <span className={css.name}>{title}</span>
-          <span className={css.description}>{props.t(props.descriptionKey)}</span>
+          <span className={css.name} title={title}>{title}</span>
+          <span className={css.description} title={description}>{description}</span>
         </span>
-        {state.dirty ? <span className={css.pending}>{props.t('settings.unsaved')}</span> : null}
+        {state.dirty ? <span className={css.pending} title={props.t('settings.unsaved')}>{props.t('settings.unsaved')}</span> : null}
         <svg
           width="14"
           height="14"
@@ -259,4 +279,50 @@ export function BooleanField(props: FieldProps & {
       <p className={css.hint}>{props.hint}</p>
     </div>
   )
-}
+}
+
+/** A staged enumerated field rendered as a select. */
+export function ChoiceField(props: FieldProps & {
+  /** Copy for the inherit option (draft text is the empty string). */
+  inheritLabel: string
+  /** Choices rendered in order; `value` is the draft/stored text. */
+  choices: ReadonlyArray<{ value: string; label: string }>
+}) {
+  return (
+    <div className={css.field}>
+      <div className={css.head}>
+        <label className={css.label} htmlFor={props.id}>{props.label}</label>
+        {props.overridden
+          ? (
+            <span className={css.badges}>
+              <span className={css.badge}>{props.overriddenLabel}</span>
+              <button
+                type="button"
+                className={css.reset}
+                disabled={props.disabled}
+                onClick={props.onReset}
+              >
+                {props.resetLabel}
+              </button>
+            </span>
+          )
+          : null}
+      </div>
+      <select
+        id={props.id}
+        className={css.select}
+        value={props.text}
+        disabled={props.disabled}
+        onChange={(event) => { props.onEdit(event.target.value) }}
+      >
+        <option value="">{props.inheritLabel}</option>
+        {props.choices.map(choice => (
+          <option key={choice.value} value={choice.value}>{choice.label}</option>
+        ))}
+      </select>
+      <p className={props.invalid ? css.invalid : css.hint}>
+        {props.invalid ? props.invalidLabel : props.hint}
+      </p>
+    </div>
+  )
+}

package/src/client/index.ts

@@ -1,7 +1,7 @@
 /**
  * dsh-pet browser half — mounts the whale-girl as a global floating surface
  * and drives it from the host's same-origin `/api/pet/*` JSON endpoints: poll
- * the host snapshot (~800 ms), forward interactions, persist drag positions.
+ * the host snapshot (~2 s), forward interactions, persist drag positions.
  * The pet is host-global (no session dimension), so it mounts directly onto
  * `document.body` via a single React root rather than a session-scoped slot —
  * on the new-conversation screen no session exists, and a dock-mounted pet
@@ -61,7 +61,7 @@ const petApi: PetHttpApi = {
 }
 
 /** Poll interval for the host snapshot. */
-const POLL_MS = 800
+const POLL_MS = 2000
 
 /** Settings namespace the pet settings card edits (the Host plugin registers it). */
 const PET_SETTINGS_NS = 'pet'
@@ -161,7 +161,7 @@ export function apply(ctx: ClientContext): void {
         // change while the page is hidden, so a background interval would
         // only burn RPCs (browser throttling is an unreliable backstop).
         // Coming back to the tab refreshes the pet immediately instead of
-        // waiting out the next 800 ms cycle.
+        // waiting out the next 2 s cycle.
         let timer: number | undefined
         const stop = (): void => {
           if (timer !== undefined) {

package/src/client/settings-card.module.css

@@ -1,3 +1,4 @@
+/* Generated by scripts/sync-shared.mjs from shared/client/settings/settings-card.module.css. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs". */
 /* Plugin settings card chrome + staged form fields.
  * Aligned with the official ui-settings-plugins PluginCard / fields CSS:
  * same semantic tokens, radius, typography and states so family cards read
@@ -229,6 +230,11 @@
   outline-offset: 2px;
 }
 
+.reset:focus-visible {
+  outline: 2px solid var(--dsw-alias-brand-primary);
+  outline-offset: 2px;
+}
+
 .input,
 .select {
   border: 1px solid var(--dsw-alias-border-l2);