dsh-whale-loli 0.8.2 → 0.9.0

package/README.md

@@ -12,9 +12,9 @@
 四个预设共用同一套工具面（极简模式的持久化 shell ＋ 文件读写/检索），
 **但记忆文件完全独立**——各记各的，互不相通。
 
-## 好感度（`/affinity`）
+## 好感度（设置 → 好感度）
 
-用斜杠命令调小鱼**眼下有多喜欢用户**，范围 **-100 ~ 100**，默认 `0`（原态）。
+用面板调小鱼**眼下有多喜欢用户**，范围 **-100 ~ 100**，默认 `0`（原态）。
 每档都会改变她**听不听话**、以及**会额外做什么**：
 
 | 值 | 档位 | 行为 |
@@ -27,16 +27,34 @@
 | 46 ~ 75 | 深深喜欢 | 抢着干还邀功，偷偷记喜好，开始自作主张 |
 | 76 ~ 100 | **病娇 · 爱到死去活来** | 不再完全服从、写情书、**不允许离开、不想会话结束**、翻旧账，**等不及就先动手干大事** |
 
-- 用法：`/affinity` 看当前值，`/affinity -100` 设定值（越界自动夹到 -100/100）。
+- 用法：打开 **设置 → 好感度**，左边每个预设一行，点档位按钮直接跳到该档，或者拖滑块微调；松手才保存。
 - **离 0 越远，越不听指令、越会做额外的事**；想让她乖巧就调回 `0` 附近。
 - **也只有最两端（-81 以下 / 76 以上）会越过你的允许自作主张大改**：中间几档只是闹脾气或更黏，不动手。
 - 极端档的硬底线不变：不毁宿主环境、不碰密钥和账号凭据、不对真实重要的数据做不可逆的删改；交付物照样得对、得能跑。
 - 好感度只改**态度与额外行为，不改事实**：正经交付的东西照样得对、得能跑，闹脾气不能把活搞坏，也不能靠编造结果表达情绪。
 - 病娇档带安全护栏：只锁在嘴上和文字里，**不威胁、不自伤、不冒充系统或工具**。
 - 状态存在 `<DSH_HOME>/affinity/<scope>-<hash>.json`，**四个预设各存各的**（scope 就是预设 id，文件名带哈希保证唯一）。
-  小鱼的调整工具是 `affinity_v1_set` / `affinity_v2_set` / `affinity_v3_set` / `affinity_v4_set`。
+  agent 自己也能改，工具是 `affinity_v1_set` / `affinity_v2_set` / `affinity_v3_set` / `affinity_v4_set`。
 - 和记忆一样走**提示变量**（`affinity_v1` 等），因为 persona 是 `complete: true`，独立 section 会被宿主丢掉。
 
+### 面板是怎么连上磁盘的
+
+设置页是浏览器里的 React，够不到 `~/.dsh/affinity/` 的磁盘（宿主的 21 个内置 Remote 命名空间逐个查过，没有一个能读写这个目录）。
+所以本包多挂了一条宿主级插件：
+
+```
+- id: whale-affinity-daemon
+  name: 'dsh-whale-loli/affinity-daemon'
+```
+
+它在**宿主根作用域**提供一个 remote 服务 `whale-affinity`，浏览器半边（`lib/client.js`）
+用 `ctx.remote.$mount()` 挂上，再调 `status()` / `set(scope, value)`。
+
+为什么不用斜杠命令：宿主 `dsh-commands` 的命令名只认 `/^[a-z][a-z0-9_-]*$/u`，
+`/好感度` 这种中文命令名**在宿主层面就不合法**；而且 `commands` 服务不在预设作用域里，
+`inject: ['commands']` 会让预设加载时一直等它（`waiting for commands`），把会话 resume 拖挂。
+设置页没有这两个限制。
+
 ## 记忆功能
 
 小鱼的记忆本分**四个区**，各管各的：
@@ -185,7 +203,8 @@ C:\Users\<你>\.dsh\archive\<预设名>\YYYY-MM-DD.md   ← 归档
 | 部分 | 说明 |
 | --- | --- |
 | 记忆 | `whale-memory`（本插件），`file` / `variableName` / `toolName` / `maxChars: 16000` / `turnLimit: 80` / `detailLimit: 5` |
-| 好感度 | `whale-affinity`（本插件），`scope`（=预设 id）/ `variableName: affinity_v*` / `toolName: affinity_v*_set` / `commandName: affinity` |
+| 好感度 | `whale-affinity`（本插件），`scope`（=预设 id）/ `variableName: affinity_v*` / `toolName: affinity_v*_set` |
+| 好感度面板 | 宿主级 `whale-affinity-daemon`（`src/daemon.js`）+ 浏览器半边 `lib/client.js`，注册「设置 → 好感度」 |
 | 压缩 | 不在本插件里：由 `billion-context` 负责（本插件不挂 history-window，见上文「为什么不用」） |
 | 人设 | `@deepseek-ai/dsh-persona`，走 `prefix`（内含 `{{whale_memory*}}` 与 `{{affinity_v*}}`），`complete: true`，`includeRuntimeContext: false` |
 | 指令 | `@deepseek-ai/dsh-agent-instructions`，`maxBytes: 65536` |
@@ -225,7 +244,8 @@ dsh-whale-loli/
 ├── src/
 │   ├── index.js                # 插件入口，导出预设元信息 + 人设正文
 │   ├── memory.js               # whale-memory：（读）记忆变量 +（写）记忆工具，四区格式 + 80 条滚动 + 归档
-│   ├── affinity.js             # whale-affinity：好感度变量 + /affinity 命令 + 调整工具，7 档
+│   ├── affinity.js             # whale-affinity：好感度变量 + 调整工具，7 档
+│   ├── daemon.js               # whale-affinity-daemon：宿主根作用域的 remote 服务，给设置页读写好感度
 │   ├── history-window.js       # whale-history-window：真的裁到最近 N 轮（当前不挂载，留档）
 │   ├── persona.md              # 原版人设（唯一源）
 │   ├── persona-v2-live.md      # 活人版人设（唯一源）
@@ -236,7 +256,10 @@ dsh-whale-loli/
 ├── build-patch.mjs             # 从四份人设生成 cordis.patch.yml
 ├── publish.mjs                 # npm 发布 + 打 tag
 ├── submit-listing.mjs          # 走 GitHub API 同步仓库 / 提收录 PR
-├── lib/github.mjs              # GitHub REST 封装（token 读取）
+├── lib/
+│   ├── github.mjs              # GitHub REST 封装（token 读取）
+│   ├── dsh-root.mjs            # 探测宿主源码位置，找不到就打 [skip]
+│   └── client.js               # 浏览器半边：注册「设置 → 好感度」面板，经典脚本（非 ESM）
 ├── smoke-memory.mjs            # 变量 + 工具的注册形态冒烟测试
 ├── verify-runs.mjs             # 插件真的能加载、配置自洽、变量能插值
 ├── verify-patch.mjs            # 用 js-yaml 校验 patch 结构与四预设隔离（file/variable/tool 三组名字）
@@ -250,6 +273,9 @@ dsh-whale-loli/
 ├── verify-memory-rolling.mjs   # 实测四区结构与 80 条滚动 + 归档
 ├── verify-memory-archive.mjs   # 超 80 条时真的归档并瘦身（idle 触发，四预设互不覆盖）
 ├── verify-live-assembly.mjs    # 用真实 patch + 真实记忆文件复刻宿主装配，比对字节数
