diff --git a/plugins/antianqi/mmx-octopus/.minimax-plugin/plugin.json b/plugins/antianqi/mmx-octopus/.minimax-plugin/plugin.json
index ee3332af..0f8bd4f7 100644
--- a/plugins/antianqi/mmx-octopus/.minimax-plugin/plugin.json
+++ b/plugins/antianqi/mmx-octopus/.minimax-plugin/plugin.json
@@ -2,7 +2,7 @@
   "schemaVersion": 1,
   "name": "mmx-octopus",
   "displayName": "MMX 章鱼娘",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "桌面上的 MMX 章鱼娘 —— MMX Agent 的可视化身体，也是你自己的专属聊天对象。她会反映 Agent 正在思考还是正在干活，还能被 Agent 和技能通过托管 MCP 直接指挥说话、换表情、挪位置。权限说明：本插件会读取你每个对话每轮的最终回复、标题与运行状态，用来判断 Agent 正在思考还是已经完成，并在你主动问她时用她自己的固定会话跑一轮 Agent，把回答直接说出来；她的对话历史只存在本机。",
   "author": "antianqi",
   "icon": "icon.png",
diff --git a/plugins/antianqi/mmx-octopus/README.md b/plugins/antianqi/mmx-octopus/README.md
index 3354de2b..05bc5f2c 100644
--- a/plugins/antianqi/mmx-octopus/README.md
+++ b/plugins/antianqi/mmx-octopus/README.md
@@ -5,7 +5,7 @@ doing, and the Agent can tell her what to say.*
 
 English | [简体中文](README.zh-CN.md)
 