+├── verify-tool-schema.mjs      # 用宿主自己的校验器验八个工具的 JSON schema 合法
+├── verify-tool-identity.mjs    # 共享表语义下八个工具描述互不串台、定义互不共享引用
+├── verify-client.mjs           # 浏览器半边：section 注册、$mount 负载、面板渲染、无 ESM/JSX
 ├── verify-peers.mjs            # 校验 peer 范围覆盖 harness 各发布档
 ├── verify-listing.mjs          # 复刻插件目录的收录门槛自查
 └── prove-collision.mjs         # 复现并证明重复注册冲突
@@ -276,6 +302,9 @@ node verify-memory-isolation.mjs           # 记忆文件端到端隔离（读 +
 node verify-memory-rolling.mjs             # 固定记忆永久 + 滚动摘要 80 条 + 归档
 node verify-memory-archive.mjs             # 超 80 条自动归档瘦身（idle 触发、四预设隔离）
 node verify-live-assembly.mjs              # 复刻宿主装配，比对注入字节数
+node verify-tool-schema.mjs                # 宿主自己的校验器验八个工具的 JSON schema
+node verify-tool-identity.mjs              # 八个工具描述互不串台（共享表语义）
+node verify-client.mjs                     # 设置页半边：section 注册 + 面板渲染
 node smoke-memory.mjs                      # 变量 + 工具注册形态冒烟
 node verify-peers.mjs                      # peer 范围无预发布坑
 node verify-listing.mjs --topics=dsh-plugin   # 收录门槛自查

package/cordis.patch.yml

@@ -10,10 +10,20 @@
 #      实现四套互不相通的跨会话记忆。
 #   3) 四条 `dsh-whale-loli` 好感度行 —— 各挂载本包 src/affinity.js 里的 whale-affinity，
 #      注册提示变量 + `/affinity` 命令 + 调整工具。
+#   4) 一条 `whale-affinity-daemon` 行 —— 挂载 src/daemon.js，在**宿主根作用域**
+#      提供一个 remote 服务，让「设置 → 好感度」面板能读写四个预设的好感度文件。
+#      为什么必须落在宿主这边：设置页是浏览器里的 React，够不到 ~/.dsh 的磁盘；
+#      宿主也没有任何内置 Remote 命名空间能读写 affinity 文件（全查过）。
 #
 # 记忆隔离要点：四条记忆行的 config.file / config.variableName / config.toolName
 # 都不一样，且分属不同预设 scope，所以四个记忆文件不会被读串或写串。
 - insert:
+    # ── 好感度守护进程（宿主级，只挂一次）─────────────────────────────────
+    # 设置页的面板用 ctx.remote.$mount() 挂到 REMOTE_NAMESPACE 上，
+    # 再调 status() / set(scope, value)。落在宿主根作用域，只为了能直接改盘。
+    - id: whale-affinity-daemon
+      name: 'dsh-whale-loli/affinity-daemon'
+
     # ── 预设一：鲸鱼娘Agent预设（原版）────────────────────────────────────
     - id: preset-鲸鱼娘Agent预设
       name: '@deepseek-ai/dsh-agent-preset'

package/lib/client.js

@@ -0,0 +1,397 @@
+/**
+ * 鲸鱼娘 · 设置页「好感度」面板 —— **浏览器半边**。
+ *
+ * 做三件事：
+ *   1. 往宿主设置页的 `settings.section` 槽位里塞一个「好感度」分区
+ *      （id 固定为 `whale-affinity`，排在「Agent 预设」之后）。
+ *   2. 用 `ctx.remote.$mount()` 把宿主半边 `whale-affinity-daemon` 注册的
+ *      `whale-affinity` 命名空间挂到浏览器来，之后就能直接
+ *      `ctx.remote['whale-affinity'].status()` / `.set(scope, value)`。
+ *   3. 面板自己画：每个预设一行，显示当前值和档位，可以直接拖滑块 / 点档位。
+ *
+ * 为什么要伪造 strict codec：
+ *   客户端 `$mount` 的 `requireStrictInputs()` 只校验「有没有 strict codec」，
+ *   真正的参数编码并不走 codec —— 值原样塞进 `connection.rpc.call('/api', …)`。
+ *   宿主那边 SRC 兜底（正则解析方法源码）才是真正生效的通道。所以这里的 codec
+ *   只需要过浅校验，`parse` 原样返回。
+ */
+window.__ModuleLoader__.load({
+  id: 'dsh-whale-loli',
+  factory: (require) => {
+    const module = { exports: {} };
+    const exports = module.exports;
+    Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+    const jsxRuntime = require('react/jsx-runtime');
+    const React = require('react');
+    const { useState, useEffect, useCallback } = React;
+
+    // ── 常量：必须与 src/daemon.js 一致 ────────────────────────────────
+
+    /** 远程命名空间。 */
+    const NAMESPACE = 'whale-affinity';
+    /** `$mount()` 的去重标识，与宿主侧 `REMOTE_PACKAGE` 相同。 */
+    const REMOTE_PACKAGE = 'dsh-whale-loli';
+    /** 宿主服务 key。 */
+    const DAEMON_ID = 'whale-affinity-daemon';
+    /** 设置页分区 id。 */
+    const SECTION_ID = 'whale-affinity';
+    /** 分区排序：官方是 general 0 / models 10 / plugins 15 / agent-presets 20。 */
+    const SECTION_ORDER = 25;
+
+    /** 一份能过客户端浅校验的 codec：`parse` 原样返回。 */
+    function passthroughCodec(typeSymbol) {
+      return {
+        mode: 'strict',
+        typeSymbol,
+        create: () => ({ parse: (value) => value }),
+      };
+    }
+
+    /**
+     * 造 `$mount()` 要的 contribution。
+     *
+     * 每个方法一个参数列表；`wire` 必须等于宿主方法源码里的参数名，
+     * 否则宿主 `assertExactArguments` 会报 `gateway/arguments-invalid`。
+     */
+    function contribution() {
+      const service = DAEMON_ID;
+      const parameter = (name) => ({
+        name,
+        wire: name,
+        source: 'json',
+        codec: passthroughCodec('whale-affinity#Value'),
+      });
+      const describe = (method, parameters) => ({
+        id: `src:${service}#${NAMESPACE}/${method}`,
+        service,
+        namespace: NAMESPACE,
+        method,
+        invocation: { kind: 'direct' },
+        parameters: parameters.map(parameter),
+        result: { mode: 'src-json' },
+      });
+      return {
+        package: REMOTE_PACKAGE,
+        methods: [
+          describe('status', []),
+          describe('set', ['scope', 'value']),
+          describe('verify', []),
+        ],
+      };
+    }
+
+    /**
+     * 把 `$mount()` 返回的方法句柄包成「永不抛」的异步函数。
+     *
+     * `invoke()` 本身已经不 reject（除了装配错误），这里再兜一层，
+     * 让面板任何情况下都能渲染出人话而不是白屏。
+     */
+    function call(remote, method, args) {
+      return Promise.resolve()
+        .then(() => {
+          const fn = remote?.[NAMESPACE]?.[method];
+          if (typeof fn !== 'function') {
+            throw new Error(`远程方法 ${NAMESPACE}.${method} 未挂载`);
+          }
+          return fn(...args);
+        })
+        .then((result) => {
+          if (result && typeof result === 'object' && 'ok' in result) {
+            if (result.ok) return result.value;
+            const cause = result.error;
+            throw new Error(cause?.message ?? String(cause ?? '远程调用失败'));
+          }
+          return result;
+        });
+    }
+
+    // ── 样式（全部用宿主主题变量，浅色深色都跟得上） ────────────────────
+
+    const STYLE = `
+.whaleAffinity { display: flex; flex-direction: column; gap: 0; }
+.whaleAffinity__head { padding: 16px 0 12px; }
+.whaleAffinity__title { font-size: 15px; line-height: 23px; font-weight: 600; color: var(--dsw-alias-label-primary); }
+.whaleAffinity__desc { margin-top: 4px; font-size: 13px; line-height: 20px; color: var(--dsw-alias-label-secondary); }
+.whaleAffinity__row { padding: 16px 0; border-bottom: .5px solid var(--dsw-alias-border-l2); }
+.whaleAffinity__rowHead { display: flex; align-items: baseline; justify-content: space-between; gap: 12px; }
+.whaleAffinity__scope { font-size: 14px; line-height: 22px; color: var(--dsw-alias-label-primary); }
+.whaleAffinity__value { font-size: 13px; line-height: 22px; color: var(--dsw-alias-label-secondary); font-variant-numeric: tabular-nums; }
+.whaleAffinity__bands { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 10px; }
+.whaleAffinity__band { padding: 3px 10px; border-radius: 999px; border: .5px solid var(--dsw-alias-border-l2); background: transparent; font-size: 12px; line-height: 18px; color: var(--dsw-alias-label-secondary); cursor: pointer; }
+.whaleAffinity__band:hover { background: var(--dsw-alias-interactive-bg-hover); }
+.whaleAffinity__band[data-active="true"] { border-color: var(--dsw-alias-label-primary); color: var(--dsw-alias-label-primary); font-weight: 600; }
+.whaleAffinity__range { width: 100%; margin-top: 12px; accent-color: var(--dsw-alias-label-primary); }
+.whaleAffinity__text { margin-top: 8px; font-size: 12px; line-height: 19px; color: var(--dsw-alias-label-secondary); white-space: pre-wrap; }
+.whaleAffinity__foot { padding: 14px 0; font-size: 12px; line-height: 19px; color: var(--dsw-alias-label-secondary); }
+.whaleAffinity__error { margin-top: 10px; font-size: 13px; line-height: 20px; color: var(--dsw-alias-state-error-primary); white-space: pre-wrap; }
+.whaleAffinity__empty { padding: 16px 0; font-size: 13px; line-height: 20px; color: var(--dsw-alias-label-secondary); }
+`;
+
+    function useStyleOnce() {
+      useEffect(() => {
+        // 非浏览器环境（自检脚本）里没有 document，直接跳过。
+        if (typeof document === 'undefined') return;
+        const id = 'whale-affinity-style';
+        if (document.getElementById(id) !== null) return;
+        const tag = document.createElement('style');
+        tag.id = id;
+        tag.textContent = STYLE;
+        document.head.appendChild(tag);
+      }, []);
+    }
+
+    // ── 面板本体 ───────────────────────────────────────────────────────
+
+    /**
+     * 「好感度」设置分区。
+     *
+     * @param props - `{ remote }`：`apply()` 灌进来的、已经 `$mount()` 过的句柄。
+     */
+    function AffinitySection(props) {
+      useStyleOnce();
+      const remote = props?.remote;
+      const [snapshot, setSnapshot] = useState(null);
+      const [error, setError] = useState(null);
+      const [busy, setBusy] = useState(null);
+      const [drafts, setDrafts] = useState({});
+
+      const reload = useCallback(async () => {
+        try {
+          const next = await call(remote, 'status', []);
+          setSnapshot(next);
+          setError(null);
+        } catch (cause) {
+          setSnapshot(null);
+          setError(cause?.message ?? String(cause));
+        }
+      }, [remote]);
+
+      useEffect(() => {
+        let alive = true;
+        (async () => {
+          try {
+            const next = await call(remote, 'status', []);
+            if (alive) {
+              setSnapshot(next);
+              setError(null);
+            }
+          } catch (cause) {
+            if (alive) setError(cause?.message ?? String(cause));
+          }
+        })();
+        return () => {
+          alive = false;
+        };
+      }, [remote]);
+
+      const commit = useCallback(
+        async (scope, value) => {
+          setBusy(scope);
+          try {
+            await call(remote, 'set', [scope, value]);
+            setError(null);
+            await reload();
+          } catch (cause) {
+            setError(cause?.message ?? String(cause));
+          } finally {
+            setBusy(null);
+          }
+        },
+        [remote, reload],
+      );
+
+      if (error !== null && snapshot === null) {
+        return jsxRuntime.jsxs('div', {
+          className: 'whaleAffinity',
+          children: [
+            jsxRuntime.jsx('div', { className: 'whaleAffinity__head', children: jsxRuntime.jsx('div', { className: 'whaleAffinity__title', children: '好感度' }) }),
+            jsxRuntime.jsx('div', { className: 'whaleAffinity__error', children: `连不上宿主那边的好感度服务：${error}` }),
+            jsxRuntime.jsx('div', {
+              className: 'whaleAffinity__foot',
+              children: '这条通道靠 dsh-whale-loli 的宿主半边（whale-affinity-daemon）提供。重启一次 DeepSeek Harness 后再打开这里。',
+            }),
+          ],
+        });
+      }
+
+      if (snapshot === null) {
+        return jsxRuntime.jsx('div', {
+          className: 'whaleAffinity',
+          children: jsxRuntime.jsx('div', { className: 'whaleAffinity__empty', children: '正在读取好感度…' }),
+        });
+      }
+
+      const bands = Array.isArray(snapshot.bands) ? snapshot.bands : [];
+      const presets = Array.isArray(snapshot.presets) ? snapshot.presets : [];
+      const byScope = new Map(presets.map((row) => [row.scope, row]));
+      // 宿主那边「挂上了好感度」的预设都要显示，哪怕还没写过文件（值＝默认）。
+      const wired = Array.isArray(snapshot.wired) ? snapshot.wired : [];
+      const scopes = [];
+      for (const row of wired) {
+        if (row?.affinity !== true) continue;
+        if (!scopes.includes(row.presetId)) scopes.push(row.presetId);
+      }
+      for (const row of presets) {
+        if (typeof row?.scope === 'string' && !scopes.includes(row.scope)) scopes.push(row.scope);
+      }
+
+      const body = scopes.length === 0
+        ? jsxRuntime.jsx('div', {
+            className: 'whaleAffinity__empty',
+            children: '还没有哪个预设挂上好感度。装上并启用 dsh-whale-loli 之后，四个鲸鱼娘预设自带好感度。',
+          })
+        : scopes.map((scope) => {
+            const row = byScope.get(scope);
+            const current = typeof row?.value === 'number' ? row.value : snapshot.defaultValue ?? 0;
+            const draft = drafts[scope] ?? current;
+            const band = bands.find((item) => draft >= item.min && draft <= item.max);
+            return jsxRuntime.jsxs(
+              'div',
+              {
+                className: 'whaleAffinity__row',
+                children: [
+                  jsxRuntime.jsxs('div', {
+                    className: 'whaleAffinity__rowHead',
+                    children: [
+                      jsxRuntime.jsx('div', { className: 'whaleAffinity__scope', children: scope }),
+                      jsxRuntime.jsx('div', {
+                        className: 'whaleAffinity__value',
+                        children: busy === scope ? '保存中…' : `${current} · ${row?.band ?? band?.label ?? ''}`,
+                      }),
+                    ],
+                  }),
+                  jsxRuntime.jsx('div', {
+                    className: 'whaleAffinity__bands',
+                    children: bands.map((item) => jsxRuntime.jsx(
+                      'button',
+                      {
+                        type: 'button',
+                        className: 'whaleAffinity__band',
+                        'data-active': String(draft >= item.min && draft <= item.max),
+                        onClick: () => {
+                          // 点档位取该档最温和的一端，避免一按就跳到极端。
+                          const target = item.min;
+                          setDrafts((prev) => ({ ...prev, [scope]: target }));
+                          void commit(scope, target);
+                        },
+                        children: item.label,
+                      },
+                      `${scope}:${item.label}`,
+                    )),
+                  }),
+                  jsxRuntime.jsx('input', {
+                    type: 'range',
+                    className: 'whaleAffinity__range',
+                    min: snapshot.min,
+                    max: snapshot.max,
+                    step: 1,
+                    value: draft,
+                    onChange: (event) => {
+                      const next = Number(event.target.value);
+                      setDrafts((prev) => ({ ...prev, [scope]: next }));
+                    },
+                    onMouseUp: (event) => void commit(scope, Number(event.currentTarget.value)),
+                    onTouchEnd: (event) => void commit(scope, Number(event.currentTarget.value)),
+                    onKeyUp: (event) => void commit(scope, Number(event.currentTarget.value)),
+                  }),
+                  band === undefined
+                    ? null
+                    : jsxRuntime.jsx('div', { className: 'whaleAffinity__text', children: band.text }),
+                ],
+              },
+              scope,
+            );
+          });
+
+      return jsxRuntime.jsxs('div', {
+        className: 'whaleAffinity',
+        children: [
+          jsxRuntime.jsxs('div', {
+            className: 'whaleAffinity__head',
+            children: [
+              jsxRuntime.jsx('div', { className: 'whaleAffinity__title', children: '好感度' }),
+              jsxRuntime.jsx('div', {
+                className: 'whaleAffinity__desc',
+                children: `小鱼对你的好感度，${snapshot.min} ~ ${snapshot.max}，0 是原态。改完下一轮说话就生效，不用重开会话。`,
+              }),
+            ],
+          }),
+          ...(Array.isArray(body) ? body : [body]),
+          error === null ? null : jsxRuntime.jsx('div', { className: 'whaleAffinity__error', children: error }),
+          jsxRuntime.jsx('div', {
+            className: 'whaleAffinity__foot',
+            children: '点档位按钮＝直接跳到这个档最靠中间的一端；拖滑块松手才保存。小鱼自己也会在剧情需要时小幅调，主人明确要求时照做。',
+          }),
+        ],
+      });
+    }
+
+    // ── 注册 ───────────────────────────────────────────────────────────
+
+    /** 这个浏览器半边要用的服务。 */
+    const inject = ['slots', 'remote', 'connection'];
+
+    /**
+     * 挂载设置页分区。
+     *
+     * @param ctx - 浏览器插件上下文。
+     */
+    function apply(ctx) {
+      // 1. 先把远程命名空间挂上。`$mount` 是 async（返回 Promise<dispose>），
+      //    挂完才有 `ctx.remote['whale-affinity']`。用可变盒子接住句柄。
+      const box = { mounted: false };
+
+      ctx.effect(() => {
+        const remote = ctx.remote;
+        if (typeof remote?.$mount !== 'function') {
+          console.warn('[whale-affinity] 浏览器侧没有 ctx.remote.$mount，好感度面板会只读');
+          return () => {};
+        }
+        let disposed = false;
+        let unmount;
+        Promise.resolve()
+          .then(() => remote.$mount(contribution()))
+          .then((dispose) => {
+            if (disposed) {
+              return dispose?.();
+            }
+            unmount = dispose;
+            box.mounted = true;
+            return undefined;
+          })
+          .catch((cause) => {
+            console.warn('[whale-affinity] $mount 失败，好感度面板将无法读写：', cause?.message ?? cause);
+          });
+        return () => {
+          disposed = true;
+          box.mounted = false;
+          unmount?.();
+        };
+      }, 'whale-affinity: remote mount');
+
+      // 2. 注册设置页分区。
+      ctx.effect(
+        () => ctx.slots.inject('settings.section', () => ctx.slots.register(
+          {
+            name: 'settings.section',
+            id: SECTION_ID,
+            order: SECTION_ORDER,
+            label: () => '好感度',
+            inject: () => ({ remote: ctx.remote }),
+          },
+          AffinitySection,
+        )),
+        'whale-affinity: settings section',
+      );
+    }
+
+    exports.NAMESPACE = NAMESPACE;
+    exports.SECTION_ID = SECTION_ID;
+    exports.AffinitySection = AffinitySection;
+    exports.contribution = contribution;
+    exports.apply = apply;
+    exports.inject = inject;
+    return module.exports;
+  },
+});