-Author: [antianqi](https://github.com/antianqi) · Version: `1.8.0` ·
+Author: [antianqi](https://github.com/antianqi) · Version: `1.9.0` ·
 Plugin ID: `mmx-octopus` · Category: `Productivity`
 
 *The app interface is in Chinese.*
@@ -27,6 +27,14 @@ Plugin ID: `mmx-octopus` · Category: `Productivity`
 - **The Agent can drive her.** This package hosts an MCP server with four
   tools (below), so the Agent can make her speak, change her expression, move
   her, or read her state.
+- **She can answer with an agent of her own — if you make one.** The plugin
+  never creates an agent for you and never writes one. If you want her to have
+  her own, open the panel (Settings → 「想要更鲜明的性格？」) and press
+  **「复制她的设定」** ("copy her settings"): it puts her character sheet on
+  your clipboard. Paste it into a new agent named `mmx` in the Host's Agent
+  settings, and the plugin finds that agent on its own (read-only) and answers
+  with it. Skip the step and she answers with the default agent, her character
+  sheet travelling with every message.
 - **She stays out of the way.** The floating window is frameless, transparent,
   always on top and click-through, so it never blocks the desktop. It is
   220 × 460 and can be dragged anywhere on the screen; the Agent can park it in
@@ -65,6 +73,8 @@ Nothing else is needed: no API key, no account, no dependency to install.
 2. Drag it to a corner, or let the Agent move it with `mmx_move`.
 3. Talk to the Agent as usual and watch her expression follow along.
 4. Open the panel and write to her — she answers in her own session.
+5. Optional: give her an agent of her own — copy her settings from the panel
+   and paste them into a new agent named `mmx` (see "What it does").
 
 ### The Agent's four tools
 
@@ -109,81 +119,54 @@ it like the rest of the port.
 - **What it reads** — this package's own files, read from
   `context.pluginRoot`: `miniapp/node/identity/AGENTS.md` and
   `miniapp/node/identity/STORY.md` (who she is), plus the page assets under
-  `miniapp/client/`.
+  `miniapp/client/`; and the list of agents the Host exposes, which it only
+  reads to decide which agent answers for her.
 - **What it writes** — four JSON files under `context.dataDir`, the private
-  directory the Host creates for this plugin:
+  directory the Host creates for this plugin, and **nothing outside it**:
   `context.dataDir/state.json` (her expression, position, bubble and the Agent's
   busy state), `context.dataDir/chat.json` (your chat with her),
   `context.dataDir/diary.json` (her diary) and `context.dataDir/style.json`
   (how she has learned to write). Every write is atomic — a temporary file in
   the same directory, then a rename — so a crash cannot leave a half-written
   file behind.
-- **At most one new agent file outside `context.dataDir`** — since 1.8.0 the
-  runtime **can add one agent of its own** to the Host's agent directory, so
-  that her character sheet can live in that agent's system prompt instead of
-  only in the message. **By default it adds one**: the panel has a
-  two-way choice ("Which agent should she use"), and the default is "create a
-  dedicated agent" — that tier adds the agent, so her character stays in that
-  agent's system prompt (crisper personality, more lifelike replies).
-  **You can switch back to "use an existing agent" at any time** — in that tier
-  the plugin writes **not a single byte** outside its own data directory and
-  her character sheet travels with the message only. The choice is asked
-  **on first run**: the opening card asks  for the tier first, then for her name and how she addresses you; you can
-  change it in the panel at any time. Full disclosure:
-  - **Which file** — exactly one: `<Host agent directory>/mmx-octopus-agent/agent.md`.
-    The directory and the file are **new**; the Host picks it up without a
-    restart.
-  - **What is in it** — the same character sheet the plugin would otherwise
-    send with every message (who she is, what she looks like, her rules), plus
-    the frontmatter the Host expects (`name`, `description`, `displayName`).
-  - **What is never touched** — **no existing agent is modified and no other
-    file is written**: not your agents' `agent.md`, not the `AGENTS.md` of an
-    agent workspace, not your project files. If the name `mmx-octopus-agent` is
-    already taken by an agent that is not ours, the plugin **writes nothing and
-    does not use it** — she keeps working on an existing agent (that other
-    agent's file is never treated as ours).
-  - **How it is written** — atomically (temporary file, then a rename), one
-    write at a time, and only when the file does not exist yet: an existing
-    file is never overwritten, so there is nothing to back up.
-  - **How to remove it, or how to pick up a new version** — the file is
-    **never rewritten in place**, so after you upgrade the package the old
-    character sheet stays in it. Delete
-    `<Host agent directory>/mmx-octopus-agent/` and the runtime adds it again on
-    the next start, this time with the current version's sheet. If you would
-    rather not have this agent at all, pick "use an existing agent" in the
-    panel — the plugin then leaves it alone, and as long as you    do not switch back to "create a dedicated agent" it will not be recreated.
-    Nothing else on your machine is affected.
-  - **How the directory is found — it is never guessed** — only from the
-    workspace of a session the plugin itself created: the Host sets that
-    workspace to the Mini App's own agent directory
-    (`<Host agent directory>/<agent>/miniapps/<plugin-id>`), and the plugin
-    takes its parent. It does **not** walk up the filesystem looking for a
-    folder called `agents` (a project of yours could contain one, and the
-    file would land in your project), and it does **not** derive the
-    directory from `context.dataDir`. If that one path does not identify the
-    directory, the plugin writes **nothing** and falls back to sending her
-    character sheet with every message, exactly as before.
-  - **One session of its own** — to learn that path the plugin may create one
-    session through the Host's Agent API. Such sessions belong to the plugin
-    and do **not** show up in your chat list; the plugin reuses that session
-    as hers instead of creating another one.
+- **No file outside `context.dataDir`** — since 1.9.0 the runtime writes
+  **nothing else at all**: no agent file, nothing under the Host's agent
+  directory, nothing in your project. The only files it touches are the four
+  JSON files listed above.
+  - **No choice in the panel any more.** The 1.8.0 panel's two-way choice
+    ("Which agent should she use" — "create a dedicated agent" vs "use an
+    existing agent") is gone, and so is the manual `agentprov-cli.mjs` command
+    that came with it. There is nothing left to switch.
+  - **Your own `mmx` agent, if you make one.** The panel's **「复制她的设定」**
+    button only hands you her character sheet as text — it writes nothing. You
+    paste it into a new agent named `mmx` in the Host's Agent settings; the
+    plugin then finds that agent through the Host's agent list and answers
+    with it, reading it only. Creating, editing and deleting that agent stay
+    yours; the plugin only ever reads the agent list.
+  - **It still reads the Host's agent list — read-only.** The plugin reads the
+    agents the Host exposes and, if you have an agent named `mmx`, that is the
+    one she answers with. Your agent is never modified and never written to.
+    With no `mmx` agent she falls back to the default agent.
+  - **Her character sheet travels with the message.** With no dedicated agent
+    to hold it, her identity (who she is, what she looks like, her rules) is
+    carried in the prompt of every turn — see "How her identity reaches her"
+    below.
 - **Leftovers from earlier versions** — versions before 1.7.0 wrote an `AGENTS.md`
   into the workspace of the agent that has this Mini App installed, to carry her
   identity there. That is no longer written and no longer needed. If you are
   upgrading from an earlier version the old file may still be there
   (`agents/<agent>/miniapps/<plugin-id>/AGENTS.md`) and you can delete it — the
   runtime never touches it, because a plugin must not write outside its own
-  data directory.
-- **How her identity reaches her** — **twice, on purpose**. Her character
-  sheet (who she is, what she looks like, her rules) is read from this
-  package's own `miniapp/node/identity/AGENTS.md` and passed inside each
+  data directory. What 1.8.0 may have left behind is covered under
+  "Upgrading from 1.8.0" below.
+- **How her identity reaches her** — **on every turn, in the message**. Her
+  character sheet (who she is, what she looks like, her rules) is read from
+  this package's own `miniapp/node/identity/AGENTS.md` and passed inside each
   prompt, so it is never missing from a turn. Because that travels in the
   conversation, the Host's context compaction may drop it — that is why it is
-  sent again every turn. Since 1.8.0 — and only once you pick "create a
-  dedicated agent" in the panel — the same sheet is also written into the
-  system prompt of the agent added above (the file disclosed above), which
-  survives compaction; if that file cannot be written, the per-turn copy
-  remains and nothing changes for you.
+  sent again every turn. Since 1.9.0 this is the only channel: the sheet is
+  no longer written into any agent file, so the per-turn copy is the one and
+  only copy.
 - **Sessions read** — the package declares `session.read`. It reads the title,
   the running state and the final reply of a turn, to tell whether the Agent is
   thinking or has finished, and to summarise the turn. The board in the panel
@@ -191,13 +174,11 @@ it like the rest of the port.
 - **Agent turns it runs** — it declares `session.run`, and it runs **one Agent
   turn per message you send her in the chat area**, in her own session. The
   turn runs through the Host Agent, so it carries the capabilities the Host
-  grants that agent; it reads the Host's agent list to look for an agent
-  dedicated to the Mini App — in the default mode ("create a dedicated
-  agent") the one it adds itself comes first (see
-  above) and yours is only used when that one is not there; with neither, it
-  falls back to the default agent. If you pick "use an
-  existing agent" in the panel, only your own `mmx` is used (or the default agent when there is none),
-  and the one it could add is never touched. It never runs turns on your own sessions.- **Agent turns it starts on its own** — besides your messages, the runtime starts
+  grants that agent; it reads the Host's agent list and, if you have an agent
+  named `mmx`, that is the one it answers with (your agent is only read,
+  never modified); with no `mmx` agent it falls back to the default agent.
+  It never runs turns on your own sessions.
+- **Agent turns it starts on its own** — besides your messages, the runtime starts
   a few turns by itself, and **each of them uses your model quota**:
   - **Idle talk** — **off by default**; turn it on in the panel: Settings →
     「她没人的时候自己说话」 ("She talks when you are away"). Once on, after 20
@@ -229,6 +210,31 @@ it like the rest of the port.
 - **State location** — `context.dataDir`. Treat it as opaque: it may move
   between versions, so do not hard-code it.
 
+### Upgrading from 1.8.0
+
+1.9.0 changes what the plugin does with the Host's agents, not just the
+version number. **It no longer creates an agent file anywhere**, and with it
+the panel's "create a dedicated agent / use an existing agent" choice and the
+manual `agentprov-cli.mjs` command are gone as well.
+
+- **If you used 1.8.0** and let it create its own dedicated agent, the Host
+  may still have the leftover directory
+  `<Host data dir>/agents/mmx-octopus-agent/`. You can **delete it by hand** —
+  nothing in it is needed any more.
+- **1.9.0 never creates that directory and never touches it.** The only files
+  it writes are the four JSON files under `context.dataDir`.
+- **Your own `mmx` agent still wins.** If you have an agent named `mmx`, she
+  answers with it — read-only; the plugin never modifies it.
+- **1.9.0 also hands you her settings.** The panel's **「复制她的设定」** button
+  gives you her character sheet as text, so you can put it into an agent named
+  `mmx` that you create yourself. The plugin no longer creates that agent for
+  you — it only recognises it.
+
+- **If your saved state still points at the old agent, 1.9.0 ignores it.**
+  1.8.0 could have stored `mmx-octopus-agent` in the plugin's state file. 1.9.0
+  drops that name when it loads the state, so she answers with your own `mmx`
+  agent if you have one, and with the Host's default agent otherwise.
+
 ## Known limits
 
 - The interface is Chinese only.
@@ -236,6 +242,9 @@ it like the rest of the port.
 - Her body animation only covers the moments the clips cover; between clips the
   `pose` fallback runs.
 - She answers in whatever agent the Host resolves for her.
+- Without an agent named `mmx` of your own, her character sheet travels in the
+  message instead, and the Host's context compaction may drop it — which is
+  why it is sent again every turn.
 
 ## License
 
diff --git a/plugins/antianqi/mmx-octopus/README.zh-CN.md b/plugins/antianqi/mmx-octopus/README.zh-CN.md
index 64e5b78f..d02179ee 100644
--- a/plugins/antianqi/mmx-octopus/README.zh-CN.md
+++ b/plugins/antianqi/mmx-octopus/README.zh-CN.md
@@ -4,7 +4,7 @@
 
 English | [简体中文](README.zh-CN.md)
 
-作者：[antianqi](https://github.com/antianqi) · 版本：`1.8.0` ·
+作者：[antianqi](https://github.com/antianqi) · 版本：`1.9.0` ·
 插件 ID：`mmx-octopus` · 分类：`Productivity`
 
 ## 它做什么
@@ -19,6 +19,11 @@ English | [简体中文](README.zh-CN.md)
 - **她写日记。** 面板里的日记本写的是她自己的独白，和聊天记录分开存，她自己写。
 - **Agent 能指挥她。** 这个包自带一个 MCP 服务器，四个工具（见下），
   Agent 可以让她说话、换表情、挪位置、读她的状态。
+- **她也可以用自己的 agent 回答 —— 但那个 agent 得你自己建。** 插件不会替你建 agent，
+  也不会往宿主写 agent 文件。想让她有自己的 agent：打开面板（设置 →「想要更鲜明的性格？」），
+  点 **「复制她的设定」**，她的设定正文会进你的剪贴板；到 MiniMax Code 的 Agent 设置里
+  新建一个叫 `mmx` 的 agent，把设定粘进去保存，插件就会自己认出它（只读）并用它回答。
+  不建也行：她用默认 agent 回答，设定每轮随消息带。
 - **她不挡路。** 浮窗无边框、透明、置顶、鼠标穿透，永远不挡住桌面。
   尺寸 220 × 460，可以拖到屏幕任意位置；Agent 也能把它停到四个固定位之一（三个角 + 屏幕中间）。
 - **怎么再找到她。** 浮窗是鼠标穿透的，所以它不会吞掉你的点击：把指针移到她身上，
@@ -49,6 +54,7 @@ English | [简体中文](README.zh-CN.md)
 2. 把它拖到某个角，或者让 Agent 用 `mmx_move` 挪。
 3. 照常跟 Agent 说话，看她的表情跟着走。
 4. 打开面板跟她说话 —— 她在自己的会话里回答。
+5. （可选）给她一个自己的 agent —— 在面板里复制她的设定，粘到新建的 `mmx` agent 里（见「它做什么」）。
 
 ### Agent 的四个工具
 
@@ -86,60 +92,47 @@ English | [简体中文](README.zh-CN.md)
 
 - **读什么** —— 读这个包自己的文件，从 `context.pluginRoot` 读：
   `miniapp/node/identity/AGENTS.md` 和 `miniapp/node/identity/STORY.md`（她是谁），
-  以及 `miniapp/client/` 下的页面素材。
-- **写什么** —— `context.dataDir` 下四个 JSON 文件，也就是宿主给这个包建的私有目录：
+  以及 `miniapp/client/` 下的页面素材；还读宿主列出来的 agent 列表 ——
+  **只读**，用来决定由哪个 agent 回答她。
+- **写什么** —— `context.dataDir` 下四个 JSON 文件，也就是宿主给这个包建的私有目录，
+  **这个目录之外它一个字节都不写**：
   `context.dataDir/state.json`（她的表情、位置、气泡，以及 Agent 忙不忙），
   `context.dataDir/chat.json`（你和她的聊天），
   `context.dataDir/diary.json`（她的日记）、`context.dataDir/style.json`（她学到的语气）。
   每次落盘都是原子的 —— 先写同目录临时文件，再改名 —— 所以崩了也不会留下半个文件。
-- **`context.dataDir` 之外最多新增一个 agent 文件（1.8.0 起）** —— **默认新增**：面板上有一组
-  二选一（「她用哪个 agent」），**默认是「建专属 agent」** ⇒ 运行时会在**宿主的 agent 目录里新增一个
-  属于自己的 agent**，好让她的设定能待在那个 agent 的 system prompt 里，不只活在消息里
-  （这样她的性格更鲜明、回复更拟人）。
-  **你随时能切回「用现有 agent」** ⇒ 那一档插件**一个字节都不往宿主目录写**，她的设定只随消息带。
-  这一档**在第一次运行时就问**：首启那张卡片里先选「建专属 agent」还是「用现有 agent」，
-  再选她叫什么、她怎么称呼你；之后随时能在设置里改。  完整披露：
-  - **写哪个文件** —— 只有一个：`<宿主的 agent 目录>/mmx-octopus-agent/agent.md`。
-    目录和文件都是**新建的**，宿主**不用重启**就能认到它。
-  - **里面写什么** —— 就是插件本来每轮随消息送的那份设定（她是谁 / 她长什么样 / 她的规矩），
-    外加宿主要的 frontmatter（`name` / `description` / `displayName`）。
-  - **哪些绝不碰** —— **不改任何已有的 agent，也不写别的文件**：不改你的 agent 的 `agent.md`，
-    不写 agent 工作区里的 `AGENTS.md`，不碰你的项目文件。要是 `mmx-octopus-agent` 这个名字
-    已经被别的 agent 占了，插件就**什么都不写、也不用它** —— 她照样用现有 agent 说话
-    （那个别人的 agent 不会被当成我们自己的用）。
-  - **怎么写** —— 原子写（先写临时文件再改名），一次只写一个，而且**只在文件不存在时**写：
-    已存在的文件绝不覆盖 ⇒ 没有需要备份的旧文件。
-  - **怎么移除它 / 怎么拿到新版本** —— 这个文件**永远不会被就地改写**，所以升级插件之后，
-    里面还是旧的那份设定。删掉 `<宿主的 agent 目录>/mmx-octopus-agent/` 整个目录，
-    下次启动它会按当前版本的设定重新加上。想彻底不要这个 agent：面板上选「用现有 agent」，
-    插件就不碰它了 —— 只要不切回「建专属 agent」，删掉的目录不会被重建。
-    别的什么都不受影响。
-  - **这个目录怎么找 —— 绝不靠猜** —— **只从插件自己建的那个会话的工作目录**认：宿主把那个会话的
-    工作目录设成「Mini App 自己的 Agent 目录」（`<宿主的 agent 目录>/<agent>/miniapps/<plugin-id>`），
-    插件取它的上一层。**不会**在文件系统里上溯找名为 `agents` 的目录（你的项目里正好有一层
-    叫 `agents` 的话，文件就会落进你的项目），**也不会**从 `context.dataDir` 反推。认不出来就
-    **一个字节都不写**，退回「每轮随消息带设定」的老路，一切照旧。
-  - **它自己那个会话** —— 为了问出这个路径，插件可能会通过宿主的 Agent API 建一个会话。
-    这种会话归插件自己，**不会出现在你的聊天列表里**；而且插件会把它**复用成她的会话**，
-    不再另建一个。
+- **`context.dataDir` 之外不写任何文件（1.9.0 起）** —— 运行时**再也不新建任何文件**：
+  不建 agent 文件，不往宿主的 agent 目录写，不碰你的项目。它碰到的文件只有上面
+  那四个 JSON。
+  - **面板上那个二选一没了。** 1.8.0 面板上的「她用哪个 agent」（「建专属 agent」/
+    「用现有 agent」）已经去掉，随它一起去的还有那条手动命令 `agentprov-cli.mjs`，
+    没有什么可切的了。
+  - **你自己那个 `mmx` agent，得你建。** 面板上的 **「复制她的设定」** 只是把她的设定正文
+    交给你（一个字节都不写盘），你把它粘到 Agent 设置里新建的 `mmx` agent 上；插件之后
+    通过宿主的 agent 列表**认出来**并用它回答，全程只读。建、改、删都是你的事。
+  - **agent 列表它还是会读 —— 只读。** 插件读宿主列出来的 agent 列表；如果你自己
+    建过一个叫 `mmx` 的 agent，她就用那个来回答。**你的 agent 不会被改，也不会被写**；
+    没有 `mmx` agent 就退回默认 agent。
+  - **她的设定随消息带。** 没有专属 agent 替她存着这份底稿了，她的身份（她是谁 /
+    她长什么样 / 她的规矩）就每一轮随消息带进会话 —— 见下面「她的身份怎么送到她那儿」。
 - **老版本留下的东西** —— 1.7.0 之前的版本会把一份 `AGENTS.md` 写进「装了本插件的那个 agent」
   的工作区，用来把她的身份放在那儿。**现在不再写了，也不再需要它**。从老版本升级的话，
   那份文件可能还在（`agents/<agent>/miniapps/<plugin-id>/AGENTS.md`），可以直接删 ——
-  运行时不会去动它：**插件不许写自己 dataDir 之外的文件**。
-- **她的身份怎么送到她那儿** —— **两条腿走**。她的底稿、样子和规矩从本包自己的
+  运行时不会去动它：**插件不许写自己 dataDir 之外的文件**。1.8.0 那次可能留下的
+  agent 目录，见下面「从 1.8.0 升级」。
+- **她的身份怎么送到她那儿** —— **每一轮随消息带（弱通道）**。她的底稿、样子和规矩从本包自己的
   `miniapp/node/identity/AGENTS.md` 读出来，拼进每次的提示词里，所以每一轮都带着它。
   ⚠️ 代价：这一份走的是会话历史 ⇒ 宿主做上下文压缩时可能把它压掉（所以每轮都重发一份）。
-  1.8.0 起，**你在面板上选了「建专属 agent」之后**，同样一份设定也写进了上面那个新增 agent
-  的 system prompt（压缩压不掉）；万一那个文件写不成，每轮随消息带的那份照样在，你什么都不用管。
+  1.9.0 起这就是**唯一**一条路：不再往任何 agent 文件里写她的底稿了，每轮随消息带的
+  那份就是唯一的一份。
 - **读哪些会话** —— 这个包声明了 `session.read`。它读一轮对话的标题、运行状态和最终回复，
   用来分辨 Agent 是在想还是做完了，也用来给这一轮做摘要。面板里的看板列出正在跑的会话，
   每 30 秒刷新一次。
 - **会跑哪些 Agent 轮次** —— 它声明了 `session.run`，并且**你在聊天区给她发的每一句话，
   都在她自己的会话里跑一轮 Agent**。这一轮走宿主的 Agent，因此带着宿主给那个 agent 的权限；
-  它会读宿主的 agent 列表，找有没有专属于这个 Mini App 的 agent ——
-  **默认档（「建专属 agent」）优先用插件自己新增的那个**（见上面），它没有才用你的 `mmx`；
-  都没有就退回默认 agent。你在面板上选了「用现有 agent」的话，就只用你自己那个 `mmx`（没有就退回默认 agent），
-  插件新增的那个**一次都不碰**。它不会去跑你自己的会话。- **它自己会起的那些轮次** —— 除了你发的消息，运行时还会自己起几轮，**每一轮都花你的模型额度**：
+  它会读宿主的 agent 列表；如果你自己有一个叫 `mmx` 的 agent，就用它来回答
+  （**只读，不会改你的 agent**）；没有 `mmx` agent 就退回默认 agent。
+  它不会去跑你自己的会话。
+- **它自己会起的那些轮次** —— 除了你发的消息，运行时还会自己起几轮，**每一轮都花你的模型额度**：
   - **闲话**：**默认关着**，要她主动开口自己在面板里开：设置 → 「她没人的时候自己说话」。
     开了以后，你安静 20 分钟后她可能自己开口；一小时最多 2 轮，两轮之间至少隔 45 分钟。
     **同一个开关也能再关掉**。
@@ -160,12 +153,33 @@ English | [简体中文](README.zh-CN.md)
 - **麦克风** —— 从不。这个包没有声明 `deviceAccess`，也不申请任何浏览器权限。
 - **状态放在哪** —— `context.dataDir`。把它当成不透明路径：版本之间可能变，别写死。
 
+### 从 1.8.0 升级
+
+1.9.0 改的是插件和宿主 agent 的关系，不只是一个版本号：**它不再创建任何 agent 文件**，
+面板上的「建专属 agent / 用现有 agent」二选一，以及跟着它的手动命令 `agentprov-cli.mjs`，
+一并没了。
+
+- **如果你用过 1.8.0** 并让它建了专属 agent，宿主的数据目录里可能还残留
+  `<宿主数据目录>/agents/mmx-octopus-agent/` 目录，**可以手动删掉** ——
+  里面的东西已经用不上了。
+- **1.9.0 不会再创建它，也不会再去碰它。** 它只写 `context.dataDir` 下那四个 JSON。
+- **你自己那个 `mmx` agent 照旧优先。** 你要是有叫 `mmx` 的 agent，她就用它来回答 ——
+  **只读**，插件不会改它。
+- **1.9.0 还多给了你一份设定。** 面板上的 **「复制她的设定」** 会把她的设定正文给你，
+  你可以自己建一个叫 `mmx` 的 agent 把她放进去 —— 插件不再替你建，只负责认。
+
+- **如果你保存的状态里还指着那个老 agent，1.9.0 会忽略它。** 1.8.0 可能把
+  `mmx-octopus-agent` 记在插件的状态文件里；1.9.0 加载时会把这个名字丢掉 ⇒
+  你自己建了 `mmx` 就用它，没有就用宿主的默认 agent。
+
 ## 已知限制
 
 - 界面只有中文。
 - 没有语音：气泡就是文字。
 - 身体动画只覆盖片子里有的那些瞬间；片子之间跑的是 `pose` 兜底。
 - 她用宿主给她解析到的那个 agent 回答。
+- 没有你自己建的 `mmx` agent 时，她的设定就走「每轮随消息带」这条路，
+  而宿主做上下文压缩时可能把它压掉（所以每轮都重发一份）。
 
 ## 许可证
 
diff --git a/plugins/antianqi/mmx-octopus/miniapp/client/index.html b/plugins/antianqi/mmx-octopus/miniapp/client/index.html
index 96c81721..6d61cf4a 100644
--- a/plugins/antianqi/mmx-octopus/miniapp/client/index.html
+++ b/plugins/antianqi/mmx-octopus/miniapp/client/index.html
@@ -10,7 +10,6 @@
     <script id="mmx-segments"></script>
     <!-- 帧契约占位：服务端在启动时把 chat-protocol.mjs 的帧类型清单注入这里 -->
     <script id="mmx-chat-protocol"></script>
-    <script id="mmx-agent-mode"></script>
     <style>
       :root,
       [data-theme='light'] {
@@ -1911,27 +1910,23 @@
             <p class="set-note" id="naming-note">名字和称呼都是你的设定，改了她下一轮就知道。</p>
           </section>
 
-          <!-- ★ **「她用哪个 agent」**（上游评审 Optional #3：给用户一个自己决定的入口）——
-               默认「专属 agent」（老板 2026-11-04 拍板：体验感最好，也是主线方向）；
-               选「用现有 agent」那一档 ⇒ 插件**不往宿主目录写任何文件**。 -->
+          <!-- ★ **「复制她的设定」**（官方插件市场 1.8.0 拒收 → 官方给的改法 B）：
+               插件**不写宿主任何文件** ⇒ 想让她的性格更鲜明，得由**你自己**建一个
+               名为 mmx 的 agent 并把设定贴进去；插件只负责**认出来**并用它。 -->
           <section class="set-group">
-            <span class="set-title">她用哪个 agent</span>
-            <div class="seg" role="group" aria-label="用哪个 agent" id="agentmode-group" data-agentmode-group>
-              <button type="button" data-agentmode="own" aria-pressed="true">专属 agent</button>
-              <button type="button" data-agentmode="existing" aria-pressed="false">现有 agent</button>
-            </div>
-            <p class="set-note" id="agentmode-note">
-              <b>专属 agent</b>（默认）—— 给她建一个只属于她的 agent，她的设定写进它的
-              system prompt：性格更鲜明、回复更拟人；代价是它从零开始，没有你现有 agent
-              攒下的经验。
-              <br />
-              <b>现有 agent</b> —— 用你现在这个 agent：更偏助理，认得你之前的经验，
-              帮你干活的工具和上下文都是现成的；代价是她的性格只能每轮随消息带，
-              宿主压缩上下文时可能被压掉，插件也**不往宿主目录写任何文件**。
+            <span class="set-title">想要更鲜明的性格？</span>
+            <p class="set-note">
+              插件不会往你的宿主目录写任何文件。你可以自己建一个叫 <b>mmx</b> 的 agent，
+              把她的设定贴进去 —— 她就会用那个 agent 回答，性格更鲜明
+              （代价是从零开始，没有你现有 agent 攒下的经验）。
               <br />
-              换档会重开她的会话（聊天记录留着）。
+              做法：复制她的设定 → 打开 MiniMax Code 的 Agent 设置 → 新建一个名为 <b>mmx</b>
+              的 agent → 粘贴保存。建不建都行：不建她就按「每轮随消息带」的方式跟你说话。
             </p>
-            <p class="set-note" id="agentmode-status" style="display:none"></p>
+            <div class="set-actions">
+              <button type="button" id="agent-card-copy">复制她的设定</button>
+            </div>
+            <p class="set-note" id="agent-card-status" style="display:none"></p>
           </section>
 
           <section class="set-group">
@@ -2065,19 +2060,7 @@
     <div class="naming-ask" id="naming-ask" hidden role="dialog" aria-modal="true" aria-labelledby="naming-ask-title">
       <div class="naming-card">
         <h3 id="naming-ask-title">先认识一下</h3>
-        <p>先定她用哪个 agent，再告诉她叫什么、她怎么称呼你。随时能在设置里改。</p>
-        <div class="set-group">
-          <span class="set-title">她用哪个 agent</span>
-          <div class="seg" role="group" aria-label="用哪个 agent" id="naming-agentmode-group" data-agentmode-group>
-            <button type="button" data-agentmode="own" aria-pressed="true">专属 agent</button>
-            <button type="button" data-agentmode="existing" aria-pressed="false">现有 agent</button>
-          </div>
-          <p class="set-note">
-            <b>专属 agent</b>（默认）—— 给她建一个只属于她的 agent，性格更鲜明、回复更拟人
-            （从零开始，没有积累）；<b>现有 agent</b> —— 用你现成的那个，更偏助理，
-            能用上你之前的经验与工具上下文。
-          </p>
-        </div>
+        <p>先告诉她叫什么、她怎么称呼你。随时能在设置里改。</p>
         <label class="set-field">
           <span>她的名字</span>
           <input id="naming-ask-her" type="text" maxlength="24" placeholder="MMX" />
@@ -3177,8 +3160,6 @@ <h3 id="naming-ask-title">先认识一下</h3>
           if (el.namingAsk.hidden === false) return;
           el.namingAskHer.value = state.naming && state.naming.herName ? state.naming.herName : '';
           el.namingAskUser.value = state.naming && state.naming.userTitle ? state.naming.userTitle : '';
-          // 首启就把「她用哪个 agent」摆出来，并按当前档位预选（默认＝专属 agent）。
-          paintAgentMode(normalizeAgentMode(state.agentMode));
           el.namingAsk.hidden = false;
           try {
             el.namingAskHer.focus();
@@ -3194,80 +3175,73 @@ <h3 id="naming-ask-title">先认识一下</h3>
         }
 
         /**
-         * 把任意输入归一成合法档位（**页面侧默认归一的唯一实现**）。
-         *
-         * ⚠️ **默认档来自服务端注入的 window.__MMX_AGENT_MODE__.default**
-         *   （真源在 node/agentpick.mjs）—— 页面里**不许自己写默认值**，
-         *   否则服务端改了默认、页面还按老的画 ⇒ 两边对不上。
-         *   注入读不到时兜底成 'own'（与服务端默认值一致）。
-         *
-         * @param {unknown} mode
-         * @returns {string} 'own' | 'existing'
-         */
-        function normalizeAgentMode(mode) {
-          var cfg = window.__MMX_AGENT_MODE__;
-          var fallback = cfg && cfg.default === 'existing' ? 'existing' : 'own';
-          return mode === 'existing' ? 'existing' : fallback;
-        }
-
-        /**
-         * 把「她用哪个 agent」的档位画到二选一上。
-         *
-         * ⚠️ **同一判断只写一处**（老板 2026-11-04 把这个选择搬到首启卡片，
-         *   于是同一个二选一出现在两个地方）：设置区与首启卡片都带
-         *   `data-agentmode-group`，两处共用这一个选择器 —— 谁多画一处、
-         *   谁少画一处都会漂。
+         * 把一段文本放进剪贴板（优先用 Clipboard API，不行就走老路）。
          *
-         * @param {string} mode 'own' | 'existing'
-         * @param {string} [skipGroupId] 这一处**先别画**（首启卡片开着的时候，
-         *   用户正在挑的那一档不能被快照回灌冲掉）
+         * @param {string} text
+         * @returns {Promise<boolean>}
          */
-        function paintAgentMode(mode, skipGroupId) {
-          var wanted = normalizeAgentMode(mode);
-          var buttons = document.querySelectorAll('[data-agentmode-group] button[data-agentmode]');
-          for (var i = 0; i < buttons.length; i++) {
-            if (skipGroupId && buttons[i].closest('#' + skipGroupId)) continue;
-            buttons[i].setAttribute(
-              'aria-pressed',
-              buttons[i].getAttribute('data-agentmode') === wanted ? 'true' : 'false'
-            );
+        function copyTextToClipboard(text) {
+          if (navigator.clipboard && navigator.clipboard.writeText) {
+            return navigator.clipboard.writeText(text)
+              .then(function () { return true; })
+              .catch(function () { return legacyCopyText(text); });
           }
+          return Promise.resolve(legacyCopyText(text));
         }
 
         /**
-         * 读某个二选一当前选中的档位。
-         * @param {string} groupId
-         * @returns {string} 'own' | 'existing'
+         * 老办法复制（Clipboard API 不可用时的兜底）。
+         * @param {string} text
+         * @returns {boolean}
          */
-        function readAgentMode(groupId) {
-          var group = document.getElementById(groupId);
-          if (!group) return normalizeAgentMode(null);
-          var picked = group.querySelector('button[aria-pressed="true"]');
-          var value = picked ? picked.getAttribute('data-agentmode') : '';
-          return normalizeAgentMode(value);
+        function legacyCopyText(text) {
+          var area = document.createElement('textarea');
+          area.value = text;
+          area.setAttribute('readonly', '');
+          area.style.position = 'fixed';
+          area.style.left = '-9999px';
+          document.body.appendChild(area);
+          area.select();
+          var ok = false;
+          try {
+            ok = document.execCommand('copy');
+          } catch (error) {
+            ok = false;
+          }
+          document.body.removeChild(area);
+          return ok;
         }
 
         /**
-         * 首启卡片提交：名字 + 称呼 + **她用哪个 agent**。
-         *
-         * ⭐ **老板 2026-11-04 拍板**：「这个设置最好在第一次运行的时候就有一个选择。
-         *   选择用新建agent还是现有agent，之后选择叫什么，怎么称呼你」
-         *   ⇒ 二选一跟「叫什么 / 怎么称呼你」**同一次提交**送出去。
+         * 「复制她的设定」—— 官方改法 B：引导用户自己建 mmx agent，插件只负责识别。
          *
-         * @param {string} herName
-         * @param {string} userTitle
+         * ⚠️ **插件不写宿主任何文件** —— 这一步只是把设定正文交给用户，
+         *   由用户自己在 Agent 设置里建 agent 并粘贴。
          */
-        function saveNamingWithMode(herName, userTitle) {
-          var wanted = readAgentMode('naming-agentmode-group');
-          var current = normalizeAgentMode(state.agentMode);
-          saveNaming(herName, userTitle, true);
-          if (wanted === current) return;
-          post('/api/agent-mode', { mode: wanted })
+        function copyAgentCard() {
+          post('/api/agent-card', {})
             .then(function (data) {
-              if (data.snapshot) render(data.snapshot);
+              var text = String(data.body || '');
+              if (!text) throw new Error('没拿到设定正文');
+              return copyTextToClipboard(text).then(function (ok) {
+                var status = document.getElementById('agent-card-status');
+                if (status) {
+                  var hint = data.found
+                    ? '已经找到你自己建的 mmx agent —— 她现在用它回答。'
+                    : '还没找到叫 mmx 的 agent；建好之后她会自动用它。';
+                  status.textContent = (ok ? '设定已复制。' : '复制失败，请手动复制。') + hint;
+                  status.style.display = '';
+                }
+                toast(
+                  ok
+                    ? '设定已复制 —— 去 Agent 设置里建一个叫 mmx 的 agent，粘贴进去'
+                    : '复制失败，请手动复制',
+                  ok ? '' : 'error'
+                );
+              });
             })
             .catch(function (error) {
-              toast('切换 agent 失败：' + error.message, 'error');
+              toast('拿不到她的设定：' + error.message, 'error');
             });
         }
 
@@ -3480,20 +3454,6 @@ <h3 id="naming-ask-title">先认识一下</h3>
                 : 'false'
             );
           }
-          // 「她用哪个 agent」—— 默认「专属 agent」（老板 2026-11-04 拍板：体验感最好、也是主线方向；
-          // 选「用现有 agent」那一档 ⇒ 插件不往宿主目录写任何文件）
-          // ⚠️ **设置区与首启卡片共用这一处渲染**（同一判断只写一处）：
-          //   两处都带 data-agentmode-group ⇒ 一个选择器画全部，不会各画各的。
-          state.agentMode = normalizeAgentMode(snapshot.agentMode);
-          // 首启卡片开着的时候**别冲掉**用户正在挑的那一档（快照回灌不该改他的本地选择）。
-          paintAgentMode(state.agentMode, el.namingAsk && !el.namingAsk.hidden ? 'naming-agentmode-group' : '');
-          var modeStatus = document.getElementById('agentmode-status');
-          if (modeStatus) {
-            var statusText = snapshot.agentStatus || '';
-            modeStatus.textContent = statusText;
-            modeStatus.style.display = statusText ? '' : 'none';
-          }
-
           // 诊断与看板
           renderTracking(snapshot);
           renderBoard(state.board);
@@ -4671,13 +4631,13 @@ <h3 id="naming-ask-title">先认识一下</h3>
           state.namingDirty.user = true;
         });
         el.namingAskSave.addEventListener('click', function () {
-          saveNamingWithMode(el.namingAskHer.value, el.namingAskUser.value);
+          saveNaming(el.namingAskHer.value, el.namingAskUser.value, true);
         });
         // 「先跳过」= 不想给称呼 —— 存成默认名 + 空称呼，
         // 这样 configured=true，首启卡片不再弹，但她以后还能在设置里补上。
         // ⚠️ **但他在卡片上挑过的那一档照样生效**（挑了就不该被丢掉）。
         el.namingAskSkip.addEventListener('click', function () {
-          saveNamingWithMode(el.namingAskHer.value || '', '');
+          saveNaming(el.namingAskHer.value || '', '', true);
         });
 
         document.getElementById('chat-reset').addEventListener('click', function () {
@@ -4866,32 +4826,15 @@ <h3 id="naming-ask-title">先认识一下</h3>
             });
         });
 
-        // ★ **首启卡片上的那组二选一**：**只改本地选中**，随卡片一起提交
-        //   （不立刻发请求 —— 首启这一次的提交是「名字 + 称呼 + 这一档」一起走）。
-        var namingModeGroup = document.getElementById('naming-agentmode-group');
-        if (namingModeGroup) {
-          namingModeGroup.addEventListener('click', function (event) {
-            var button = event.target.closest('button[data-agentmode]');
-            if (!button) return;
-            paintAgentMode(button.getAttribute('data-agentmode'));
+        // ★ **「复制她的设定」**（官方改法 B）：只把设定正文交给用户，
+        //   由用户自己在 Agent 设置里建 agent 并粘贴；插件全程不写宿主文件。
+        var agentCardCopyBtn = document.getElementById('agent-card-copy');
+        if (agentCardCopyBtn) {
+          agentCardCopyBtn.addEventListener('click', function () {
+            copyAgentCard();
           });
         }
 
-        // ★ **「她用哪个 agent」**（上游评审 Optional #3）
-        document.getElementById('agentmode-group').addEventListener('click', function (event) {
-          var button = event.target.closest('button[data-agentmode]');
-          if (!button) return;
-          var next = button.getAttribute('data-agentmode');
-          post('/api/agent-mode', { mode: next })
-            .then(function (data) {
-              if (data.snapshot) render(data.snapshot);
-              toast(next === 'own' ? '她用专属 agent' : '她用现有 agent');
-            })
-            .catch(function (error) {
-              toast('切换失败：' + error.message, 'error');
-            });
-        });
-
         document.getElementById('scope-group').addEventListener('click', function (event) {
           var button = event.target.closest('button[data-scope]');
           if (!button) return;
diff --git a/plugins/antianqi/mmx-octopus/miniapp/node/agentcard.mjs b/plugins/antianqi/mmx-octopus/miniapp/node/agentcard.mjs
new file mode 100644
index 00000000..e156930f
--- /dev/null
+++ b/plugins/antianqi/mmx-octopus/miniapp/node/agentcard.mjs
@@ -0,0 +1,85 @@
+// @ts-check
+
+/**
+ * 渲染「交给用户自己粘贴的 agent 设定正文」。
+ *
+ * ⭐ **为什么需要它**（官方插件市场拒收 1.8.0 → 官方给的改法 B，2026-11-09）：
+ *   插件**全程不写宿主任何文件** ⇒ 想留住「专属 agent」这个体验，
+ *   只能由**用户自己**建 agent、自己粘贴设定；插件只负责**认出来**并用它。
+ *   要能引导，就得先把那份设定正文交出来 —— 就是这个模块的活。
+ *
+ * ⚠️ **纯函数**：只拼字符串。它**不写**任何文件
+ *   （读身份层在 identity.mjs；**这里绝对没有写盘** —— 判据第四十九轮盯着这一点）。
+ *
+ * ⚠️ **同一个判断只写一处**：agent 叫什么，只有 agentpick.mjs 说了算
+ *   （这里 import 它的 PET_AGENT_NAME，不另写一份）。
+ *
+ * @module miniapp/node/agentcard
+ */
+
+import { readIdentitySections, readPersonaBody } from './identity.mjs';
+import { PET_AGENT_NAME } from './agentpick.mjs';
+
+/** 用户自己建那个 agent 时该用的名字（真源在 agentpick.mjs，这里只引用）。 */
+export const AGENT_CARD_NAME = PET_AGENT_NAME;
+
+/** 宿主 agent 列表里的显示名（用户可以在自己的 Agent 设置里改成别的）。 */
+export const AGENT_CARD_DISPLAY_NAME = '章鱼娘';
+
+/** 宿主 agent 列表里的说明。 */
+export const AGENT_CARD_DESCRIPTION = '桌面上的章鱼娘（她自己那个专属 agent）';
+
+/** 写进正文里的标记 —— 方便认出「这份设定来自这个插件」。 */
+export const AGENT_CARD_MARK = '<!-- mmx-octopus:agent-card -->';
+
+/**
+ * 渲染 agent 设定正文（纯函数）。
+ *
+ * ⚠️ frontmatter 只用宿主认识的字段（name / description / x-mavis.displayName）：
+ *   宿主解析器会拒掉不认识的字段，写错 = agent 认不出来。
+ *
+ * @param {{persona?: string, identity?: {baseline?: string, appearance?: string, rules?: string},
+ *   name?: string, displayName?: string, description?: string}} input
+ * @returns {string}
+ */
+export function renderAgentCard(input) {
+  const name = String(input?.name || AGENT_CARD_NAME);
+  const displayName = String(input?.displayName || AGENT_CARD_DISPLAY_NAME);
+  const description = String(input?.description || AGENT_CARD_DESCRIPTION);
+  const persona = String(input?.persona ?? '').trim();
+  const identity = input?.identity || {};
+  const parts = [
+    '---',
+    'name: ' + name,
+    'description: ' + description,
+    'x-mavis:',
+    '  displayName: ' + displayName,
+    '---',
+    '',
+    AGENT_CARD_MARK,
+    '',
+  ];
+  if (persona) parts.push(persona, '');
+  const baseline = String(identity.baseline ?? '').trim();
+  const appearance = String(identity.appearance ?? '').trim();
+  const rules = String(identity.rules ?? '').trim();
+  if (baseline) parts.push('# 她是谁', '', baseline, '');
+  if (appearance) parts.push('# 她长什么样', '', appearance, '');
+  if (rules) parts.push('# 她的规矩', '', rules, '');
+  return parts.join('\n').trimEnd() + '\n';
+}
+
+/**
+ * 取这份设定正文（读包内的身份层三段 + 人格正文）。
+ *
+ * ⚠️ **只读**：读的是插件自己包里的文件（identity/AGENTS.md、identity/PERSONA.md），
+ *   不碰宿主任何文件，**也不写任何文件**。
+ *
+ * @param {string} pluginRoot
+ * @returns {Promise<string>}
+ */
+export async function buildAgentCard(pluginRoot) {
+  const persona = await readPersonaBody(pluginRoot);
+  const identity = await readIdentitySections(pluginRoot);
+  return renderAgentCard({ persona, identity });
+}
diff --git a/plugins/antianqi/mmx-octopus/miniapp/node/agentpick.mjs b/plugins/antianqi/mmx-octopus/miniapp/node/agentpick.mjs
index de7a70fb..cef35616 100644
--- a/plugins/antianqi/mmx-octopus/miniapp/node/agentpick.mjs
+++ b/plugins/antianqi/mmx-octopus/miniapp/node/agentpick.mjs
@@ -3,95 +3,51 @@
 /**
  * 她的会话该挂在哪个 agent 上（纯决策）。
  *
- * ⭐ **为什么这件事要单独成模块**：
- * 「**现在最主要的问题是调用了错误的agent文件**」。
- * 查下来的事实：她的会话一直挂在**默认 agent（primary = mavis）**上，
- * 于是她的 **system prompt 是 Mavis 的**（"You are Mavis… a coding agent…"），
- * 而「她是谁 / 她长什么样 / 她的规矩」只是工作区里的 `AGENTS.md`（项目级说明）。
- * **权重打架时 system prompt 赢** ⇒ 老板一句「最早啊」，她就照 Mavis 的模式去查数据。
+ * ⚠️ **v1.9.0：插件不再往宿主目录写任何文件。**
+ *   官方插件市场拒绝 1.8.0 的理由：1.8.0 默认会往宿主内部的 agent 目录新增一个
+ *   agent.md —— 越出了插件自己的数据目录，用户没明确同意就多出一个 agent，
+ *   卸载后也不会清理。v1.9.0 把那条能力**整个删掉**（不是改成默认关闭）。
  *
- * 修法不是削工具（老板明说「可以有权限」），而是**让她的 agent 文件讲她是谁**。
+ * 现在这一层只做一件**只读**的事：宿主里有没有一个叫 mmx 的 agent
+ * （用户自己建的那个），有就优先用它，没有就用默认 agent。
  *
- * ⚠️ **可推广性**：专属 agent 是**用户配置**的 —— 别人装了我们的 Mini App，
- * `agents()` 里没有「mmx」⇒ `create({agent:'mmx'})` 直接 INVALID_ARGUMENTS。
- * 所以要**先探测再用**，探测不到就退回默认 agent（= 之前的行为）。
- *
- * 纯函数放这里，是为了让自检能**真的跑函数行为**（而不是读源码猜），
- * 并且能用「传坏参数」做负向注入。
+ * ⚠️ **同一判断只写一处**：状态机、服务端路由都走这里。
  */
 
-/** 她的专属 agent 名（用户自己建的那个 —— 老板机器上就有这个名字）。 */
+/** 用户自己建的专属 agent 名（**只读**：插件只是认出它，不创建、不修改、不删除）。 */
 export const PET_AGENT_NAME = 'mmx';
 
 /**
- * 我们自己新增的那个专属 agent 名（v1.8.0）。
- *
- * ⭐ **agent 名字的真源就在这个纯模块里**（agentpick.mjs 不依赖任何东西）——
- *   `agentprov.mjs` 从这里取，两边不许各写一份。
- */
-export const SELF_AGENT_NAME = 'mmx-octopus-agent';
-
-/**
- * 产品默认档（**唯一真源**）。
+ * v1.8.0 时代插件自动创建的那个 agent 名（**历史遗留**）。
  *
- * ⭐ **老板 2026-11-04 拍板**：「默认是用专属agent，这样体验感才最好，也是我们主要的方向，
- *   但是需要给用户一个选择的余地」⇒ **默认 = 建专属 agent**，用户随时能切回「用现有 agent」。
+ * 那个 agent 是 1.8.0 自己建的 —— 用户没点头就会多出来，卸载后也不清理 ⇒
+ * 官方插件市场拒收了 1.8.0。1.9.0 起插件既不建它、也不碰它。
  *
- * ⚠️ **只有这一处写默认值** —— 状态机、服务端路由、客户端面板的默认归一都从这里取，
- *   不许各写各的（写散了下次改默认就会漏）。
+ * ⚠️ **用途只有一个**：加载 state 时把 1.8.0 留在 `state.json` 里的
+ *   `petAgent: "mmx-octopus-agent"` 丢掉 —— 不丢的话，老用户升级后她的会话
+ *   仍会挂在那个 agent 上，与「1.9.0 不再碰它」对不上
+ *   （官方评审 2026-11-09 在 PR #119 上指出的问题）。
  *
- * @type {'own'|'existing'}
+ * agent 名字的真源在这一份文件里，别处不许再抄一遍。
  */
-export const DEFAULT_AGENT_MODE = 'own';
-
-/**
- * 把任意输入归一成合法档位（**默认归一的唯一实现**）。
- *
- * ⚠️ **只有明确是 'existing' 才降级**；别的值（空 / 乱值 / undefined）一律按**默认档**算
- *   —— 这样「默认值是什么」这件事**只由 DEFAULT_AGENT_MODE 说了算**。
- *
- * @param {unknown} mode
- * @returns {'own'|'existing'}
- */
-export function normalizeAgentMode(mode) {
-  return mode === 'existing' ? 'existing' : DEFAULT_AGENT_MODE;
-}
+export const LEGACY_SELF_AGENT_NAME = 'mmx-octopus-agent';
 
 /**
- * 决定这一轮用哪个 agent —— **用户在面板里选的那一档**决定。
+ * 决定这一轮用哪个 agent。
  *
  * 优先级：
- *   · 「用现有 agent」：**显式指定的** ＞ **用户自己的「mmx」** ＞ **空（默认 agent）**
- *     —— 我们新增的那个**不参与**（这一档就是「不新增、不使用」）。
- *   · 「建专属 agent」（**产品默认**）：**显式指定的** ＞ **我们新增的那个** ＞ **用户自己的「mmx」** ＞ **空**
- *     —— 用户明确选了它 ⇒ 就要它的性格，不迁就现有 agent。
+ *   · **显式指定的**（state.petAgent）＞ **用户自己的 mmx** ＞ **空（默认 agent）**
  *
- * ⚠️ **「用现有 agent」那一档里「用户自己的 mmx」优先于我们的**：老板机器上已经有那个 agent ⇒
- *   不新增、不改它、也不把会话挪走（零影响）。
+ * ⚠️ 插件**永远不新增 agent**（v1.9.0）：名字被别人占了也不碰、不用、不降级到它。
  *
- * @param {string[]} listedNames 宿主 `agents()` 列出来的 agent 名
- * @param {string|null|undefined} configured 用户显式指定的 agent 名（`state.petAgent`）
- * @param {string} [selfName] 我们自己新增的那个 agent 名（宿主里**确实列出来了**才用它）
- * @param {string} [mode] 'own' = 建专属 agent（**产品默认**）；'existing' = 用现有 agent
- *   （内部会先归一：只有明确 existing 才降级）
- * @param {boolean} [selfOwned] 我们那个 agent **确实是我们写的**吗？
- *   ⚠️ 名字被别人占了（name_taken）⇒ 我们**没建成** ⇒ 那个同名 agent 是**别人的**
- *   ⇒ 不能把它当成「我们那个」用（降级：继续用现有 agent）。
- *   传进来的 `selfName` 只是**名字**；**是不是我们的**由这条事实决定。
+ * @param {string[]} listedNames 宿主 agents() 列出来的 agent 名
+ * @param {string|null|undefined} configured 用户显式指定的 agent 名（state.petAgent）
  * @returns {string} '' = 不指定（用默认 agent）
  */
-export function pickPetAgent(listedNames, configured, selfName = '', mode = DEFAULT_AGENT_MODE, selfOwned = false) {
+export function pickPetAgent(listedNames, configured) {
   const explicit = configured ? String(configured) : '';
   if (explicit) return explicit;
   const names = Array.isArray(listedNames) ? listedNames.map((n) => String(n ?? '')) : [];
-  const self = String(selfName ?? '');
-  // ⭐ **档位先归一**（唯一实现）：只有明确 existing 才降级，别的值按默认档算。
-  const m = normalizeAgentMode(mode);
-  // 「建专属 agent」那一档：我们那个**排在自己的 mmx 前面**（用户明确选了它）。
-  // ⚠️ **但只有它确实是我们写的才用** —— 名字被别人占了 ⇒ 我们没建成 ⇒
-  //   那个同名 agent 是**别人的** ⇒ 绝不能把它当成「我们那个」用。
-  if (m === 'own' && selfOwned && self && names.includes(self)) return self;
-  // 「用现有 agent」那一档：我们那个**不参与**（不新增、不使用）。
   if (names.includes(PET_AGENT_NAME)) return PET_AGENT_NAME;
   return '';
 }
diff --git a/plugins/antianqi/mmx-octopus/miniapp/node/agentprov.mjs b/plugins/antianqi/mmx-octopus/miniapp/node/agentprov.mjs
deleted file mode 100644
index 2753585e..00000000
--- a/plugins/antianqi/mmx-octopus/miniapp/node/agentprov.mjs
+++ /dev/null
@@ -1,305 +0,0 @@
-// @ts-check
-
-/**
- * 给她**新增**一个专属 agent —— 只增不改、失败必降级。
- *
- * ⭐ **为什么需要它**：官方给 Mini App 的通道只有三条（托管 MCP / 输入框 message.append /
- *   Agent 会话 API），**没有「注入 system prompt」这一条**。身份层只能靠「每轮随消息带」
- *   （弱通道），而弱通道会被宿主压缩掉。
- *   官方答复：「可以写个脚本在 mcode 的 agent 配置中新增一个 agent；不修改已有的 agent 配置，
- *   新增应该没问题。」这个模块就是那件事 —— 在宿主 agent 目录里**新增**一个我们自己的 agent.md，
- *   之后她的会话挂在这个 agent 上 ⇒ 身份层进了 system prompt（强通道）。
- *
- * ⚠️ **三条硬底线**：
- *   ① 只**新增**一个目录 + 一个文件：<agents 根>/<agent 名>/agent.md；
- *   ② **绝不改**已有的 agent —— 名字被占（那个目录里已经有别人的 agent.md）就**不碰不用**，降级；
- *   ③ 定位 agent 根目录**只认一种能证明的形状**：我们自己用 Agent API 建的会话，
- *      它的**工作目录**是「Mini App 自己的 Agent 目录」
- *      = <agents 根>/<agent 名>/miniapps/<pluginId>，往上三层就是 agents 根。
- *      **不猜** —— 不从 dataDir 反推（宿主内部布局，反推=猜），
- *      也不「上溯找名为 agents 的目录」（用户项目里只要有一层目录叫 agents 就会被误认，
- *      等于往**用户的项目**里写文件）。拿不到根目录 ⇒ **一个字节都不写**（降级）。
- *
- * ⚠️ **失败必降级**：任何一步出错（拿不到根目录 / 名字被占 / 写失败 / 校验失败）
- *   都只是**返回失败**，不抛异常、不阻断她说话 —— 降级路径上身份层仍走随消息带（弱通道）。
- *
- * @module miniapp/node/agentprov
- */
-
-import { readFile, stat } from 'node:fs/promises';
-import { basename, dirname, join } from 'node:path';
-import { createWriteQueue, writeTextAtomic } from './atomic-json.mjs';
-import { readIdentitySections, readPersonaBody } from './identity.mjs';
-// ⭐ **agent 名字的真源在 agentpick.mjs**（纯模块、零依赖）—— 这边不许另写一份。
-import { PET_AGENT_NAME as LEGACY_AGENT_NAME, SELF_AGENT_NAME } from './agentpick.mjs';
-
-export { LEGACY_AGENT_NAME, SELF_AGENT_NAME };
-
-/** 我们写进 agent.md 的标记 —— 用来认出「这个文件是我们写的」。 */
-export const SELF_AGENT_MARK = '<!-- mmx-octopus:self-agent -->';
-
-/** 宿主自定义 agent 的 system prompt 文件名。 */
-export const SELF_AGENT_FILE = 'agent.md';
-
-/** 宿主 agent 列表里显示的名字（角色名，不跟着用户的改名走）。 */
-export const SELF_AGENT_DISPLAY_NAME = '小章鱼';
-
-/** agent 列表里的说明。 */
-export const SELF_AGENT_DESCRIPTION =
-  '桌面上的章鱼娘专属 agent（她的会话跑在这个 agent 上，身份层写在这个 agent 的文件里）';
-
-/** 同一个文件上的并发写排成一条链（社区规则：串行化并发写）。 */
-const writeQueue = createWriteQueue();
-
-/**
- * 这个字符串看起来像一条绝对路径吗？
- *
- * @param {string} value
- * @returns {boolean}
- */
-export function looksLikePath(value) {
-  const text = String(value ?? '');
-  if (text.length < 3) return false;
-  if (text.charAt(0) === '/') return true;
-  const isDrive = text.charCodeAt(1) === 58;
-  const sep = text.charAt(2);
-  return isDrive && (sep === '/' || sep === String.fromCharCode(92));
-}
-
-/**
- * 把一个值里所有像路径的字符串抠出来（深度有限，防跑飞）。
- *
- * @param {unknown} value
- * @param {number} [depth]
- * @param {string[]} [out]
- * @returns {string[]}
- */
-export function collectPathStrings(value, depth = 0, out = []) {
-  if (depth > 4 || value === null || value === undefined) return out;
-  if (typeof value === 'string') {
-    if (looksLikePath(value)) out.push(value);
-    return out;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) collectPathStrings(item, depth + 1, out);
-    return out;
-  }
-  if (typeof value === 'object') {
-    for (const key of Object.keys(value)) {
-      collectPathStrings(value[key], depth + 1, out);
-    }
-  }
-  return out;
-}
-
-/**
- * 从宿主给的路径里找 agent 根目录 —— **只认一种形状**。
- *
- *   <root>/<agent 名>/miniapps/<pluginId> —— Mini App 自己的 Agent 目录
- *   ⇒ root = 往上三层。
- *
- * ⭐ **为什么只有这一种**（上游评审 Must fix 1，2026-11-04）：
- *   官方规范（docs/miniapp/sessions.md）写明两种会话的工作目录不一样：
- *     · **Node 发起的会话** → 工作目录 =「Mini App 自己的 Agent 目录」= 上面这个形状；
- *     · **页面发起的会话** → 工作目录 =「该会话的项目目录」= **用户自己的项目**。
- *   所以只有**我们自己用 Agent API 建的会话**给的路径才能证明「这是宿主的 agents 根」。
- *
- * ⚠️ **上溯找名为 agents 的目录那种猜法已删**（原来有，最多上溯八层）：
- *   用户项目里只要有一层目录叫 agents（比如 ~/code/agents/foo），
- *   就会被当成宿主根目录 ⇒ 我们的 agent.md 会写进**用户的项目**。
- *   宁可**写不到**（降级：身份层仍走随消息带），也不猜。
- *
- * ⚠️ 也不从 dataDir 反推（那是宿主内部布局，反推=猜）。
- *
- * @param {string[]} paths 宿主返回的路径们
- * @param {string} pluginId 插件 id
- * @returns {string[]} 候选根目录（按可信度排序）
- */
-export function agentsRootCandidates(paths, pluginId) {
-  const wanted = String(pluginId ?? '');
-  const out = [];
-  const push = (value) => {
-    const text = String(value ?? '');
-    if (text && !out.includes(text)) out.push(text);
-  };
-  for (const raw of Array.isArray(paths) ? paths : []) {
-    const text = String(raw ?? '');
-    if (!text || !wanted) continue;
-    // 唯一认的形状：<root>/<agent>/miniapps/<pluginId>（末尾两段必须是 miniapps/<pluginId>）
-    if (basename(text) === wanted && basename(dirname(text)) === 'miniapps') {
-      const root = dirname(dirname(dirname(text)));
-      if (root && root !== text) push(root);
-    }
-  }
-  return out;
-}
-
-/**
- * 渲染我们那个 agent 的 agent.md（纯函数 —— 自检能直接跑它做负向注入）。
- *
- * ⚠️ **frontmatter 只用宿主认识的字段**（name / description / x-mavis.displayName）：
- *   宿主解析器会拒掉不认识的字段，写错 = agent 认不出来。
- *
- * @param {{persona?: string, identity?: {baseline?: string, appearance?: string, rules?: string},
- *   name?: string, displayName?: string, description?: string}} input
- * @returns {string}
- */
-export function renderSelfAgentFile(input) {
-  const name = String(input?.name || SELF_AGENT_NAME);
-  const displayName = String(input?.displayName || SELF_AGENT_DISPLAY_NAME);
-  const description = String(input?.description || SELF_AGENT_DESCRIPTION);
-  const persona = String(input?.persona ?? '').trim();
-  const identity = input?.identity || {};
-  const parts = [
-    '---',
-    'name: ' + name,
-    'description: ' + description,
-    'x-mavis:',
-    '  displayName: ' + displayName,
-    '---',
-    '',
-    SELF_AGENT_MARK,
-    '',
-  ];
-  if (persona) parts.push(persona, '');
-  const baseline = String(identity.baseline ?? '').trim();
-  const appearance = String(identity.appearance ?? '').trim();
-  const rules = String(identity.rules ?? '').trim();
-  if (baseline) parts.push('# 她是谁', '', baseline, '');
-  if (appearance) parts.push('# 她长什么样', '', appearance, '');
-  if (rules) parts.push('# 她的规矩', '', rules, '');
-  return parts.join('\n').trimEnd() + '\n';
-}
-
-/**
- * 这个 agent.md 是我们写的吗？
- *
- * @param {string} text 文件内容
- * @returns {boolean}
- */
-export function isSelfAgentFile(text) {
-  return String(text ?? '').includes(SELF_AGENT_MARK);
-}
-
-/**
- * 读一个文件；不存在 → null。
- *
- * @param {string} file
- * @returns {Promise<string|null>}
- */
-export async function readFileIfExists(file) {
-  try {
-    return await readFile(file, 'utf8');
-  } catch {
-    return null;
-  }
-}
-
-/**
- * 宿主 agent 根目录找到了没有（目录必须真的存在）。
- *
- * @param {string[]} candidates
- * @returns {Promise<string>}
- */
-export async function resolveAgentsRoot(candidates) {
-  for (const candidate of Array.isArray(candidates) ? candidates : []) {
-    try {
-      const info = await stat(candidate);
-      if (info.isDirectory()) return candidate;
-    } catch {
-      // 不存在就试下一个
-    }
-  }
-  return '';
-}
-
-/**
- * 在宿主里**新增**我们那个专属 agent。
- *
- * @param {{context: any, sessionId?: string, pluginId?: string, logger?: any}} input
- * @returns {Promise<{ok: boolean, created: boolean, agent?: string, path?: string,
- *   reason?: string, probeSessionId?: string}>}
- */
-export async function ensureSelfAgent(input) {
-  const context = input?.context;
-  const pluginId = String(input?.pluginId || context?.pluginId || '');
-  const logger = input?.logger || context?.logger;
-  const paths = [];
-
-  // ① **只有我们自己用 Agent API 建的会话**能证明根目录（上游评审 Must fix 1）：
-  //    官方规范里，Node 发起的会话工作目录 =「Mini App 自己的 Agent 目录」
-  //    = <agents 根>/<agent>/miniapps/<pluginId>；而**页面发起的会话**工作目录是
-  //    **用户自己的项目** ⇒ 从它推根目录 = 往用户项目里写文件。
-  //    所以这里**只认这一个会话**，agents() 列表不再作为路径来源
-  //    （它的 agent 目录形状是 <root>/<agent>，证明不了 root 是什么）。
-  if (input?.sessionId && context?.agent && typeof context.agent.session === 'function') {
-    try {
-      const detail = await context.agent.session(input.sessionId);
-      paths.push(...collectPathStrings(detail));
-    } catch (error) {
-      logger?.warn?.('miniapp.agent.self_agent.session_probe_failed', {
-        reason: error instanceof Error ? error.message : 'unknown',
-      });
-    }
-  }
-
-  const root = await resolveAgentsRoot(agentsRootCandidates(paths, pluginId));
-  if (!root) {
-    logger?.warn?.('miniapp.agent.self_agent.agents_root_unknown', { pluginId });
-    return { ok: false, created: false, reason: 'agents_root_unknown' };
-  }
-
-  const targetFile = join(root, SELF_AGENT_NAME, SELF_AGENT_FILE);
-
-  // ⭐ **只增不改**：文件已经存在就一个字节都不动。
-  const existing = await readFileIfExists(targetFile);
-  if (existing !== null) {
-    if (isSelfAgentFile(existing)) {
-      return { ok: true, created: false, agent: SELF_AGENT_NAME, path: targetFile };
-    }
-    // 那个名字已经被别人的 agent 占了 —— 不碰不用，降级。
-    logger?.warn?.('miniapp.agent.self_agent.name_taken', { path: targetFile });
-    return { ok: false, created: false, path: targetFile, reason: 'name_taken' };
-  }
-
-  const persona = await readPersonaBody(context?.pluginRoot || '');
-  if (!persona) {
-    logger?.warn?.('miniapp.agent.self_agent.persona_missing', {});
-    return { ok: false, created: false, reason: 'persona_missing' };
-  }
-  const identity = await readIdentitySections(context?.pluginRoot || '');
-  const content = renderSelfAgentFile({
-    persona,
-    identity,
-    name: SELF_AGENT_NAME,
-    displayName: SELF_AGENT_DISPLAY_NAME,
-    description: SELF_AGENT_DESCRIPTION,
-  });
-
-  try {
-    await writeQueue(async () => {
-      // 队列里再查一次：并发下别把别人的文件顶掉。
-      const again = await readFileIfExists(targetFile);
-      if (again !== null) return;
-      await writeTextAtomic(targetFile, content);
-    });
-  } catch (error) {
-    logger?.warn?.('miniapp.agent.self_agent.write_failed', {
-      reason: error instanceof Error ? error.message : 'unknown',
-    });
-    return { ok: false, created: false, path: targetFile, reason: 'write_failed' };
-  }
-
-  const verified = await readFileIfExists(targetFile);
-  if (verified === null || !isSelfAgentFile(verified)) {
-    logger?.warn?.('miniapp.agent.self_agent.verify_failed', { path: targetFile });
-    return { ok: false, created: false, path: targetFile, reason: 'verify_failed' };
-  }
-  logger?.info?.('miniapp.agent.self_agent.created', { path: targetFile });
-  return { ok: true, created: true, agent: SELF_AGENT_NAME, path: targetFile };
-}
-
-// ⭐ **CLI 不再住在这里**（上游评审 Optional，2026-11-04）：
-//   宿主把 miniapp/node/** 当运行时代码扫，进程里往 stdout 写东西会触发
-//   上游校验告警（stdout 属于宿主）。CLI 搬到 miniapp/scripts/agentprov-cli.mjs
-//   —— 仍然随包发布，用户手动跑那条路不变（--agents-root / --check）。
diff --git a/plugins/antianqi/mmx-octopus/miniapp/node/identity.mjs b/plugins/antianqi/mmx-octopus/miniapp/node/identity.mjs
index 45071fad..f538829c 100644
--- a/plugins/antianqi/mmx-octopus/miniapp/node/identity.mjs
+++ b/plugins/antianqi/mmx-octopus/miniapp/node/identity.mjs
@@ -5,7 +5,7 @@
  *
  * ⭐ **为什么单独成模块**：
  *   ① 随消息带的身份层（server.mjs 的 withIdentity）要读「她是谁 / 她长什么样 / 她的规矩」；
- *   ② 新增的专属 agent（agentprov.mjs）要把同样三段写进宿主 agent 的 system prompt。
+ *   ② v1.9.0 起插件不再往宿主目录写文件 ⇒ 这三段只走「每轮随消息带」这一条路。
  *   两处读同一份投影 ⇒ **判断只写一处**，否则改了一处另一处会漂。
  *
  * ⚠️ **只读** —— 这两个投影文件都在插件自己的目录里（identity/），
diff --git a/plugins/antianqi/mmx-octopus/miniapp/node/server.mjs b/plugins/antianqi/mmx-octopus/miniapp/node/server.mjs
index da5dfcf3..610d4ff4 100644
--- a/plugins/antianqi/mmx-octopus/miniapp/node/server.mjs
+++ b/plugins/antianqi/mmx-octopus/miniapp/node/server.mjs
@@ -73,9 +73,8 @@ import {
   buildStoryBlock,
   parseStoryBody,
 } from './storyscope.mjs';
-import { pickPetAgent, needRebuild, normalizeAgentMode, DEFAULT_AGENT_MODE } from './agentpick.mjs';
-// ★ **v1.8.0：在宿主里新增我们自己的专属 agent**（只增不改、失败必降级）。
-import { ensureSelfAgent, SELF_AGENT_NAME } from './agentprov.mjs';
+import { pickPetAgent, needRebuild } from './agentpick.mjs';
+import { buildAgentCard, AGENT_CARD_NAME } from './agentcard.mjs';
 // 身份层三段的**唯一读取口**（随消息带的那份 + 写进 agent 文件的那份，共用同一份投影）。
 import { readIdentitySections } from './identity.mjs';
 import { checkFrame, protocolPayload } from './chat-protocol.mjs';
@@ -279,8 +278,6 @@ const STUCK_NOTE = '我卡住了……多半是停在等一个没人回答的问
 // 降级路径现在**读那份投影**（见 `readIdentityFallback()`），本文件不再留副本 ——
 // 双写 = 迟早漂（规矩与契约已经这么漂过好几回）。
 
-
-
 /**
  * 从宿主发来的问卷请求里**取出问题正文**。
  *
@@ -495,15 +492,6 @@ export async function start(context, options = {}) {
     '<script id="mmx-chat-protocol"></script>',
     `<script id="mmx-chat-protocol">window.__MMX_CHAT_PROTOCOL__ = ${protocolPayload()};</script>`
   );
-  // 默认档真源注入：页面里的默认归一**只认这里**（和轨道表同一个套路）——
-  // 服务端改了默认值，页面跟着变，不用两处各写一份。
-  // ⚠️ 脚本标签里的 < 要转义，防止提前闭合脚本标签。
-  clientEntry = clientEntry.replace(
-    '<script id="mmx-agent-mode"></script>',
-    `<script id="mmx-agent-mode">window.__MMX_AGENT_MODE__ = ${JSON.stringify({
-      default: DEFAULT_AGENT_MODE,
-    }).replace(/</g, '\u003c')}</script>`
-  );
   const mcpHandler = createMcpHandler({
     state,
     chat,
@@ -710,22 +698,12 @@ export async function start(context, options = {}) {
   /**
    * 专属 agent 的探测结果（运行时缓存，不落盘）。
    *
-   * `null` = 还没探过；`''` = 探过了、这台机器上没有专属 agent（用默认 agent）；
-   * `'mmx'` = 有，用它；`'mmx-octopus-agent'` = 我们自己新增的那个。
+   * `null` = 还没探过；`''` = 探过了、这台机器上用默认 agent；
+   * `'mmx'` = 用户自己建了那个 agent，用它。
    */
   let petAgentProbe = null;
 
-  /**
-   * 「我们自己的专属 agent」这次运行的结论（运行时缓存）。
-   *
-   * `null` = 还没试过；对象 = 结果（ok / created / reason / path / probeSessionId）。
-   *
-   * ⚠️ **只增不改**：这个结论只决定「要不要新增我们那一个 agent」，
-   *   **绝不碰用户已有的 agent**（名字被占就降级 —— 不写、不用）。
-   */
-  let ownAgentResult = null;
-
-  /**
+    /**
    * 检查一次该不该让她主动开口；该就说一句。
    *
    * ⚠️ **闲话失败不致命**：她该说话的时候没说上，不该把整个 Mini App 带崩。
@@ -1181,22 +1159,27 @@ export async function start(context, options = {}) {
           return;
         }
 
-        // ===== 「她用哪个 agent」（上游评审 Optional #3：给用户一个自己决定的入口）=====
+        // ===== 「复制她的设定」（官方插件市场 1.8.0 拒收 → 官方给的改法 B）=====
         //
-        // ⚠️ **默认是「建专属 agent」**（老板 2026-11-04 拍板）⇒ 插件默认会去建那个 agent。
-        //   想要零写入的用户在面板上选「用现有 agent」（或首启卡片上选）即可。
-        if (path === '/api/agent-mode') {
-          // ⚠️ 默认是「建专属 agent」；只有明确传 'existing' 才降级（老板 2026-11-04 拍板）。
-          //   归一走 agentpick.mjs 的唯一实现（不许在这里自己写默认值）。
-          const mode = normalizeAgentMode(body.mode);
-          const agentMode = await state.setAgentMode(mode);
-          // 换了档 ⇒ 探测缓存作废（agent 列表 / 我们那个 agent 的结论都要重探）
-          petAgentProbe = null;
-          ownAgentResult = null;
-          // 换回「现有 agent」⇒ 别再把她钉在我们那个 agent 上
-          if (mode === 'existing') await state.setPetAgent(null);
-          context.logger.info('miniapp.agent.mode.changed', { mode });
-          sendJson(response, 200, { ok: true, agentMode, snapshot: state.snapshot() });
+        // ⚠️ **插件不写宿主任何文件**：这一条只把设定正文交给**用户**，
+        //   由用户自己在 Agent 设置里建一个名为 mmx 的 agent 并粘贴；
+        //   插件之后通过 agents() **认出来**并用它（认不出就退回「随消息带」）。
+        if (path === '/api/agent-card') {
+          const card = await buildAgentCard(context.pluginRoot);
+          let found = false;
+          try {
+            if (context.agent && typeof context.agent.agents === 'function') {
+              const listed = await context.agent.agents();
+              found = (listed?.agents || []).some(
+                (item) => String(item?.name ?? '') === AGENT_CARD_NAME
+              );
+            }
+          } catch (error) {
+            context.logger.warn('miniapp.agent.card.probe_failed', {
+              reason: error instanceof Error ? error.message : 'unknown',
+            });
+          }
+          sendJson(response, 200, { ok: true, name: AGENT_CARD_NAME, found, body: card });
           return;
         }
 
@@ -1523,17 +1506,14 @@ export async function start(context, options = {}) {
     );
   }
 
-  /**
-   * 她的会话该用哪个 agent。
-   *
-   * 优先级：用户显式指定的（`state.petAgent`）＞ 探测到的专属 agent ＞ 空（用默认）。
+    /**
+   * 她的会话挂在哪个 agent 上（**只读**探测：不新增、不修改任何 agent）。
    *
-   * ⚠️ **为什么探测而不是写死**：专属 agent 是**用户配置**的 —— 别人装了我们的
-   * Mini App，`agents()` 列表里没有「mmx」⇒ `create({agent})` 直接 INVALID_ARGUMENTS。
-   * 探测不到就退回默认 agent（= 老行为），可推广性不破。
+   * ⚠️ **v1.9.0**：这里不再有「建专属 agent」那一档 —— 插件不再往宿主目录写文件。
+   *   只认两种：用户显式指定的那个，或用户自己建的 mmx（认出来就用）。
    *
-   * ⚠️ **探测结果要缓存**：`agents()` 走宿主的目录调用通道，
-   * 跟 `run`/`answer` 共享 Node 进程的 16 个普通请求名额 —— 每轮探一次不划算。
+   * ⚠️ **探测结果要缓存**：agents() 走宿主的目录调用通道，
+   *   跟 run/answer 共享 Node 进程的 16 个普通请求名额 —— 每轮探一次不划算。
    *
    * @returns {Promise<string>} '' = 不指定（用默认 agent）
    */
@@ -1541,23 +1521,12 @@ export async function start(context, options = {}) {
     if (state.petAgent) return String(state.petAgent);
     if (petAgentProbe !== null) return petAgentProbe;
     const names = await listAgentNames();
-    // ⚠️ **档位决定我们新增的那个 agent 参不参与**：
-    //   「用现有 agent」这一档 ⇒ 它**不参与**（不新增、不使用）；
-    //   「建专属 agent」这一档 ⇒ 它**排在自己的 mmx 前面**（用户明确选了它）。
-    const mode = normalizeAgentMode(state.agentMode);
-    // ⚠️ **专属档也只有我们那个真的是我们的时才用它** —— 名字被别人占了（name_taken）
-    //   ⇒ 我们没建成 ⇒ 那个同名 agent 是**别人的** ⇒ 不能拿来当「我们那个」用
-    //   （降级：继续用现有 agent —— 与面板上写的失败原因一致）。
-    const selfOwned = mode === 'own' && !!(ownAgentResult && ownAgentResult.ok);
-    const selfName = mode === 'own' ? SELF_AGENT_NAME : '';
-    petAgentProbe = pickPetAgent(names, '', selfName, mode, selfOwned);
+    petAgentProbe = pickPetAgent(names, '');
     context.logger.info('miniapp.agent.pet_agent.resolved', {
       agent: petAgentProbe || '(default)',
-      mode,
     });
     return petAgentProbe;
   }
-
   /**
    * 宿主列出来的 agent 名（探测失败就当空表 ⇒ 退回默认 agent）。
    *
@@ -1578,55 +1547,26 @@ export async function start(context, options = {}) {
     return [];
   }
 
-  /**
+    /**
    * 她的专属会话：卡住的（pendingQuestion）不能复用，重新 create 一个。
    * create 不占 run slot；run({sessionId}) 继续时不能带 agent。
    *
-   * ⭐ **agent 对不上就重建**：
-   * 官方规范「会话不能中途换 agent」⇒ 想换只能新建会话。
-   * 原来这里只认 `state.petSessionDirty`，而 `state.petAgent` **从来没有入口写入过**
+   * ⭐ **agent 对不上就重建**：官方规范「会话不能中途换 agent」⇒ 想换只能新建会话。
+   * 原来这里只认 state.petSessionDirty，而 state.petAgent 从来没有入口写入过
    * （三个调用点都没传 agentName）⇒ 她的会话一直挂在默认 agent（mavis）上。
    * 现在多一道判据：**当前会话挂的 agent 跟要用的不一致 ⇒ 重建**。
    *
    * ⚠️ **重建的代价**：新会话 = 她的会话历史从零开始（旧的 session 数据还在宿主库里，
-   * 只是不再续用它）。这是「让 agent 文件用对」的必然代价。
+   * 只是不再续用它）。这是「让 agent 用对」的必然代价。
+   *
+   * ⚠️ **v1.9.0**：不再有「建专属 agent」那一档 ⇒ 这里**不写任何宿主文件**。
    *
    * @param {unknown} agentName 可选：这一轮用哪个 agent
    * @returns {Promise<string>}
    */
   async function ensurePetSession(agentName) {
     const explicit = agentName ? String(agentName) : '';
-    let wanted = explicit ? explicit : '';
-
-    // ⭐ **v1.8.0：没有可用的专属 agent → 现场新增一个**（只增不改、失败必降级）。
-    //
-    // ⚠️ **换 agent 只能重建会话**（官方规范：会话不能中途换 agent）⇒
-    //   只有「她还没说过话」（换过去不丢历史）时才把会话挪到我们那个 agent 上；
-    //   已经有历史了就**不动当前会话** —— 宁可暂时用弱通道，也不丢她的上下文。
-    // ⭐ **用户自己选的那一档**（面板上的「她用哪个 agent」）：
-    //   · 「用现有 agent」⇒ 我们新增的那个**一次都不碰**：
-    //     不新增、不使用、不把会话挪过去 ⇒ 插件不往宿主目录写任何文件。
-    //   · 「建专属 agent」⇒ 先把我们那一个建出来（只增不改、失败必降级），
-    //     建不出来 ⇒ 退回「现有 agent」，并把原因说清楚（面板上看得见）。
-    //
-    // ⚠️ **换 agent 只能重建会话**（官方规范：会话不能中途换 agent）。
-    //   用户**主动**选了「专属」⇒ 就换（新会话第一轮带接续摘要 ⇒ 上下文接得上）。
-    if (!explicit && state.agentMode === 'own') {
-      const own = await ensureOwnAgent();
-      if (own.ok) {
-        await state.setAgentStatus('');
-      } else {
-        await state.setAgentStatus(ownAgentFailText(own.reason));
-        if (own.probeSessionId) {
-          // 降级：建不成 ⇒ 继续用现有 agent（身份层仍走随消息带）。
-          await state.setPetSession(own.probeSessionId, false);
-        }
-      }
-      wanted = await resolvePetAgent();
-    } else if (!explicit) {
-      // 「用现有 agent」这一档：我们那一个**不参与**（不写盘、不使用）。
-      wanted = await resolvePetAgent();
-    }
+    const wanted = explicit ? explicit : await resolvePetAgent();
 
     const current = state.petSessionId;
     if (current && !state.petSessionDirty) {
@@ -1641,98 +1581,17 @@ export async function start(context, options = {}) {
         return current;
       }
     }
-    // 我们自己那个 agent 要记下来（下一轮直接用它）；用户显式指定的照旧。
-    if (wanted === SELF_AGENT_NAME && state.petAgent !== SELF_AGENT_NAME) {
-      await state.setPetAgent(SELF_AGENT_NAME);
-    } else if (agentName && wanted !== state.petAgent) {
+    // 用户显式指定的 agent 记下来（下一轮直接用它）。
+    if (agentName && wanted !== state.petAgent) {
       await state.setPetAgent(wanted);
     }
     const sessionId = await createSessionOn(wanted);
     await state.setPetSession(sessionId, false);
-    // ⚠️ 这里**不**带身份层 —— 统一在 run 之前随消息带（`withIdentity`）。
+    // ⚠️ 这里**不**带身份层 —— 统一在 run 之前随消息带（withIdentity）。
     // 理由：老会话被复用时根本走不到这个分支，在这里带会漏。
     return sessionId;
   }
-
-  /**
-   * 「专属 agent 没建成」的原因 —— 面板上给用户看的一句话。
-   *
-   * ⚠️ **失败要说出来**（不能默默退回「现有 agent」）：用户选的是「专属」，
-   *   没建成就告诉他为什么（名字被占 / 认不出目录 / 写不进去）。
-   *
-   * @param {string} reason
-   * @returns {string}
-   */
-  function ownAgentFailText(reason) {
-    const map = {
-      name_taken: '「mmx-octopus-agent」这个名字已经被别的 agent 占了，建不了 —— 继续用现有 agent。',
-      agents_root_unknown: '认不出宿主的 agent 目录，建不了专属 agent —— 继续用现有 agent。',
-      write_failed: '写不进宿主的 agent 目录，建不了专属 agent —— 继续用现有 agent。',
-      verify_failed: '写完没验过，建不了专属 agent —— 继续用现有 agent。',
-      persona_missing: '包里没读到她的设定，建不了专属 agent —— 继续用现有 agent。',
-    };
-    return map[String(reason)] || '专属 agent 没建成 —— 继续用现有 agent。';
-  }
-
-  /**
-   * 在宿主里**新增**我们自己的专属 agent（只增不改、失败必降级）。
-   *
-   * ⭐ **根目录只能「证明」，不能「猜」**（上游评审 Must fix 1，2026-11-04）：
-   *   官方规范（docs/miniapp/sessions.md）：**Node 发起的会话**工作目录 =
-   *   「Mini App 自己的 Agent 目录」= <agents 根>/<agent>/miniapps/<pluginId>，
-   *   往上三层就是 agents 根；而**页面发起的会话**工作目录是**用户自己的项目**。
-   *   ⇒ 只有我们自己用 Agent API 建的会话能证明根目录；
-   *     **不**从 dataDir 反推、**不**上溯找名为 agents 的目录（会落进用户项目）。
-   *
-   * ⚠️ **为什么要一个临时会话**：当前会话的路径证明不了根目录时，
-   *   建一个**我们自己的**会话（Node 自建 ⇒ 工作目录必然是上面那个形状）来问一次。
-   *   那个会话拿不到根目录 ⇒ **一个字节都不写**（降级：身份层仍走随消息带）。
-   *   ⚠️ Node 自建的会话**不出现在左侧聊天列表**（官方规范）⇒ 不会脏用户的会话列表。
-   *
-   * @returns {Promise<{ok: boolean, created: boolean, path?: string, reason?: string, probeSessionId?: string}>}
-   */
-  async function ensureOwnAgent() {
-    if (ownAgentResult) return ownAgentResult;
-    const current = state.petSessionId;
-    let result = await ensureSelfAgent({
-      context,
-      sessionId: current,
-      pluginId: context.pluginId,
-      logger: context.logger,
-    });
-    let probeSessionId = '';
-    // ⚠️ 只要「根目录证明不了」就探一次（不再要求「当前没有会话」）：
-    //   当前会话可能是**页面发起的**（工作目录 = 用户项目），证明不了根目录。
-    if (!result.ok && result.reason === 'agents_root_unknown') {
-      try {
-        probeSessionId = await createSessionOn('');
-      } catch (error) {
-        context.logger.warn('miniapp.agent.self_agent.probe_session_failed', {
-          reason: error instanceof Error ? error.message : 'unknown',
-        });
-      }
-      if (probeSessionId) {
-        result = await ensureSelfAgent({
-          context,
-          sessionId: probeSessionId,
-          pluginId: context.pluginId,
-          logger: context.logger,
-        });
-      }
-    }
-    if (result.ok) {
-      // 探测缓存作废：宿主里现在多了我们那个 agent，下一轮要重新列。
-      petAgentProbe = null;
-      context.logger.info('miniapp.agent.self_agent.ready', {
-        created: !!result.created,
-        path: result.path,
-      });
-    }
-    ownAgentResult = { ...result, probeSessionId };
-    return ownAgentResult;
-  }
-
-  /**
+      /**
    * 建一个会话（可指定 agent）；我们那个 agent 被删了 ⇒ 自动退回默认 agent。
    *
    * ⚠️ **「她能说话」比「一定挂在专属 agent 上」重要** ⇒ 失败要降级，不抛。
@@ -1747,8 +1606,8 @@ export async function start(context, options = {}) {
       if (!sessionId) throw new Error('session_create_failed');
       return sessionId;
     } catch (error) {
-      if (wanted !== SELF_AGENT_NAME) throw error;
-      context.logger.warn('miniapp.agent.pet_session.self_agent_create_failed', {
+      if (!wanted) throw error;
+      context.logger.warn('miniapp.agent.pet_session.agent_create_failed', {
         reason: error instanceof Error ? error.message : 'unknown',
       });
       await state.setPetAgent(null);
@@ -1828,10 +1687,8 @@ export async function start(context, options = {}) {
    * ⭐ **判断只写一处**：读取逻辑在 `identity.mjs` 里，随消息带的那份
    *   和写进专属 agent 文件的那份**读的是同一份投影**（改一处不会漂）。
    *
-   * ⚠️ **弱通道**：插件**不**把这三段写进宿主已有文件 ⇒ 只能每轮随消息带进去。
-   *   代价：身份层进会话历史 ⇒ 宿主压缩时可能被压掉。
-   *   （v1.8.0 起另有一条**强通道**：新增我们自己的 agent，把同样三段写进它的
-   *   system prompt —— 见 `agentprov.mjs`。）
+   * ⚠️ **弱通道**：插件**不**把这三段写进宿主的任何文件 ⇒ 只能每轮随消息带进去。
+   *   代价：身份层进会话历史 ⇒ 宿主压缩时可能被压掉（每轮都带一份来补）。
    *
    * @returns {Promise<{baseline: string, appearance: string, rules: string}>}
    */
diff --git a/plugins/antianqi/mmx-octopus/miniapp/node/state.mjs b/plugins/antianqi/mmx-octopus/miniapp/node/state.mjs
index afdb5581..3e4bb93f 100644
--- a/plugins/antianqi/mmx-octopus/miniapp/node/state.mjs
+++ b/plugins/antianqi/mmx-octopus/miniapp/node/state.mjs
@@ -15,8 +15,7 @@
 import { writeJsonAtomic, createWriteQueue } from './atomic-json.mjs';
 import { textLength } from './clip.mjs';
 import { pickLine } from './lines.mjs';
-// ⭐ 默认档真源（agentpick.mjs）—— 本文件不许自己写默认值。
-import { DEFAULT_AGENT_MODE, normalizeAgentMode } from './agentpick.mjs';
+import { LEGACY_SELF_AGENT_NAME } from './agentpick.mjs';
 
 /**
  * 章鱼娘的表情。thinking/working 由 Agent 侧驱动。
@@ -339,23 +338,20 @@ export class PetState {
      * @type {boolean}
      */
     this.petHeadInjected = false;
-    /** @type {{text: string, at: number} | null} 用户正在问她的内容（临时态，不持久化） */
-    this.asking = null;
-    /** @type {string | null} 她的专属会话用哪个 agent */
-    this.petAgent = null;
     /**
-     * 她的会话用哪个 agent（**用户在面板里选**，持久化）。
-     * 'own'      = **建我们自己的专属 agent**（**默认**）—— 性格更鲜明、从零开始、没有积累；
-     * 'existing' = **用现有 agent** —— 更偏助理，认得你之前的经验与工具上下文。
+     * 她的会话挂在哪个 agent 上（`null` = 用默认 agent）。
      *
-     * ⚠️ **默认是「建专属 agent」**（老板 2026-11-04 拍板：体验感最好，也是主线方向）；
-     *   想给用户留余地 ⇒ 「用现有 agent」那一档随时能在面板里选。
-     * @type {'existing'|'own'}
+     * ⚠️ **这个初值不能少**（v1.9.0 删「建专属 agent」那一档时误删了它，
+     *   官方评审 2026-11-09 指出）：不初始化的话新装时它是 `undefined` ——
+     *   快照里就没这个字段（契约写的是 `string | null`）。
+     *
+     * 取值优先级：显式指定 ＞ 用户自己建的 `mmx` ＞ 默认 agent（见 agentpick.mjs）。
+     * @type {string | null}
      */
-    this.agentMode = DEFAULT_AGENT_MODE;
-    /** @type {string} 运行时状态：实际用哪个 agent 的说明（不持久化；空 = 没话说） */
-    this.agentStatus = '';
-    /** @type {boolean} 她正在回话（运行时态，不持久化） */
+    this.petAgent = null;
+    /** @type {{text: string, at: number} | null} 用户正在问她的内容（临时态，不持久化） */
+    this.asking = null;
+        /** @type {boolean} 她正在回话（运行时态，不持久化） */
     this.chatBusy = false;
     /** @type {boolean} 是否把 MCode 状态摘要拼进她的输入（持久化，默认开） */
     this.petAware = true;
@@ -450,11 +446,13 @@ export class PetState {
         if (typeof saved.petSessionId === 'string' && saved.petSessionId) this.petSessionId = saved.petSessionId;
         if (typeof saved.petSessionDirty === 'boolean') this.petSessionDirty = saved.petSessionDirty;
         if (typeof saved.petHeadInjected === 'boolean') this.petHeadInjected = saved.petHeadInjected;
-        if (typeof saved.petAgent === 'string' && saved.petAgent) this.petAgent = saved.petAgent;
-        // ⚠️ **默认是「建专属 agent」**（老板 2026-11-04 拍板：体验感最好，也是主线方向）——
-        //   只有**明确存了** 'existing' 才降级成「用现有 agent」。
-        //   归一走 agentpick.mjs 的唯一实现（不许在这里自己写默认值）。
-        this.agentMode = normalizeAgentMode(saved.agentMode);
+        // ⚠️ **1.8.0 留下的那个 agent 名要丢掉**（官方评审 2026-11-09）：
+        //   1.8.0 默认会自己建一个 agent，并把它的名写进 `petAgent`；
+        //   1.9.0 的插件既不建它、也不碰它 ⇒ 留着它，老用户升级后她的会话
+        //   仍会挂在那个 agent 上，与「1.9.0 不再碰它」对不上。
+        //   丢掉之后回到「用户自己建的 mmx 或默认 agent」（见 agentpick.mjs）。
+        if (typeof saved.petAgent === 'string' && saved.petAgent
+            && saved.petAgent !== LEGACY_SELF_AGENT_NAME) this.petAgent = saved.petAgent;
         if (typeof saved.petAware === 'boolean') this.petAware = saved.petAware;
         if (typeof saved.idleTalk === 'boolean') this.idleTalk = saved.idleTalk;
         if (saved.naming && typeof saved.naming === 'object') {
@@ -516,7 +514,6 @@ export class PetState {
         petSessionDirty: this.petSessionDirty,
         petHeadInjected: this.petHeadInjected,
         petAgent: this.petAgent,
-        agentMode: this.agentMode,
         petAware: this.petAware,
         idleTalk: this.idleTalk,
         naming: { ...this.naming },
@@ -587,8 +584,6 @@ export class PetState {
       petHeadInjected: this.petHeadInjected,
       asking: this.asking,
       petAgent: this.petAgent,
-      agentMode: this.agentMode,
-      agentStatus: this.agentStatus,
       petAware: this.petAware,
       idleTalk: this.idleTalk,
       naming: { ...this.naming },
@@ -1189,34 +1184,6 @@ export class PetState {
     return this.idleTalk;
   }
 
-  /**
-   * 她的会话用哪个 agent（用户在面板里选的那一档）。
-   *
-   * ⚠️ **只有明确传 'existing' 才算「用现有 agent」** —— 别的值一律按「建专属 agent」处理。
-   *   默认就是「建专属 agent」（老板 2026-11-04 拍板：体验感最好，也是主线方向）；
-   *   用户想留余地 ⇒ 在面板里选「用现有 agent」，那一档**不往宿主目录写任何文件**。
-   *
-   * @param {string} mode
-   */
-  async setAgentMode(mode) {
-    this.agentMode = normalizeAgentMode(mode);
-    await this.commit();
-    return this.agentMode;
-  }
-
-  /**
-   * 运行时状态：她**实际**用哪个 agent 的说明（不持久化）。
-   *
-   * ⚠️ **不落盘**：它是一次运行的现场说明（为什么没按用户选的那一档走），
-   *   不是设置 —— 设置在 `agentMode` 里。
-   *
-   * @param {string} text
-   */
-  setAgentStatus(text) {
-    this.agentStatus = String(text ?? '');
-    return this.agentStatus;
-  }
-
   /**
    * 设置区看板。running 来自 sessions()，recent 来自 turn.finished。
    * @param {{running?: any[], recent?: any[]}} board
diff --git a/plugins/antianqi/mmx-octopus/miniapp/scripts/agentprov-cli.mjs b/plugins/antianqi/mmx-octopus/miniapp/scripts/agentprov-cli.mjs
deleted file mode 100644
index 7054ffc6..00000000
--- a/plugins/antianqi/mmx-octopus/miniapp/scripts/agentprov-cli.mjs
+++ /dev/null
@@ -1,111 +0,0 @@
-// @ts-check
-
-/**
- * 手动新增我们那个专属 agent 的命令行入口。
- *
- * 用法：
- *   node miniapp/scripts/agentprov-cli.mjs --agents-root <宿主的 agents 目录> [--check]
- *
- * ⭐ **为什么不住在 miniapp/node/**（上游评审 Optional，2026-11-04）：
- *   宿主把 miniapp/node/** 当**运行时代码**扫（上游 scripts/validate.mjs 的 node 规则），
- *   运行时代码里往 stdout 写东西会触发告警（stdout 属于宿主，运行时该走
- *   context.logger）。CLI 是**手动执行**的工具，它的输出就该走 stdout。
- *
- * ⚠️ **只新增，不改已有**：名字被占（那个目录里已经有别人的 agent.md）就**不碰不用**。
- */
-
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { writeTextAtomic } from '../node/atomic-json.mjs';
-import {
-  SELF_AGENT_DESCRIPTION,
-  SELF_AGENT_DISPLAY_NAME,
-  SELF_AGENT_FILE,
-  SELF_AGENT_NAME,
-  isSelfAgentFile,
-  readFileIfExists,
-  renderSelfAgentFile,
-} from '../node/agentprov.mjs';
-import { readIdentitySections, readPersonaBody } from '../node/identity.mjs';
-
-/**
- * 取一个 --flag 的值。
- *
- * @param {string[]} args
- * @param {string} name
- * @returns {string}
- */
-function flag(args, name) {
-  const index = args.indexOf(name);
-  return index >= 0 ? String(args[index + 1] ?? '') : '';
-}
-
-/**
- * 手动执行这条命令。
- *
- * @param {string[]} argv
- * @returns {Promise<number>}
- */
-export async function runCli(argv) {
-  const args = Array.isArray(argv) ? argv.slice() : [];
-  const root = flag(args, '--agents-root');
-  const checkOnly = args.includes('--check');
-  if (!root) {
-    process.stdout.write(
-      '用法：node miniapp/scripts/agentprov-cli.mjs --agents-root <宿主 agents 目录> [--check]\n'
-    );
-    return 2;
-  }
-  const here = dirname(fileURLToPath(import.meta.url));
-  const pluginRoot = dirname(dirname(here));
-  const persona = await readPersonaBody(pluginRoot);
-  const identity = await readIdentitySections(pluginRoot);
-  const targetFile = join(resolve(root), SELF_AGENT_NAME, SELF_AGENT_FILE);
-  const existing = await readFileIfExists(targetFile);
-  if (existing !== null) {
-    process.stdout.write(
-      (isSelfAgentFile(existing) ? '已经是我们写的那个 agent：' : '那个名字已被占用（不碰）：') +
-        targetFile +
-        '\n'
-    );
-    return 0;
-  }
-  if (checkOnly) {
-    process.stdout.write('可以写：' + targetFile + '\n');
-    return 0;
-  }
-  const content = renderSelfAgentFile({
-    persona,
-    identity,
-    name: SELF_AGENT_NAME,
-    displayName: SELF_AGENT_DISPLAY_NAME,
-    description: SELF_AGENT_DESCRIPTION,
-  });
-  try {
-    await writeTextAtomic(targetFile, content);
-  } catch (error) {
-    process.stdout.write('写失败：' + (error instanceof Error ? error.message : 'unknown') + '\n');
-    return 1;
-  }
-  process.stdout.write('已写入：' + targetFile + '\n');
-  return 0;
-}
-
-/**
- * 这个文件是不是被当作主程序跑的？
- *
- * @returns {boolean}
- */
-function isMainModule() {
-  try {
-    const entry = process.argv[1] ? resolve(process.argv[1]) : '';
-    return !!entry && entry === resolve(fileURLToPath(import.meta.url));
-  } catch {
-    return false;
-  }
-}
-
-if (isMainModule()) {
-  process.exitCode = await runCli(process.argv);
-}
diff --git a/plugins/antianqi/mmx-octopus/package.json b/plugins/antianqi/mmx-octopus/package.json
index 8392f6d7..8085abda 100644
--- a/plugins/antianqi/mmx-octopus/package.json
+++ b/plugins/antianqi/mmx-octopus/package.json
@@ -1,6 +1,6 @@
 {
   "name": "mmx-octopus",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "private": true,
   "description": "MMX Octopus: a desktop companion for MiniMax Code that mirrors what the Agent is doing and can be driven by it through a hosted MCP server.",
   "mcode": {