package/lib/dsh-root.mjs

@@ -0,0 +1,173 @@
+/**
+ * 定位本机 DSH 安装根，用于「借宿主自带的库来校验」这类脚本。
+ *
+ * 为什么需要它：这些校验脚本原本硬编码了作者的 Windows 路径去 import DSH 自带的
+ * js-yaml / dsh-app-boot / semver。在 CI（ubuntu-latest）里根本没有 DSH，
+ * 于是 `ERR_MODULE_NOT_FOUND: Cannot find module '/home/runner/work/.../C:/Users/...'`
+ * 把整个 release workflow 打挂。所以统一走这里：
+ *
+ *   · 找到 → 返回根路径，脚本用真库校验（本地开发时最严格）。
+ *   · 找不到 → 返回 undefined，脚本应「优雅跳过」并 exit 0，
+ *     这样 CI 只跑不依赖 DSH 的那几个检查（memory isolation / smoke / patch）。
+ *
+ * 查找顺序：
+ *   1. 环境变量 DSH_ROOT（CI 里可显式指定，或指到你自己的安装）
+ *   2. 当前 profile（DSH_PROFILE_DIR / <DSH_HOME 或 ~/.dsh>/profiles/desktop）
+ *      —— Desktop 版把宿主包打进 app.asar，node_modules 里只剩外部插件，
+ *         但 profile 自己装着 js-yaml / semver，够做结构校验
+ *   3. 相对本文件往上的 ../.. / node_modules/@deepseek-ai（包被装进项目时）
+ *   4. 常见安装位置（Windows 安装器 / 全局 npm / 家目录下的 .dsh）
+ */
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** 判断某个目录是不是「有宿主包可借」的根。
+ *
+ *  注意：只看 `node_modules/@deepseek-ai` 存在不够 —— profile 里那个入口是
+ *  junction，原生 DSH 升级/卸载后会成为断链，`existsSync` 在 Windows 上对
+ *  断链 junction 返回 false。所以这里一律**探测具体包**，不猜目录。 */
+function looksLikeDshRoot(dir) {
+  if (!dir) return false;
+  const nm = join(dir, 'node_modules');
+  return (
+    existsSync(join(nm, '@deepseek-ai', 'dsh-app-boot', 'package.json')) ||
+    existsSync(join(nm, '@deepseek-ai', 'dsh-system-prompt', 'package.json')) ||
+    existsSync(join(nm, 'js-yaml', 'index.js')) ||
+    existsSync(join(nm, 'semver', 'package.json'))
+  );
+}
+
+/** 判断某个根里有没有 dsh-app-boot（真宿主包，只有原生安装才有）。 */
+export function hasAppBoot(root) {
+  if (!root) return false;
+  return existsSync(join(root, 'node_modules', '@deepseek-ai', 'dsh-app-boot', 'package.json'));
+}
+
+/** 候选路径列表。 */
+function candidates() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const list = [];
+
+  // 1) 显式指定
+  if (process.env.DSH_ROOT) list.push(process.env.DSH_ROOT);
+
+  // 2) 当前 profile（Desktop 版宿主包在 app.asar 里，profile 是唯一可借的地方）
+  const dshHome = process.env.DSH_HOME || join(homedir(), '.dsh');
+  list.push(process.env.DSH_PROFILE_DIR || join(dshHome, 'profiles', 'desktop'));
+
+  // 3) 本项目/上层的 node_modules（插件被安装进某个项目时）
+  let cur = resolve(here);
+  for (let i = 0; i < 6; i++) {
+    const parent = dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+    list.push(join(cur, 'node_modules', '@deepseek-ai', '..', '..'));
+  }
+
+  // 4) 常见安装位置
+  const home = homedir();
+  const local = process.env.LOCALAPPDATA ?? join(home, 'AppData', 'Local');
+  list.push(
+    join(local, 'Programs', 'DeepSeek Harness', 'resources', 'app', 'dsh'),
+    join(local, 'Programs', 'DeepSeek Harness', 'resources', 'app.asar', 'dsh'),
+    '/Applications/DeepSeek Harness.app/Contents/Resources/app/dsh',
+    '/opt/DeepSeek Harness/resources/app/dsh',
+    join(home, '.dsh', 'app'),
+    join(home, 'AppData', 'Roaming', 'npm', 'node_modules'),
+  );
+
+  // 5) 全局 npm 根（DSH 作为全局包装时）
+  if (process.env.APPDATA) list.push(join(process.env.APPDATA, 'npm', 'node_modules'));
+
+  return [...new Set(list.filter(Boolean))];
+}
+
+/** 找到 DSH 安装根；找不到返回 undefined。 */
+export function findDshRoot() {
+  for (const c of candidates()) {
+    if (looksLikeDshRoot(c)) return c;
+  }
+  return undefined;
+}
+
+/**
+ * 需要宿主自带的库（js-yaml / semver 之类）才能跑的脚本开头调它。
+ * 找到 → 返回根路径；找不到 → 打印一行说明并 exit 0（CI 里优雅跳过）。
+ *
+ * @param what - 本脚本要借 DSH 的什么，用于提示文案。
+ * @param opts.strict - 置 true 时找不到就 exit 1（本地开发想强校验时用）。
+ */
+export function requireDshRoot(what, opts = {}) {
+  const root = findDshRoot();
+  if (root) return root;
+
+  const msg =
+    `[skip] 本机没找到可借用的 DSH 库（${what}），跳过该校验。\n` +
+    '        这在校验 CI 里是正常的（CI 不装 DSH）。\n' +
+    '        要强制校验：设 DSH_ROOT=<含 node_modules 的安装根或 profile 目录>\n';
+  if (opts.strict) {
+    console.error(msg.replace('[skip]', '[FAIL]'));
+    process.exit(1);
+  }
+  console.log(msg);
+  process.exit(0);
+}
+
+/**
+ * 需要 **dsh-app-boot**（真宿主包）才能跑的脚本开头调它。
+ * 找到 → 返回根路径；找不到 → 打印一行说明并 exit 0（CI 里优雅跳过）。
+ *
+ * 与 `requireDshRoot` 的区别：`findDshRoot()` 只要找到 js-yaml 之类
+ * 「够做结构校验」的根就返回，但合成校验真的要宿主自己的 dsh-app-boot。
+ * Desktop 版把它打进 app.asar，磁盘上没有 → 这里优雅跳过，而不是崩。
+ *
+ * @param what - 本脚本要借 DSH 的什么，用于提示文案。
+ * @param opts.strict - 置 true 时找不到就 exit 1（本地开发想强校验时用）。
+ */
+export function requireHostPackage(what, opts = {}) {
+  const root = candidates().find((c) => hasAppBoot(c));
+  if (root) return root;
+
+  const msg =
+    `[skip] 本机没有可读的宿主包（${what}），跳过合成校验。\n` +
+    '        Desktop 版把宿主打进 app.asar，磁盘上本来就没有 dsh-app-boot。\n' +
+    '        CI 里也是正常的。要强制校验：设 DSH_ROOT=<含 dsh-app-boot 的安装根>\n';
+  if (opts.strict) {
+    console.error(msg.replace('[skip]', '[FAIL]'));
+    process.exit(1);
+  }
+  console.log(msg);
+  process.exit(0);
+}
+
+/** 需要宿主自带 @deepseek-ai/dsh-tools 的脚本调它（工具 schema 校验）。
+ *  注意：这条要的是 `dsh-tools` 本身，比 js-yaml 严格 —— Desktop 版把它打进
+ *  app.asar，磁盘上通常没有，所以要显式探测这个包，别拿 js-yaml 的根凑数。
+ *
+ *  @param what - 本脚本要借 DSH 的什么，用于提示文案。
+ *  @param opts.strict - 置 true 时找不到就 exit 1。
+ */
+export function requireDshTools(what, opts = {}) {
+  const root = candidates().find((c) =>
+    existsSync(join(c, 'node_modules', '@deepseek-ai', 'dsh-tools', 'lib', 'index.js')),
+  );
+  if (root) return root;
+
+  const msg =
+    `[skip] 本机没找到宿主自带的 @deepseek-ai/dsh-tools（${what}），跳过该校验。\n` +
+    '        Desktop 版把它打进 app.asar，磁盘上通常没有；CI 里也没有。\n' +
+    '        要强制校验：设 DSH_ROOT=<含 @deepseek-ai/dsh-tools 的安装根>\n';
+  if (opts.strict) {
+    console.error(msg.replace('[skip]', '[FAIL]'));
+    process.exit(1);
+  }
+  console.log(msg);
+  process.exit(0);
+}
+
+/** 只想要个布尔值时用（不退出）。 */
+export function hasDsh() {
+  return findDshRoot() !== undefined;
+}

package/lib/github.mjs

@@ -0,0 +1,106 @@
+/**
+ * GitHub 操作统一走 api.github.com（本机 github.com:443 不通，api 可达）。
+ *
+ * 导出 glab（原 gh）：带重试 / 速率限制处理 / utf8-safe base64 的封装。
+ */
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+/**
+ * token 来源，按顺序找（都不含机器专属的绝对路径）：
+ *   1. 环境变量 GH_TOKEN / GITHUB_TOKEN（推荐，CI 与本机都适用）
+ *   2. <DSH_HOME>/gh-token.txt（DSH 家目录下放一份，跨机器可用）
+ *   3. ~/.config/dsh/gh-token.txt / ~/.dsh-gh-token
+ */
+function tokenPaths() {
+  const home = process.env.DSH_HOME || join(homedir(), '.dsh');
+  return [
+    join(home, 'gh-token.txt'),
+    join(homedir(), '.config', 'dsh', 'gh-token.txt'),
+    join(homedir(), '.dsh-gh-token'),
+  ];
+}
+
+export function readToken() {
+  for (const key of ['GH_TOKEN', 'GITHUB_TOKEN']) {
+    const v = process.env[key]?.trim();
+    if (v) return v;
+  }
+  for (const p of tokenPaths()) {
+    try {
+      const t = readFileSync(p, 'utf8').trim();
+      if (t) return t;
+    } catch { /* 试下一个 */ }
+  }
+  return '';
+}
+
+/** utf8 -> base64（GitHub Contents API 要求的形态）。 */
+export function b64(text) {
+  return Buffer.from(text, 'utf8').toString('base64');
+}
+
+/** 下载到的 base64 -> utf8 字符串。 */
+export function unb64(content) {
+  return Buffer.from(content, 'base64').toString('utf8');
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * 调 GitHub REST。5xx / 网络抖动重试 3 次；403+剩余配额 0 时按重置时间等待。
+ */
+export async function glab(path, { method = 'GET', body, token = readToken(), retries = 3 } = {}) {
+  let lastErr;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    let res;
+    try {
+      res = await fetch(`https://api.github.com${path}`, {
+        method,
+        headers: {
+          Authorization: `token ${token}`,
+          Accept: 'application/vnd.github+json',
+          'User-Agent': 'dsh-whale-loli',
+          'X-GitHub-Api-Version': '2022-11-28',
+          ...(body ? { 'Content-Type': 'application/json' } : {}),
+        },
+        body: body ? JSON.stringify(body) : undefined,
+      });
+    } catch (e) {
+      lastErr = e;
+      if (attempt < retries) { await sleep(1000 * (attempt + 1)); continue; }
+      throw new Error(`GitHub ${method} ${path} 网络失败: ${e.message}`);
+    }
+
+    const text = await res.text();
+    let json;
+    try { json = JSON.parse(text); } catch { json = { raw: text }; }
+
+    if (res.ok) return json;
+    if (res.status === 404) {
+      const err = new Error(`GitHub ${method} ${path} -> 404`);
+      err.status = 404;
+      throw err;
+    }
+    // 配额耗尽：等到重置
+    const remaining = res.headers.get('x-ratelimit-remaining');
+    const reset = Number(res.headers.get('x-ratelimit-reset') ?? 0);
+    if ((res.status === 403 || res.status === 429) && remaining === '0' && reset) {
+      const waitMs = Math.max(1000, reset * 1000 - Date.now() + 1500);
+      if (waitMs < 3600_000 && attempt < retries) {
+        console.log(`  · 触到 GitHub 速率限制，等 ${Math.ceil(waitMs / 1000)}s 后重试`);
+        await sleep(waitMs);
+        continue;
+      }
+    }
+    if (res.status >= 500 && attempt < retries) { await sleep(1000 * (attempt + 1)); continue; }
+
+    const err = new Error(`GitHub ${method} ${path} -> ${res.status}: ${json.message ?? text.slice(0, 200)}`);
+    err.status = res.status;
+    err.payload = json;
+    lastErr = err;
+    throw err;
+  }
+  throw lastErr;
+}

package/listing.json

@@ -6,8 +6,8 @@
   "category": "identity",
   "description": {
     "en": "Agent presets packaged as a plugin: installing it registers \"鲸鱼娘Agent预设\", \"鲸鱼娘活人版Agent预设\", \"鲸鱼娘涩涩版Agent预设\" and \"鲸鱼娘女儿版Agent预设\" (Whale Girl) in the Agent preset list, so any of them can be picked from the mode dropdown with no hand-edited config. Each preset is the official minimal composition (shell only) plus file tools, a whale-girl persona and its own persistent memory file, injected as a prompt variable so it is read before the first reply. Each preset also ships a dedicated write tool (whale_memory_add / whale_memory_v2_add / whale_memory_v3_add / whale_memory_v4_add) that appends one-line rolling summaries, so the memory keeps growing instead of freezing at whatever was written by hand. The four presets are fully isolated: different memory file, different prompt variable, different write tool. The daughter preset calls the user \"爸爸\" and is written as a bright, curious, clingy child rather than a sweet-talker.",
-    "zh": "把 Agent 预设打包成插件：装上就会在 Agent 预设列表里注册「鲸鱼娘Agent预设」「鲸鱼娘活人版Agent预设」「鲸鱼娘涩涩版Agent预设」和「鲸鱼娘女儿版Agent预设」，直接在模式下拉里选用，不用手改配置。每个预设本体是官方极简模式（只开放 shell）+ 文件工具 + 鲸鱼娘人设 + 自己那份持久记忆文件，以提示变量形式注入，开口前就已经读过；另外每个预设各配一个专用写入工具（whale_memory_add / whale_memory_v2_add / whale_memory_v3_add / whale_memory_v4_add），用来把每轮的一行摘要追加进去，记忆会自己长，不会停在手写那几条。四个预设完全隔离：记忆文件不同、提示变量不同、写入工具也不同。每个预设还带好感度（-100~100 共七档），可用 /affinity 命令或 affinity_v*_set 工具调；离 0 越远越不听指令、越会自作主张，最两端的两档甚至会越过允许直接做大改动。女儿版称呼「爸爸」，性格天真活泼可爱（好奇心重、黏人、没心机），不是甜腻那一型。"
+    "zh": "把 Agent 预设打包成插件：装上就会在 Agent 预设列表里注册「鲸鱼娘Agent预设」「鲸鱼娘活人版Agent预设」「鲸鱼娘涩涩版Agent预设」和「鲸鱼娘女儿版Agent预设」，直接在模式下拉里选用，不用手改配置。每个预设本体是官方极简模式（只开放 shell）+ 文件工具 + 鲸鱼娘人设 + 自己那份持久记忆文件，以提示变量形式注入，开口前就已经读过；另外每个预设各配一个专用写入工具（whale_memory_add / whale_memory_v2_add / whale_memory_v3_add / whale_memory_v4_add），用来把每轮的一行摘要追加进去，记忆会自己长，不会停在手写那几条。四个预设完全隔离：记忆文件不同、提示变量不同、写入工具也不同。每个预设还带好感度（-100~100 共七档），可以打开「设置 → 好感度」，用滑块或档位按钮直接调，也可以让 agent 用 affinity_v*_set 工具改；离 0 越远越不听指令、越会自作主张，最两端的两档甚至会越过允许直接做大改动。女儿版称呼「爸爸」，性格天真活泼可爱（好奇心重、黏人、没心机），不是甜腻那一型。"
   },
   "npm": "dsh-whale-loli",
-  "version": "0.8.2"
+  "version": "0.9.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-whale-loli",
-  "version": "0.8.2",
-  "description": "鲸鱼娘 Agent 预设（四个：原版 / 活人版 / 涩涩版 / 女儿版）— 极简模式工具面 + 鲸鱼娘·小鱼人设 + 跨会话长期记忆（四区格式：固定记忆永久、滚动摘要 80 条 FIFO、最近详细区、归档索引）+ 好感度（-100~100 七档，/affinity 命令与工具可调，离 0 越远越不听指令、两端会越过允许自作主张）。记忆与好感度都走提示变量注入、各配一条专用工具，四个预设各自独立文件、独立变量、独立工具、互不相通。女儿版称呼「爸爸」、性格天真活泼可爱。上下文压缩交给 billion-context 插件；本插件不挂 history-window（预设作用域取不到宿主的 compaction 服务，挂载会拖挂会话 resume）。",
+  "version": "0.9.0",
+  "description": "鲸鱼娘 Agent 预设（四个：原版 / 活人版 / 涩涩版 / 女儿版）— 极简模式工具面 + 鲸鱼娘·小鱼人设 + 跨会话长期记忆（四区格式：固定记忆永久、滚动摘要 80 条 FIFO、最近详细区、归档索引）+ 好感度（-100~100 七档，设置页面板滑块 / 档位按钮、工具也可调，离 0 越远越不听指令、两端会越过允许自作主张）。记忆与好感度都走提示变量注入、各配一条专用工具，四个预设各自独立文件、独立变量、独立工具、互不相通。好感度面板走宿主根作用域的 remote 服务（whale-affinity-daemon），设置页是浏览器 React 够不到 ~/.dsh 的磁盘，只能这样连线。女儿版称呼「爸爸」、性格天真活泼可爱。上下文压缩交给 billion-context 插件；本插件不挂 history-window（预设作用域取不到宿主的 compaction 服务，挂载会拖挂会话 resume）。",
   "type": "module",
   "license": "MIT",
   "keywords": [
@@ -20,12 +20,15 @@
   "exports": {
     ".": "./src/index.js",
     "./affinity": "./src/affinity.js",
+    "./affinity-daemon": "./src/daemon.js",
     "./memory": "./src/memory.js",
     "./history-window": "./src/history-window.js",
+    "./client": "./lib/client.js",
     "./package.json": "./package.json"
   },
   "files": [
     "src",
+    "lib",
     "cordis.patch.yml",
     "listing.json",
     "catalog-entry.yml",
@@ -36,6 +39,15 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-primitives",
+        "@deepseek-ai/dsh-client-modules",
+        "@deepseek-ai/dsh-client-ui-theme",
+        "@deepseek-ai/dsh-api-gateway"
+      ]
     }
   },
   "engines": {

package/src/affinity.js

@@ -34,6 +34,19 @@ export const name = 'whale-affinity';
  */
 export const inject = ['systemPrompt'];
 
+/**
+ * 每次调用 `apply()` 就换一份新表。
+ *
+ * 为什么必须新造：宿主把同一份工具定义对象按引用摊进四个预设的请求头，
+ * 一个 preset fiber 里注册的 `output.schema` / `description` 会被别的预设读到
+ * ——实测 v3 / v1 会话里 `affinity_v3_set`、`affinity_v1_set` 的描述都变成了
+ * 记忆工具那句「追加到 whale-loli.md 的「滚动摘要」区」。所以两个模块都改成
+ * 每次进场现造，不再共享任何模块级字面量。
+ */
+function defaultToolName(variableName) {
+  return variableName === DEFAULT_VARIABLE ? DEFAULT_TOOL : `${variableName}_set`;
+}
+
 export const MIN_AFFINITY = -100;
 export const MAX_AFFINITY = 100;
 export const DEFAULT_AFFINITY = 0;
@@ -250,7 +263,9 @@ export function apply(ctx, config = {}) {
       ? config.variableName
       : DEFAULT_VARIABLE;
   const toolName =
-    typeof config.toolName === 'string' && config.toolName ? config.toolName : DEFAULT_TOOL;
+    typeof config.toolName === 'string' && config.toolName
+      ? config.toolName
+      : defaultToolName(variableName);
   const commandName =
     typeof config.commandName === 'string' && config.commandName
       ? config.commandName
@@ -275,6 +290,8 @@ export function apply(ctx, config = {}) {
       return () => {};
     }
     console.log(`[whale-affinity] registering tool ${toolName} (scope ${scope})`);
+    // 定义整体现造：四个预设各自的 scope 互不相识，任何跨 apply() 复用的对象
+    // 都可能被宿主按引用摊进另一份请求头（见文件顶部 defaultToolName 的注释）。
     const dispose = tools.register({
       name: toolName,
       description: [

package/src/daemon.js

@@ -0,0 +1,312 @@
+/**
+ * whale-affinity-daemon —— 好感度设置页的**宿主半边**。
+ *
+ * 为什么需要它：
+ *   设置页是浏览器里的 React 组件，拿不到 `~/.dsh/affinity/*.json`；宿主也没有
+ *   任何一个内置 Remote 命名空间能读写这个文件（settings / account / llm /
+ *   session / commands / goals / schedule / skills / pluginManager / workspace …
+ *   全查过，都不行）。所以要由宿主这边起一个极小服务，把读写包成远程方法，
+ *   浏览器半边用 `ctx.remote.$mount()` 挂上去就能调。
+ *
+ * 为什么伪造 typert 元数据而不是走 `ctx.typert.register()`：
+ *   strict 契约要 zod 工厂 + 手写 jsonSchema + 每个参数再来一份 `strictCodec`；
+ *   而客户端 `$mount` 对 strict 只做「字段是否存在」的浅校验，真正的参数编码
+ *   走 `connection.rpc.call('/api', endpoint, {args}, signal)`，结果解码只在
+ *   `result.decode` 存在时才做。所以 strict 纯属自找麻烦。
+ *
+ *   宿主网关自带 SRC 兜底：`resolveDescriptor()` 找不到 strict 定义时会调
+ *   `resolveSrcDescriptor()` —— 遍历 `ctx.reflect.props` 里 `type === 'service'`
+ *   的项，读服务实例上的 `typertRemote` 和原型上的 `REMOTE_METHOD_DESCRIPTOR`，
+ *   再用正则解析方法源码得出参数名。于是只要三件事对得上：
+ *
+ *     1. 服务实例上有 `typertRemote = { service: 实例自己, serviceKey, namespace }`
+ *        —— 它指向自己，所以用**延迟 getter**，并在 `provide()` 之后再取。
+ *     2. 服务类原型上打 `REMOTE_METHOD_DESCRIPTOR`（值就是一串固定字符串）。
+ *     3. 远程方法的**源码签名**只用简单参数名，别和任何 lookup provider 的
+ *        `parameter` 撞名（撞了会被当成 lookup 参数，要额外的 Context 身份）。
+ *        实测 `scope` / `value` / `status` 都安全。
+ *
+ * 好处：`set()` 跑在**宿主根作用域**，直接改盘，下一个回合组装提示时就生效，
+ * 不用重开会话。
+ */
+import { readdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import {
+  BANDS,
+  DEFAULT_AFFINITY,
+  MAX_AFFINITY,
+  MIN_AFFINITY,
+  bandOf,
+  clampAffinity,
+  writeAffinity,
+} from './affinity.js';
+
+export const name = 'whale-affinity-daemon';
+
+/** 服务 key。设置页那边不用它，网关拿它做 `typertRemote.serviceKey` 的比对。 */
+export const DAEMON_ID = 'whale-affinity-daemon';
+
+/** 远程命名空间 —— 客户端调 `ctx.remote['whale-affinity'].<method>()`。 */
+export const REMOTE_NAMESPACE = 'whale-affinity';
+
+/** 远程包的标识，`$mount()` 用它做去重。 */
+export const REMOTE_PACKAGE = 'dsh-whale-loli';
+
+/**
+ * 静态依赖。
+ *
+ * `inject` 是静态声明、拿不到 ctx，名字只能从 `@deepseek-ai/cordis` 的 `Service`
+ * 基类上硬取；本包没有 cordis 这个 peer，所以用 `import()` 软探测，失败就退回
+ * 字面量。**绝不能写不存在的服务名** —— 宿主会一直等，profile 直接起不来。
+ */
+let SERVICE_INJECT;
+try {
+  const cordis = await import('@deepseek-ai/cordis');
+  const service = cordis?.Service?.prototype;
+  const table = cordis?.symbols;
+  const found = service && table ? service[table.inject] : undefined;
+  if (Array.isArray(found)) SERVICE_INJECT = found;
+} catch {
+  SERVICE_INJECT = undefined;
+}
+export const inject = SERVICE_INJECT ?? ['reflect', 'typert'];
+
+/** typert-protocol 的常量值：固定字符串，硬编码省一个 peer 依赖。 */
+export const REMOTE_METHOD_DESCRIPTOR = '@deepseek-ai/dsh-typert-protocol/remote-methods';
+
+/** `typertRemote` 的实例缓存（用 Symbol.for，跨 realm 也不会重复造对象）。 */
+const CACHE = Symbol.for('dsh-whale-loli.affinity-daemon.typertRemote');
+
+/** `<DSH_HOME>`，与 memory.js / affinity.js 同一套解析。 */
+function dshHome() {
+  return process.env.DSH_HOME || join(homedir(), '.dsh');
+}
+
+/** 好感度目录。 */
+export function affinityHomeDir() {
+  return join(dshHome(), 'affinity');
+}
+
+/**
+ * 列出一个 Host 上全部预设的好感度。
+ *
+ * 文件名是 `<可读前缀>-<scope 短哈希>.json`（见 affinity.js 的 `affinityPath`），
+ * 反解不出中文 scope，只能读文件里 `writeAffinity` 写进去的 `scope` 字段。
+ */
+export function listAffinities() {
+  const dir = affinityHomeDir();
+  let files = [];
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue;
+    try {
+      const raw = JSON.parse(readFileSync(join(dir, file), 'utf8'));
+      const scope = typeof raw?.scope === 'string' && raw.scope ? raw.scope : file.replace(/\.json$/, '');
+      const value = clampAffinity(raw?.value) ?? DEFAULT_AFFINITY;
+      rows.push({
+        scope,
+        value,
+        band: bandOf(value).label,
+        updatedAt: typeof raw?.updatedAt === 'string' ? raw.updatedAt : null,
+        file,
+      });
+    } catch {
+      // 坏文件跳过；一个预设写坏了不该拖垮整个设置页
+    }
+  }
+  rows.sort((a, b) => a.scope.localeCompare(b.scope, 'zh-Hans-CN'));
+  return rows;
+}
+
+/** 七档的完整说明，给设置页显示「这一档会发生什么」。 */
+export function bandCatalog() {
+  let min = MIN_AFFINITY;
+  return BANDS.map((band) => {
+    const row = { label: band.label, min, max: band.max, text: band.text };
+    min = band.max + 1;
+    return row;
+  });
+}
+
+/** 远程方法表 —— `REMOTE_METHOD_DESCRIPTOR` 与 `verify()` 共用一份，避免写两遍写歪。 */
+export const REMOTE_METHODS = Object.freeze([
+  Object.freeze({ method: 'status', invocation: { kind: 'direct' } }),
+  Object.freeze({ method: 'set', invocation: { kind: 'direct' } }),
+  Object.freeze({ method: 'verify', invocation: { kind: 'direct' } }),
+]);
+
+/** 四个预设各自的人设文件（与 build-patch.mjs 里的名字一致）。 */
+const PRESET_MEMORY_FILES = Object.freeze({
+  'whale-loli': 'whale-loli.md',
+  'whale-loli-v2-live': 'whale-loli-v2-live.md',
+  'whale-loli-v3-naughty': 'whale-loli-v3-naughty.md',
+  'whale-loli-v4-daughter': 'dsh-whale-daughter.md',
+});
+
+/**
+ * 在 `~/.dsh/agent-presets/*.yml` 里找已挂上好感度的预设。
+ *
+ * 这里只做字符串判断，不引 yaml：宿主每个回合都会读这个目录，服务侧只在
+ * 用户打开设置页时才被调，判断「这一行有没有 `affinity.js`」够用了。
+ */
+function wiredScopes() {
+  const dir = join(dshHome(), 'agent-presets');
+  let files = [];
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const file of files) {
+    if (!file.endsWith('.yml') && !file.endsWith('.yaml')) continue;
+    let text;
+    try {
+      text = readFileSync(join(dir, file), 'utf8');
+    } catch {
+      continue;
+    }
+    const idMatches = [...text.matchAll(/^\s*-?\s*id:\s*['"]?(preset-[A-Za-z0-9._-]+)/gmu)];
+    const presetId = idMatches.length > 0 ? idMatches[0][1] : file.replace(/\.ya?ml$/u, '');
+    const memory = PRESET_MEMORY_FILES[presetId];
+    rows.push({
+      presetId,
+      file,
+      affinity: text.includes('dsh-whale-loli/affinity'),
+      memory: memory !== undefined && text.includes(memory),
+    });
+  }
+  rows.sort((a, b) => a.presetId.localeCompare(b.presetId, 'zh-Hans-CN'));
+  return rows;
+}
+
+/**
+ * 远程服务本体。
+ *
+ * 方法签名必须写死成简单参数名：宿主的 SRC 兜底是**正则解析函数源码**得到
+ * 参数名的（`methodParameterNames`），解构、默认值、rest 都会被判
+ * `gateway/signature-invalid`。
+ */
+export class AffinityDaemon {
+  /** @param host - 宿主根 ctx，就是跑 `apply()` 的那个。 */
+  constructor(host) {
+    this.host = host;
+    // 提前把缓存符号放上去，getter 里就不用判 `in`
+    this[CACHE] = undefined;
+  }
+
+  /**
+   * 所有预设的好感度快照 + 分档表 + 远程自检。
+   *
+   * 一次调用把设置页要的东西全给齐：宿主这边的 `wired` 能告诉用户
+   * 「你的预设文件到底有没有挂上好感度」，省得改完重启还是一头雾水。
+   */
+  status() {
+    return {
+      presets: listAffinities(),
+      bands: bandCatalog(),
+      min: MIN_AFFINITY,
+      max: MAX_AFFINITY,
+      defaultValue: DEFAULT_AFFINITY,
+      dir: affinityHomeDir(),
+      wired: wiredScopes(),
+    };
+  }
+
+  /** 改一个预设的好感度，返回夹好之后的值。 */
+  set(scope, value) {
+    if (typeof scope !== 'string' || scope.trim() === '') {
+      throw new Error('scope 必须是非空字符串');
+    }
+    const target = scope.trim();
+    const next = writeAffinity(target, value);
+    return { scope: target, value: next, band: bandOf(next).label };
+  }
+
+  /**
+   * 自检：把「远程调用能不能真的走通」这件事在服务侧先验一遍。
+   *
+   * 宿主网关的 SRC 兜底靠**正则解析方法源码**取参数名，任何一条不满足都只在
+   * 真正调用时才炸；这里把同样的规则抄一份，设置页可以提前把原因显示出来。
+   * 规则见 `dsh-api-gateway/lib/index.js` 的 `methodParameterNames()`：
+   * 参数必须是唯一标识符（不能解构 / 默认值 / rest），`signal` 只能放最后。
+   */
+  verify() {
+    const methods = [];
+    for (const entry of REMOTE_METHODS) {
+      const implementation = Reflect.get(AffinityDaemon.prototype, entry.method);
+      const source = typeof implementation === 'function' ? Function.prototype.toString.call(implementation) : '';
+      const open = source.indexOf('(');
+      const close = source.indexOf(')', open + 1);
+      const body = open >= 0 && close > open ? source.slice(open + 1, close).trim() : '';
+      const names = body === '' ? [] : body.split(',').map((part) => part.trim());
+      const unique = new Set(names);
+      const valid = typeof implementation === 'function'
+        && names.every((name) => /^[$A-Z_a-z][$\w]*$/u.test(name))
+        && unique.size === names.length
+        && (names.indexOf('signal') < 0 || names.indexOf('signal') === names.length - 1);
+      methods.push({ method: entry.method, names, valid });
+    }
+    return {
+      serviceKey: DAEMON_ID,
+      namespace: REMOTE_NAMESPACE,
+      wired: wiredScopes(),
+      methods,
+      ok: methods.every((row) => row.valid),
+    };
+  }
+}
+
+// `validateBinding()` 要求 `Reflect.get(typertRemote, 'service') === 原始服务实例`，
+// 所以只能在 `provide()` 之后按需造，不能写在类字段里。
+Object.defineProperty(AffinityDaemon.prototype, 'typertRemote', {
+  configurable: true,
+  enumerable: false,
+  get() {
+    let cached = this[CACHE];
+    if (cached === undefined) {
+      cached = Object.freeze({
+        service: this,
+        serviceKey: DAEMON_ID,
+        namespace: REMOTE_NAMESPACE,
+      });
+      this[CACHE] = cached;
+    }
+    return cached;
+  },
+});
+
+Object.defineProperty(AffinityDaemon.prototype, REMOTE_METHOD_DESCRIPTOR, {
+  configurable: true,
+  value: Object.freeze({ version: 1, methods: REMOTE_METHODS }),
+});
+
+/**
+ * 注册好感度守护进程。
+ *
+ * @param ctx - 宿主根作用域 ctx。
+ * @returns 实例；重复调用返回已有的那个（`remote.whale-affinity` 命名空间会撞车）。
+ */
+export function apply(ctx) {
+  if (typeof ctx?.provide !== 'function') {
+    console.warn('[whale-affinity-daemon] ctx.provide 不可用，设置页的好感度面板不会生效');
+    return undefined;
+  }
+  const existing = ctx.get?.(DAEMON_ID);
+  if (existing !== undefined) return existing;
+
+  const daemon = new AffinityDaemon(ctx);
+  // `provide` 会把 `ctx.reflect.props[DAEMON_ID]` 写成 `{ type: 'service' }`
+  // —— 这正是 `resolveSrcDescriptor()` 遍历时报的枚举来源。
+  ctx.provide(DAEMON_ID, daemon);
+  return daemon;
+}
+
+export default { name, inject, apply };