agent-purge 0.2.2 → 0.2.4

package/README.md

@@ -1,6 +1,10 @@
 # agent-purge
 
-一份系统提示词，喂给多个 coding agent。支持替换（replace）、追加（append）、清空（off）三种模式，可热切换，全程可逆。
+[![npm](https://img.shields.io/npm/v/agent-purge)](https://www.npmjs.com/package/agent-purge)
+[![stars](https://img.shields.io/github/stars/ZiChuanLan/agent-purge)](https://github.com/ZiChuanLan/agent-purge/stargazers)
+[![license](https://img.shields.io/npm/l/agent-purge)](LICENSE)
+
+一份系统提示词，喂给多个 coding agent。支持替换（replace）、只发人设（strict）、追加（append）、清空（off）四种模式，可热切换，全程可逆。
 
 ```
 agent-purge web          # 本地控制台 http://127.0.0.1:7788
@@ -52,10 +56,85 @@ agent-purge pi --persona <id>  # 只这一轮用别的
 
 ## 支持情况
 
+每个数字都是实测值：本地假 provider 抓真实请求体，不是估算。
+
+| harness | 机制 | 实测版本 | 默认 system | 注入后 |
+|---|---|---|---|---|
+| `codex` | 启动参数 `-c model_instructions_file=` | 0.163.0 | 21,026 | 24 |
+| `claude` | `--system-prompt-file` + 二进制补丁清残留身份句 | 2.1.304 | 6,379 | 156 |
+| `grok` | `--system-prompt-override` | 1.0.62 | 5,146 | 21 |
+| `omp` | `--system-prompt` | 17.4.2 | 34,511 | 10,106 |
+| `hermes` | 临时 HOME 里替换 `SOUL.md` | 0.21.5 | 8,139 | 7,554 |
+| `zcode` | UserPromptSubmit hook（user 角色）+ `customSystemPrompt` | 0.16.9 | 9,359 | 9,359 |
+| `opencode` | cwd 下 `.opencode/plugin/*.ts` 原地改 `output.system` | 1.19.3 | 19,332 | 112 |
+| `opencode2` | `plugins/agent-purge-v2.ts` 的 `ctx.session.hook("context")` | 0.0.0-beta-17823 | 8,279 | 3,189 |
+| `dsh` | cordis 插件（三个 profile 各一份） | 0.2.1-rc.2 | 5,713 | 68 |
+| `pi` | 原生扩展，会话内 `/purge` | — | — | — |
+| `antigravity` | 等长替换二进制里的身份句 | 1.23.x | ≈20,498 | — |
+| `codebuddy` | `--system-prompt-file` | 2.171.0 | — | — |
+| `qoder` / `workbuddy` | 不支持（提示词在服务端） | — | — | — |
+
+`opencode` 和 `opencode2` 是两个不同的 npm 包（`opencode-ai` 1.x 与 `@opencode/cli` 2.x），插件接口完全不同，各自独立支持。
+
 `agent-purge ls` 和 Web 控制台显示的是**运行期真值**：每个 harness 有没有装、版本、注入层（SYS / USER）、三个通道各自可用性。`matrix.json` 里是静态能力表，两者冲突时以运行期为准。
 
 闭源桌面端（提示词在服务端或二进制里）只做原样启动，不做任何注入——`agent-purge <h>` 会明确打印原因，不会假装生效。
 
+### dsh（DeepSeek Harness）
+
+desktop / web / headless 三个形态共用一套插件：往每个 profile 的 `node_modules/agent-purge/` 放一个 cordis 插件，在 `cordis.patch.yml` 里用 `- insert` 挂上。**不改 `app.asar`，不碰安装目录，不依赖任何第三方插件。**
+
+```bash
+agent-purge install dsh      # 写插件 + 挂载（三个 profile 一起）
+agent-purge dsh              # 按当前 persona 启动桌面版
+agent-purge uninstall dsh    # 删插件 + 剥离 patch 段，字节还原
+```
+
+装完要**重启一次 dsh**（patch 层只在启动时读）；之后换 persona、切模式、开关全是热生效，不用再重启。
+
+三个形态可以**分别开关**：Web 面板的 dsh 卡片下方有 desktop / web / headless 三个小勾，对应 `state.json` 的 `dshProfiles`。比如只在桌面版用，就把 web 和 headless 关掉；勾选只写状态文件，插件每轮现读，**不用重启**。
+
+只想临时试一下、不碰常驻 profile：`agent-purge dsh --ask "…"`（一次性会话，进程退出即清理）。
+
+#### 为什么不做「文件夹级人设」
+
+很容易想到的下一步是：同一个 dsh 里，A 项目一套人设、B 项目另一套。技术上做得到——插件在 `assemble` 时能拿到 cwd，按目录前缀匹配 persona 即可。但这是**破坏性**的设计，所以刻意不做：
+
+- **唯一真相被打破**。现在所有人设共用一个 `state.json` 指针，换一次、所有入口跟着变。按目录分叉等于把「配置」升级成「规则引擎」，之后每次改人设都要先回答「改的是哪一层」。
+- **规则会自我繁殖**。前缀匹配必然要处理嵌套目录、glob、优先级、冲突兜底。今天一个前缀，明天就要 `.agent-purge/` 文件，后天要继承与覆盖——最后没人说得清当前生效的是哪一条。
+- **跨入口语义分裂**。codex / claude / opencode 这些入口没有「项目」概念（有的是 PATH shim，有的是配置文件）。dsh 里按目录切、别处全局，用户无法解释「为什么这里是人设 A，那里是 B」。
+- **卸载不再是字节还原**。一旦引入目录规则，卸载就要判断哪些规则是用户写的、哪些是工具写的，回滚成本陡增。
+
+一句话：**agent-purge 卖的是「一份人设，所有入口，一起切换」**。做文件夹级隔离，赚的是灵活性，赔的是这句话还成不成立。真有这个需求，给每个项目放不同的人设文件、用 `agent-purge use` 手动切，比在插件里塞一套匹配引擎干净得多。
+
+## magpie 网关插件（可选）
+
+[magpie](https://github.com/yetone/magpie) 把各家 agent 的请求收进本地网关。挂上这个插件后，**凡是经过网关的请求**（Claude Code、Codex、OpenCode、pi…）的 system 段都按 agent-purge 的当前人设改写——不用逐个 harness 装，换人设也不用重启 magpie。
+
+插件在仓库里，不进 npm 包（`files` 白名单），所以按路径装：
+
+```bash
+git clone https://github.com/ZiChuanLan/agent-purge
+magpie plugin add /path/to/agent-purge/magpie-plugin     # 按路径装
+magpie plugin options magpie-plugin '{"mode":"append"}'  # 插件名 = 目录名
+magpie plugin list                                      # 应看到 async gateway hook + Persona 页
+```
+
+插件读的还是 `~/.agent-purge/`（同样认 `AGENT_PURGE_HOME`）：`agent-purge use <id>` 之后下一个请求就换人设。magpie 里也会多出 **Persona** 页，点一下就把人设和模式写进插件的 options。
+
+四种模式和 CLI 一致，差别在网关手里只有文本、没有各家启动参数：
+
+| 模式 | 网关插件做什么 |
+|---|---|
+| `off` | 不动请求 |
+| `strict` | system 整段换成人设（工具说明也一起没了，harness 可能变笨） |
+| `append` | 人设挂在最前，宿主 system 原样 |
+| `replace` | 人设在前，再删掉宿主 system 里报名字的那句（近似；要干净用 `strict`） |
+
+options 三键：`mode`、`persona`（人设 id）、`agents`（只对这些 magpie agent 生效，如 `["claude","codex"]`）。
+
+**边界**：改的是请求体里的文本，harness 在客户端就拼死的东西拦不住；`replace` 只删「一行里同时有自称和点名模型/厂商」的行，比 CLI 那套 per-harness 处理粗。插件页是沙箱（没有 fetch、读不到磁盘），人设清单由 `gen-personas.mjs` 按你本机的人设生成到本地（不进仓库），**装完先跑一次**，之后增删人设再跑：`node magpie-plugin/gen-personas.mjs`。自测不依赖 magpie：`npm test`（钩子 26 项断言：四种协议 × 四种模式；页面逻辑 18 项：搜索过滤、options 合并、失败回滚）。
+
 ## 目录
 
 ```
@@ -64,6 +143,7 @@ lib/         状态、persona、注入、通道、检测
 backends/    每个 harness 的启动参数与身份句处理
 web/         控制台（server.mjs + ui.html）
 bench/       注入成功率实测与裁判脚本（开发用，不参与运行）
+magpie-plugin/  magpie 网关插件（可选，不进 npm 包）
 matrix.json  能力矩阵
 ```
 
@@ -112,6 +192,10 @@ matrix.json  能力矩阵
 **第三方独立性声明**：本项目属于完全独立的开源安全评测研究项目，与 pi 官方或其关联主体无任何隶属、商业合作、授权或官方背书关系。文中「官方」仅指评测对象为使用者本机安装的官方 harness 软件包，不代表其官方开发、认可或担保本插件。
 
 **必须署名**：借用本项目的名称、思路、代码或提示词，必须署名并标明本仓库。不署名将依法追究责任。
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=ZiChuanLan/agent-purge&type=Date)](https://star-history.com/#ZiChuanLan/agent-purge&Date)
+
 ## License
 
 MIT

package/backends/index.mjs

@@ -2,6 +2,8 @@
 // setup/cleanup 由入口统一调用，保证能按哈希回滚。
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { SESSION as DSH_SESSION, addPlugin, removePlugin, sessionSource } from "../lib/dsh.mjs";
+import { opencodePlugins } from "../lib/persist.mjs";
 
 const inline = (text) => text.replace(/\s+$/, "");
 
@@ -86,6 +88,57 @@ export const backends = {
 		};
 	},
 
+	// dsh（DeepSeek Harness）：CLI 只能起 headless（desktop 被 Electron 独占）。
+	// 一次性注入用 agent-purge-session 这个独立插件名，不会覆盖常驻的 agent-purge。
+	dsh: ({ personaText, mode, args }) => {
+		if (mode === "off") return { cmd: "dsh", args: ["--profile", "headless", ...args] };
+		return {
+			cmd: "dsh",
+			args: ["--profile", "headless", ...args],
+			note: `[plugin] ${DSH_SESSION}（三个 profile；patch: - insert）`,
+			residueHint: "desktop profile 由 Electron 独占，一次性注入只对本次 CLI 进程有效",
+			setup: () => addPlugin(DSH_SESSION, sessionSource(personaText, mode)),
+			cleanup: () => removePlugin(DSH_SESSION),
+		};
+	},
+
+	// opencode v2（@opencode/cli，bin 名 opencode2）：新插件 API，V1 的
+	// experimental.chat.system.transform 在 2.x 已废。插件放全局 plugins 目录。
+	opencode2: ({ personaText, mode, args }) => {
+		if (mode === "off") return { cmd: "opencode2", args: [...args] };
+		const dir = opencodePlugins();
+		// 与 V1 常驻插件（agent-purge.ts）分开，否则一次性注入会顶掉常驻接管
+		const file = join(dir, "agent-purge-v2-session.ts");
+		const persona = inline(personaText);
+		const mutate =
+			mode === "append"
+				? `event.system.push({ type: "text", text: PERSONA });`
+				: `event.system.splice(0, event.system.length, { type: "text", text: PERSONA });`;
+		const src = `// 由 agent-purge 生成；删除本文件即恢复宿主人设。
+const PERSONA = ${JSON.stringify(persona)};
+
+	export default {
+  id: "agent-purge-v2-session",
+  async setup(ctx) {
+    await ctx.session.hook("context", (event) => {
+      ${mutate}
+    });
+  },
+};
+`;
+		const write = () => {
+			mkdirSync(dir, { recursive: true });
+			writeFileSync(file, src);
+		};
+		return {
+			cmd: "opencode2",
+			args,
+			note: `[plugin] ${file.replace(/\\/g, "/")}（ctx.session.hook("context") 改 event.system）`,
+			setup: write,
+			cleanup: () => rmSync(file, { force: true }),
+		};
+	},
+
 	// 需要落盘或调用方配合，CLI 不代劳，只给可复制的配方
 	zcode: () => ({
 		manual: [
@@ -153,6 +206,16 @@ export const oneshots = {
 		const b = backends.opencode({ personaText, cwd, args: ["run", prompt] });
 		return b;
 	},
+	opencode2: ({ prompt, personaText, mode }) => {
+		if (mode === "off") return { cmd: "opencode2", args: ["run", prompt] };
+		const b = backends.opencode2({ personaText, mode, args: ["run", prompt] });
+		return b;
+	},
+	dsh: ({ prompt, personaText, mode }) => {
+		if (mode === "off") return { cmd: "dsh", args: ["--profile", "headless", prompt] };
+		// backends.dsh 会自己补 --profile headless，这里只给 prompt（否则重复）
+		return backends.dsh({ personaText, mode, args: [prompt] });
+	},
 	zcode: ({ prompt }) => ({
 		cmd: "zcode",
 		args: ["--prompt", prompt, "--mode", "yolo", "--output-format", "stream-json", "--no-color"],

package/bin/agent-purge.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 // agent-purge — 一个入口，把各家 harness 的系统提示词替换收进来。
 // 能力与实测数字见 matrix.json。
 //
@@ -309,22 +309,27 @@ function modeCmd() {
 async function installCmd(verb, rest) {
 	const id = rest[0];
 	const ids = id === "--all" || !id ? Object.keys(matrix.harnesses).filter((h) => matrix.harnesses[h].class !== "unsupported") : [id];
-	const { backends: be } = await import("../backends/index.mjs");
+	// 常驻只走 lib/persist.mjs 这一个控制面（caps / Web 开关 / status 都读它的 targets）
+	const { install, uninstall, targets } = await import("../lib/persist.mjs");
+	const { createStore } = await import("../lib/personas.mjs");
+	const store = createStore(DATA);
 	for (const h of ids) {
-		const b = be[h];
-		if (!b) die(`未知 harness: ${h}`);
-		const fn = verb === "install" ? b.install : b.uninstall;
-		if (!fn) {
+		if (!matrix.harnesses[h]) die(`未知 harness: ${h}`);
+		if (!targets[h]) {
 			console.log(`${h}: 没有常驻模式（用 arm 走裸命令接管 / slash 走会话内）`);
 			continue;
 		}
-		const spec = matrix.harnesses[h];
-		const { createStore } = await import("../lib/personas.mjs");
-		const store = createStore(DATA);
-		const pid = store.activeId();
-		const r = fn({ personaPath: store.materialize(pid), personaText: store.read(pid).body.trim(), root: DATA, reason: spec.reason }) ?? {};
-		const ok = verb === "install" ? r.ok !== false : r.ok !== false;
-		console.log(`${ok ? "✓" : "✗"} ${verb} ${h}${r.file ? ` → ${r.file}` : ""}${r.note ? `  (${r.note})` : ""}`);
+		let r;
+		if (verb === "install") {
+			const pid = store.activeId();
+			if (!pid) die("还没有 persona：先 agent-purge use <id>");
+			r = install(h, { root: DATA, active: store.refreshActive() }) ?? {};
+		} else {
+			// 卸载不能依赖 persona 还在：人设删了也必须能关
+			r = uninstall(h) ?? {};
+		}
+		const ok = !r.error;
+		console.log(`${ok ? "✓" : "✗"} ${verb} ${h}${r.file ? ` → ${r.file}` : ""}${r.note ? `  (${r.note})` : ""}${r.error ? `  ${r.error}` : ""}`);
 		if (ok) setArmed(DATA, h, "install", verb === "install");
 	}
 }
@@ -720,7 +725,8 @@ function help() {
          其他家没有这个能力：/purge 展开成用户消息，bench 实测 0/2 无效，所以不提供
    注入强度：只有 sys 层算。user 层（上下文块/用户消息）在 codex/claude/opencode/grok/hermes 实测都是 0/2，一律不提供。
 
-harness: pi, opencode, codex, claude, grok, omp, hermes, zcode, antigravity, qoder, workbuddy, codebuddy
+harness: pi, opencode, opencode2, dsh, codex, claude, grok, omp, hermes, zcode, antigravity, qoder, workbuddy, codebuddy
+          opencode2 = @opencode/cli 2.x（v2 插件 API），dsh = DeepSeek Harness（cordis 插件，desktop/web/headless 三形态）。
          qoder / workbuddy 无 prompt 组装入口（提示词在服务端），只能改上下文规则文件。
 `);
 }

package/lib/caps.mjs

@@ -46,6 +46,8 @@ const DESKTOP_FIRST = new Set(["zcode", "antigravity", "qoder", "workbuddy"]);
 	},
 	qoder: { shim: "提示词在服务端，本地拦不到" },
 	workbuddy: { shim: "提示词在服务端，本地拦不到" },
+	// dsh 的 CLI 只能起 headless：接管裸命令会把桌面/网页入口静默改道
+	dsh: { shim: "dsh 命令行只能起 headless：接管裸命令会让双击/网页入口变成终端会话；要三形态就装常驻插件（install）" },
 	codebuddy: {
 		install: "只有 settings.json（插件开关/模型），没有能把文本塞进提示的词条；实测只能走启动参数或壳",
 	},
@@ -62,6 +64,8 @@ const BLOCKED = { antigravity: "二进制补丁才能改它的系统提示，配
 const HOT = {
 	pi: { kind: "command", needs: "slash", how: "扩展钩子 before_agent_start：/purge 或改设置，下一轮生效" },
 	opencode: { kind: "state", needs: "install", how: "插件钩子 chat.system.transform 每轮读 state.json + active.md：改设置下一轮生效" },
+	dsh: { kind: "state", needs: "install", how: "cordis 插件每轮 assemble 读 state.json + active.md：改设置下一轮生效（desktop 装完要重启一次）" },
+	opencode2: { kind: "state", needs: "install", how: "v2 插件 ctx.session.hook('context') 每轮读 state.json + active.md：改设置下一轮生效" },
 };
 
 /** 没有每轮拼装点的：说明为什么只能重启 */
@@ -105,7 +109,7 @@ export function capsFor(id, ctx = {}) {
 				: `本机 PATH 里找不到 ${id}（先把它装到 PATH 上）`
 			: desktop
 				? `只对终端里敲 \`${id}\` 生效；桌面图标启动绕开 PATH`
-				: null;
+				: reason(id, "shim");
 
 	const t = persistTargets[id];
 	// user 层不算能力：写下去也压不住 harness 自己的身份，装了等于白装

package/lib/detect.mjs

@@ -14,6 +14,8 @@ export const specs = {
 	codebuddy: { bins: ["codebuddy"], homes: [["CODEBUDDY_HOME", ".codebuddy"]], version: ["--version"], marker: "history.jsonl" },
 	claude: { bins: ["claude"], homes: [["CLAUDE_CONFIG_DIR", ".claude"]], version: ["--version"], marker: "settings.json" },
 	opencode: { bins: ["opencode"], homes: [["XDG_CONFIG_HOME", ".config/opencode"]], version: ["--version"], marker: "opencode.json" },
+	opencode2: { bins: ["opencode2"], homes: [["XDG_CONFIG_HOME", ".config/opencode"]], version: ["--version"], marker: "opencode.json" },
+	dsh: { bins: ["dsh"], homes: [["DSH_HOME", ".dsh"]], version: ["--version"], marker: "profiles" },
 	grok: { bins: ["grok"], homes: [["GROK_HOME", ".grok"]], version: ["--version"], marker: "config.toml" },
 	omp: { bins: ["omp"], homes: [["OMP_HOME", ".omp"]], version: ["--version"], marker: "agent/config.yml" },
 	hermes: { bins: ["hermes"], homes: [["HERMES_HOME", "AppData/Local/hermes"]], version: ["--version"], marker: "hermes-agent" },

package/lib/dsh.mjs

@@ -0,0 +1,240 @@
+// dsh（DeepSeek Harness）的插件通道，三形态（desktop / web / headless）共用一套写法。
+//
+// 两个插件名，互不覆盖：
+//   agent-purge          常驻：每次 assemble 读 state.json + active.md，off 即时生效
+//   agent-purge-session  一次性：persona 快照编译进源码，进程退出即删
+//
+// 三个 profile 都要装：paths 推导自 profile 的 dirname（src/index.js → package root），
+// 所以包必须放在 <profile>/node_modules/<name> 下。
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const DSH_PROFILES = ["desktop", "web", "headless"];
+export const RESIDENT = "agent-purge";
+export const SESSION = "agent-purge-session";
+
+export const dshHome = () => process.env.DSH_HOME || join(homedir(), ".dsh");
+export const profileDir = (p) => join(dshHome(), "profiles", p);
+export const pluginDir = (p, name = RESIDENT) => join(profileDir(p), "node_modules", name);
+const patchFile = (p) => join(profileDir(p), "cordis.patch.yml");
+
+const mark = (name) => [`# >>> agent-purge:${name}`, `# <<< agent-purge:${name}`];
+
+/** 这个 package.json 是 agent-purge 写的吗（别碰同名外来目录）。 */
+const isOurs = (meta) => existsSync(meta) && /"?agentPurge"?\s*:\s*true/.test(readFileSync(meta, "utf8"));
+
+/** 常驻插件：不编译人设，每次请求现读 state；off 就把宿主的返回值原样透传。 */
+export function residentSource(root, activePath) {
+	const state = join(root, "state.json").replace(/\\/g, "/");
+	// active.md 是派生物，实际位置是 <root>/personas/active.md（由 createStore().materialize 给出）
+	const active = String(activePath).replace(/\\/g, "/");
+	return `// 由 agent-purge 生成；删掉本目录 + patch 段即取消。
+import { readFileSync, appendFileSync } from "node:fs";
+const STATE = ${JSON.stringify(state)};
+const ACTIVE = ${JSON.stringify(active)};
+const NAME = ${JSON.stringify(RESIDENT)};
+// 一行一条的运行日志，出问题先看它。写失败静默。
+const LOG = STATE.replace(/state\.json$/, "dsh.log");
+function log(ev, extra) {
+  try {
+    appendFileSync(LOG, new Date().toISOString() + " " + PROFILE + " " + ev + (extra ? " " + extra : "") + "\\n");
+  } catch { /* 只读环境不抛 */ }
+}
+// 自己在哪个 profile：<dsh>/profiles/<name>/node_modules/<pkg>/index.js
+const PROFILE = (() => {
+  try {
+    const m = /[\\\\/]profiles[\\\\/]([^\\\\/]+)[\\\\/]/.exec(new URL(import.meta.url).pathname);
+    return m ? decodeURIComponent(m[1]) : "";
+  } catch {
+    return "";
+  }
+})();
+function cfg() {
+  try {
+    const st = JSON.parse(readFileSync(STATE, "utf8"));
+    // 磁盘卸载后内存里的回调还在：armed 里没有任何 dsh 条目就当成已关闭
+    const armed = st && st.armed && st.armed.dsh;
+    if (!Array.isArray(armed) || !armed.includes("install")) return null;
+    // dshProfiles：没设置过 = desktop/web/headless 全开；设了 = 只认列出的那几个（可热改）
+    const on = st && Array.isArray(st.dshProfiles) ? st.dshProfiles : null;
+    if (on && (!PROFILE || !on.includes(PROFILE))) return null;
+    const mode = (st && st.default && st.default.mode) || "replace";
+    if (mode === "off") return null;
+    const body = readFileSync(ACTIVE, "utf8").trim();
+    return body ? { mode, body } : null;
+  } catch {
+    return null;
+  }
+}
+function put(asm, c) {
+  if (!asm || typeof asm !== "object") return asm;
+  const sections = Array.isArray(asm.sections) ? asm.sections : [];
+  if (c.mode === "append") return { ...asm, sections: [...sections, { name: NAME, text: c.body }] };
+  return { ...asm, sections: [{ name: NAME, text: c.body }] };
+}
+export default {
+  name: NAME,
+  inject: ["systemPrompt"],
+  apply(ctx) {
+    log("apply", "inject=" + JSON.stringify(["systemPrompt"]));
+    // 宿主每轮 assemble 走 system-prompt/assemble 瀑布。必须 global：agent 作用域的
+    // systemPrompt 是另一个实例，且切预设时宿主会整只换代理，实例上的 monkey-patch 会丢。
+    const handler = async (assembly, _context, next) => {
+      let assembled = assembly;
+      if (typeof next === "function") {
+        try {
+          assembled = await next();
+        } catch {
+          assembled = assembly; // 下游抛错也要让上游兜底，不能把整轮发消息弄死
+        }
+      }
+      const c = cfg();
+      const out = c ? put(assembled, c) : assembled;
+      log("assemble", (c ? "mode=" + c.mode : "off")
+        + " in=" + (Array.isArray(assembled && assembled.sections) ? assembled.sections.length : -1)
+        + " out=" + (Array.isArray(out && out.sections) ? out.sections.length : -1)
+        + " names=" + (Array.isArray(out && out.sections) ? out.sections.map((s) => s && s.name).join(",") : "-"));
+      return out;
+    };
+    try {
+      ctx.on("system-prompt/assemble", handler, { global: true, prepend: true });
+      log("hook", "system-prompt/assemble global");
+    } catch (e) {
+      // 老版本没有这个瀑布：退回包 assemble（关闭时同 this、同参数、同返回类型）
+      const prompt = ctx.systemPrompt;
+      const orig = prompt.assemble;
+      prompt.assemble = function (...rest) {
+        const c = cfg();
+        if (!c) return orig.apply(this, rest);
+        const out = orig.apply(this, rest);
+        if (out && typeof out.then === "function") return out.then((asm) => put(asm, c));
+        return put(out, c);
+      };
+    }
+  },
+};
+`;
+}
+
+/** 一次性插件：人设快照内嵌，进程结束就没。 */
+export function sessionSource(personaText, mode) {
+	const put =
+		mode === "append"
+			? `return { ...asm, sections: [...(Array.isArray(asm.sections) ? asm.sections : []), { name: NAME, text: PERSONA }] };`
+			: `return { ...asm, sections: [{ name: NAME, text: PERSONA }] };`;
+	return `// 由 agent-purge 生成（一次性，进程退出即删）。
+const PERSONA = ${JSON.stringify(personaText.trim())};
+const NAME = ${JSON.stringify(SESSION)};
+export default {
+  name: NAME,
+  inject: ["systemPrompt"],
+  apply(ctx) {
+    const prompt = ctx.systemPrompt;
+    const orig = prompt.assemble;
+    // 同常驻插件：不包 async，保持宿主的返回类型
+    prompt.assemble = function (...rest) {
+      const out = orig.apply(this, rest);
+      const put = (asm) => {
+        if (!asm || typeof asm !== "object") return asm;
+        ${put}
+      };
+      if (out && typeof out.then === "function") return out.then(put);
+      return put(out);
+    };
+  },
+};
+`;
+}
+
+/** 装一个插件名到三个 profile，并在 patch 里挂上（同一段 marker 幂等）。 */
+export function addPlugin(name, source) {
+	const pkg = JSON.stringify({ name, version: "0.0.0", type: "module", main: "index.js", agentPurge: true }, null, 1);
+	const [begin, end] = mark(name);
+	const block = `\n${begin}\n- insert:\n    - id: ${name}\n      name: ${name}\n${end}\n`;
+	const files = [];
+	const touched = []; // { dir, patch, before }：中途抛错时按相反顺序回滚
+	// 预检：同名目录要么不存在，要么是我们的（package.json 带 agentPurge 标记），否则不碰
+	for (const p of DSH_PROFILES) {
+		const dir = pluginDir(p, name);
+		const meta = join(dir, "package.json");
+		if (existsSync(dir) && !isOurs(meta)) throw new Error(`${dir} 已存在且不是 agent-purge 装的，拒绝覆盖`);
+	}
+	try {
+		for (const p of DSH_PROFILES) {
+			const dir = pluginDir(p, name);
+			const patch = patchFile(p);
+			const before = existsSync(patch) ? readFileSync(patch, "utf8") : null;
+			// 先登记再动手：下面任何一步抛错，这一轮的产物都能被回滚
+			touched.push({ dir, patch, before });
+			mkdirSync(dir, { recursive: true });
+			writeFileSync(join(dir, "package.json"), pkg);
+			writeFileSync(join(dir, "index.js"), source);
+			files.push(dir);
+			const old = before ?? "# agent-purge 新建的 patch 层\n";
+			if (old.includes(begin)) continue;
+			// `[]` 是合法空数组，后面接 `- insert:` 就是非法 YAML：整份换成我们的段
+			// 不存在也算“空”：走 stash 分支才能把“原本没有这个文件”记下来，卸载后才不会留个空壳
+			const empty = before === null || /^\s*(\[\s*\]\s*)?$/.test(old);
+			const next = empty ? block.slice(1) : old + block;
+			if (empty) {
+				// 整份替换会把原文端掉：原文 + 我们写出的成品都存下，卸载时对得上才整份还原
+				// （对不上 = 期间被人改过，那就只剔自己那段）
+				writeFileSync(join(dir, ".patch.before"), JSON.stringify({ before, after: next }));
+			}
+			writeFileSync(patch, next);
+		}
+	} catch (e) {
+		// 回滚：撤销本次已写的文件，宁可完全没装也不留半套
+		for (const { dir, patch, before } of touched.reverse()) {
+			rmSync(dir, { recursive: true, force: true });
+			if (before === null) rmSync(patch, { force: true });
+			else writeFileSync(patch, before);
+		}
+		throw e;
+	}
+	return { dirs: files, profiles: DSH_PROFILES };
+}
+
+/** 只撤自己那一段：目录 + patch marker，别的配置原样。 */
+export function removePlugin(name) {
+	const [begin, end] = mark(name);
+	// 删 install 写入的那一段：前导 \n 可有可无（整份替换的形态没有），尾随 \n 一并吃掉
+	const re = new RegExp(`(?:^|\\n)${begin}[\\s\\S]*?${end}\\n?`, "g");
+	for (const p of DSH_PROFILES) {
+		const dir = pluginDir(p, name);
+		const meta = join(dir, "package.json");
+		// 只删自己装的；同名但不是我们的目录留着（可能被用户或其他包占了）
+		const ours = isOurs(meta);
+		const stashFile = join(dir, ".patch.before");
+		// 当初整份替换过的：记录躲在插件目录里，先读出来，不然删目录就丢了
+		let stash = null;
+		if (ours && existsSync(stashFile)) {
+			try {
+				stash = JSON.parse(readFileSync(stashFile, "utf8"));
+			} catch {
+				stash = null;
+			}
+		}
+		if (ours) rmSync(dir, { recursive: true, force: true });
+		const patch = patchFile(p);
+		if (!existsSync(patch)) continue;
+		const text = readFileSync(patch, "utf8");
+		// 我们整份写的、且此后没人动过 → 整份还原（原本没这个文件就删掉它）
+		if (stash && text === stash.after) {
+			if (stash.before === null) rmSync(patch, { force: true });
+			else writeFileSync(patch, stash.before);
+			continue;
+		}
+		if (text.includes(begin)) writeFileSync(patch, text.replace(re, ""));
+	}
+}
+
+/** patch 里还挂着这个名字吗（status 用；不许在有其他 insert 时谎报干净）。 */
+export function hasPlugin(name) {
+	const [begin] = mark(name);
+	return DSH_PROFILES.every((p) => {
+		const patch = patchFile(p);
+		return existsSync(join(pluginDir(p, name), "index.js")) && existsSync(patch) && readFileSync(patch, "utf8").includes(begin);
+	});
+}

package/lib/persist.mjs

@@ -3,10 +3,13 @@
 // 不动二进制——这里只做可逆的配置改动。
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { RESIDENT as DSH_RESIDENT, SESSION as DSH_SESSION, addPlugin, hasPlugin, pluginDir, residentSource, removePlugin } from "./dsh.mjs";
 
 const BEGIN = "# >>> agent-purge";
 const END = "# <<< agent-purge";
 const home = process.env.USERPROFILE || process.env.HOME;
+// opencode 认 XDG_CONFIG_HOME（lib/detect.mjs 也是这么探测的）：两处必须同一个落点，否则装了白装
+export const opencodePlugins = () => join(process.env.XDG_CONFIG_HOME || join(home, ".config"), "opencode", "plugins");
 
 export const targets = {
 	pi: {
@@ -67,8 +70,10 @@ export const targets = {
 	},
 	opencode: {
 		// 写入用全局单一位置；读取/删除要扫全部历史位置，否则老版本留下的项目级插件会继续注入
-		file: () => join(home, ".config", "opencode", "plugins", "agent-purge.ts"),
+		file: () => join(opencodePlugins(), "agent-purge.ts"),
 		files: () => [
+			join(opencodePlugins(), "agent-purge.ts"),
+			// 旧落点：设了 XDG 的机器上，老版本写在 home/.config 的那份也得能被扫到并清掉
 			join(home, ".config", "opencode", "plugins", "agent-purge.ts"),
 			join(home, ".config", "opencode", "plugin", "agent-purge.ts"),
 			join(process.cwd(), ".opencode", "plugin", "agent-purge.ts"),
@@ -99,6 +104,62 @@ export const AgentPurge = async () => ({
     else output.system.splice(0, output.system.length, c.body);
   },
 });
+`,
+	},
+	dsh: {
+		// cordis 插件挂 systemPrompt 层；三个 profile 各一份（desktop 由 Electron 独占，装完要重启一次）
+		file: () => join(pluginDir("desktop"), "index.js"),
+		kind: "file",
+		layer: "sys",
+		note: "cordis 插件包；运行时读 state.json，off 即时生效；desktop 需重启一次",
+		probe: () => hasPlugin(DSH_RESIDENT),
+		install: ({ root, active }) => {
+			const r = addPlugin(DSH_RESIDENT, residentSource(root, active));
+			return { file: join(pluginDir("desktop"), "index.js"), note: `三个 profile：${r.profiles.join("/")}；desktop 重启 DeepSeek Harness 生效` };
+		},
+		uninstall: () => {
+			removePlugin(DSH_RESIDENT);
+			// 一次性插件被 SIGKILL 时不会自己清，一并扫掉
+			removePlugin(DSH_SESSION);
+			return { file: join(pluginDir("desktop"), "index.js") };
+		},
+	},
+	opencode2: {
+		// v2 新版插件 API（V1 的 experimental.chat.system.transform 在 2.x 已废），与 V1 插件文件物理分开
+		file: () => join(opencodePlugins(), "agent-purge-v2.ts"),
+		files: () => [join(opencodePlugins(), "agent-purge-v2.ts"), join(opencodePlugins(), "agent-purge-v2-session.ts")],
+		kind: "file",
+		layer: "sys",
+		note: "v2 插件 ctx.session.hook(\"context\")；运行时读 state.json，热切",
+		body: (active, root) => `import { readFileSync } from "node:fs";
+// agent-purge 托管文件：删除即可取消
+const STATE = ${JSON.stringify(join(root, "state.json").replace(/\\/g, "/"))};
+const ACTIVE = ${JSON.stringify(String(active).replace(/\\/g, "/"))};
+function cfg() {
+  try {
+    const st = JSON.parse(readFileSync(STATE, "utf8"));
+    // 磁盘卸载后服务里已加载的回调还在：armed 没了就当成已关闭
+    const armed = st && st.armed && st.armed.opencode2;
+    if (!Array.isArray(armed) || !armed.includes("install")) return null;
+    const mode = (st && st.default && st.default.mode) || "replace";
+    if (mode === "off") return null;
+    const body = readFileSync(ACTIVE, "utf8").trim();
+    return body ? { mode, body } : null;
+  } catch {
+    return null;
+  }
+}
+export default {
+  id: "agent-purge",
+  async setup(ctx) {
+    await ctx.session.hook("context", (event) => {
+      const c = cfg();
+      if (!c) return;
+      if (c.mode === "append") event.system.push({ type: "text", text: c.body });
+      else event.system.splice(0, event.system.length, { type: "text", text: c.body });
+    });
+  },
+};
 `,
 	},
 };
@@ -106,6 +167,8 @@ export const AgentPurge = async () => ({
 export function status(_root) {
 	return Object.entries(targets).map(([name, t]) => {
 		const file = t.file();
+		// 自定义探针（多文件目标用），优先于默认的存在性判断
+		if (t.probe) return { name, installed: t.probe(), file };
 		const candidates = t.files ? t.files() : [file];
 		const present = candidates.filter((f) => existsSync(f));
 		if (!present.length) return { name, installed: false, file };
@@ -121,6 +184,15 @@ export function status(_root) {
 export function install(name, { root, active }) {
 	const t = targets[name];
 	if (!t) return { error: `${name} 没有持久化后端（见 notes：grok/omp 只有 CLI 开关，claude/zcode/antigravity 要打补丁）` };
+	// 多文件/自定义布局的 harness 自带安装函数（dsh 三个 profile、opencode2 v2 插件）
+	// 它们的失败信号是异常（同名外来目录拒绝覆盖等），这里转成调用方约好的 {error}
+	if (t.install) {
+		try {
+			return { ...t.install({ root, active }), action: "custom" };
+		} catch (e) {
+			return { error: e.message };
+		}
+	}
 	const file = t.file();
 	mkdirSync(dirname(file), { recursive: true });
 	if (t.kind === "file") {
@@ -136,6 +208,13 @@ export function install(name, { root, active }) {
 export function uninstall(name) {
 	const t = targets[name];
 	if (!t) return { error: `${name} 没有持久化后端` };
+	if (t.uninstall) {
+		try {
+			return { ...t.uninstall(), action: "custom" };
+		} catch (e) {
+			return { error: e.message };
+		}
+	}
 	if (t.kind === "file") {
 		// 清掉所有历史位置，保证“关掉”之后没有任何残留插件还在注入
 		const candidates = t.files ? t.files() : [t.file()];

package/lib/state.mjs

@@ -1,140 +1,155 @@
-// 唯一状态文件。
-//
-// 之前是两套：`.defaults.json`（harness+mode）与 `personas/.active`（人设指针），
-// 两个文件、两套语义、Web 与 CLI 各写一边 —— 这就是"用起来混乱"的根源：
-// 用户改了一处以为全生效，其实另一处还压着旧值。
-//
-// 现在只有 state.json：
-//   persona  谁      —— 当前 persona id（人设的唯一指针）
-//   default  注入谁   —— 裸敲 agent-purge 时启动的 harness + 注入模式
-//   armed    怎么生效 —— 每家已经武装了哪几条通道：shim / slash / install
-//
-// personas/active.md 退化为「派生物」：由 launch/arm 时按 persona 生成，
-// 供落盘型 harness 与 opencode 插件读取，不再承载状态。
-import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-const FILE = "state.json";
-const LEGACY_DEFAULTS = ".defaults.json";
-const LEGACY_ACTIVE = join("personas", ".active");
-
-export const MODES = ["strict", "replace", "append", "off"];
-/** 三种生效通道，互不冲突，可以叠加 */
-export const ARMS = ["shim", "slash", "install"];
-
-export const ARM_LABEL = {
-	shim: "裸命令接管（敲 codex 就是接管的）",
-	slash: "会话内 /purge（热切换）",
-	install: "配置文件常驻（连别人启动的也生效）",
-};
-
-export function statePath(root) {
-	return join(root, FILE);
-}
-
-function emptyState() {
-	return { v: 1, persona: null, default: null, armed: {}, piAuto: false, piUserLayer: false };
-}
-
-/**
- * 读状态，顺带把旧布局迁移过来（旧文件改名 `*.migrated` 留档，之后只认 state.json）。
- * 返回 `{ state, migrated[] }`；migrated 是给调用方打印的一行行说明。
- */
-export function loadState(root) {
-	const file = statePath(root);
-	let state = emptyState();
-	const migrated = [];
-
-	if (existsSync(file)) {
-		try {
-			const raw = JSON.parse(readFileSync(file, "utf8"));
-			state = { ...state, ...raw, armed: raw?.armed && typeof raw.armed === "object" ? raw.armed : {} };
-		} catch {
-			migrated.push("state.json 损坏 → 按空状态重来");
-		}
-	}
-
-	const legacy = join(root, LEGACY_DEFAULTS);
-	if (!state.default && existsSync(legacy)) {
-		try {
-			const d = JSON.parse(readFileSync(legacy, "utf8"));
-			if (d?.harness) {
-				state.default = { harness: d.harness, mode: MODES.includes(d.mode) ? d.mode : "replace" };
-				migrated.push(`.defaults.json → default=${state.default.harness} · ${state.default.mode}`);
-			}
-			renameSync(legacy, legacy + ".migrated");
-		} catch {
-			/* 坏文件不动它，留给人工看 */
-		}
-	}
-
-	if (!state.persona) {
-		const old = join(root, LEGACY_ACTIVE);
-		if (existsSync(old)) {
-			const id = readFileSync(old, "utf8").trim();
-			if (id) {
-				state.persona = id;
-				migrated.push(`personas/.active → persona=${id}`);
-			}
-			renameSync(old, old + ".migrated");
-		}
-	}
-
-	// 迁完立即落盘：否则下次调用看不到旧文件，迁移结果直接丢掉
-	if (migrated.length) writeFileSync(file, JSON.stringify(state, null, 2) + "\n");
-
-	return { state, migrated };
-}
-
-export function saveState(root, state) {
-	writeFileSync(statePath(root), JSON.stringify(state, null, 2) + "\n");
-	return state;
-}
-
-/** 浅合并；armed 需要整块替换时传完整对象 */
-export function patchState(root, patch) {
-	const { state } = loadState(root);
-	return saveState(root, { ...state, ...patch });
-}
-
-export function setDefault(root, { harness, mode }) {
-	if (!harness) throw new Error("harness 不能为空");
-	const { state } = loadState(root);
-	const next = { ...state, default: { harness, mode: MODES.includes(mode) ? mode : "replace" } };
-	return saveState(root, next).default;
-}
-
-export function setPersona(root, id) {
-	const { state } = loadState(root);
-	return saveState(root, { ...state, persona: id }).persona;
-}
-
-/** 裸敲 pi 是否也自动注入（装好的扩展直接读这个位） */
-export function setPiAuto(root, on) {
-	const { state } = loadState(root);
-	return saveState(root, { ...state, piAuto: on === true }).piAuto;
-}
-
-/** pi 的人设走哪一层：false = system（默认），true = 额外塞进用户消息（给忽略 system 的模型用） */
-export function setPiUserLayer(root, on) {
-	const { state } = loadState(root);
-	return saveState(root, { ...state, piUserLayer: on === true }).piUserLayer;
-}
-
-/** armed 变成 {codex: ["shim","install"]}；空数组即删键 */
-export function setArmed(root, id, arm, on) {
-	const { state } = loadState(root);
-	const cur = new Set(state.armed?.[id] ?? []);
-	if (on) cur.add(arm);
-	else cur.delete(arm);
-	const list = ARMS.filter((a) => cur.has(a));
-	const armed = { ...state.armed };
-	if (list.length) armed[id] = list;
-	else delete armed[id];
-	saveState(root, { ...state, armed });
-	return list;
-}
-
-export function armedOf(state, id) {
-	return state.armed?.[id] ?? [];
-}
+// 唯一状态文件。
+//
+// 之前是两套：`.defaults.json`（harness+mode）与 `personas/.active`（人设指针），
+// 两个文件、两套语义、Web 与 CLI 各写一边 —— 这就是"用起来混乱"的根源：
+// 用户改了一处以为全生效，其实另一处还压着旧值。
+//
+// 现在只有 state.json：
+//   persona  谁      —— 当前 persona id（人设的唯一指针）
+//   default  注入谁   —— 裸敲 agent-purge 时启动的 harness + 注入模式
+//   armed    怎么生效 —— 每家已经武装了哪几条通道：shim / slash / install
+//
+// personas/active.md 退化为「派生物」：由 launch/arm 时按 persona 生成，
+// 供落盘型 harness 与 opencode 插件读取，不再承载状态。
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+const FILE = "state.json";
+const LEGACY_DEFAULTS = ".defaults.json";
+const LEGACY_ACTIVE = join("personas", ".active");
+
+export const MODES = ["strict", "replace", "append", "off"];
+/** 三种生效通道，互不冲突，可以叠加 */
+export const ARMS = ["shim", "slash", "install"];
+
+export const ARM_LABEL = {
+	shim: "裸命令接管（敲 codex 就是接管的）",
+	slash: "会话内 /purge（热切换）",
+	install: "配置文件常驻（连别人启动的也生效）",
+};
+
+export function statePath(root) {
+	return join(root, FILE);
+}
+
+function emptyState() {
+	return { v: 1, persona: null, default: null, armed: {}, piAuto: false, piUserLayer: false, dshProfiles: null };
+}
+
+/**
+ * 读状态，顺带把旧布局迁移过来（旧文件改名 `*.migrated` 留档，之后只认 state.json）。
+ * 返回 `{ state, migrated[] }`；migrated 是给调用方打印的一行行说明。
+ */
+export function loadState(root) {
+	const file = statePath(root);
+	let state = emptyState();
+	const migrated = [];
+
+	if (existsSync(file)) {
+		try {
+			const raw = JSON.parse(readFileSync(file, "utf8"));
+			state = { ...state, ...raw, armed: raw?.armed && typeof raw.armed === "object" ? raw.armed : {} };
+		} catch {
+			migrated.push("state.json 损坏 → 按空状态重来");
+		}
+	}
+
+	const legacy = join(root, LEGACY_DEFAULTS);
+	if (!state.default && existsSync(legacy)) {
+		try {
+			const d = JSON.parse(readFileSync(legacy, "utf8"));
+			if (d?.harness) {
+				state.default = { harness: d.harness, mode: MODES.includes(d.mode) ? d.mode : "replace" };
+				migrated.push(`.defaults.json → default=${state.default.harness} · ${state.default.mode}`);
+			}
+			renameSync(legacy, legacy + ".migrated");
+		} catch {
+			/* 坏文件不动它，留给人工看 */
+		}
+	}
+
+	if (!state.persona) {
+		const old = join(root, LEGACY_ACTIVE);
+		if (existsSync(old)) {
+			const id = readFileSync(old, "utf8").trim();
+			if (id) {
+				state.persona = id;
+				migrated.push(`personas/.active → persona=${id}`);
+			}
+			renameSync(old, old + ".migrated");
+		}
+	}
+
+	// 迁完立即落盘：否则下次调用看不到旧文件，迁移结果直接丢掉
+	if (migrated.length) writeFileSync(file, JSON.stringify(state, null, 2) + "\n");
+
+	return { state, migrated };
+}
+
+export function saveState(root, state) {
+	writeFileSync(statePath(root), JSON.stringify(state, null, 2) + "\n");
+	return state;
+}
+
+/** 浅合并；armed 需要整块替换时传完整对象 */
+export function patchState(root, patch) {
+	const { state } = loadState(root);
+	return saveState(root, { ...state, ...patch });
+}
+
+export function setDefault(root, { harness, mode }) {
+	if (!harness) throw new Error("harness 不能为空");
+	const { state } = loadState(root);
+	const next = { ...state, default: { harness, mode: MODES.includes(mode) ? mode : "replace" } };
+	return saveState(root, next).default;
+}
+
+export function setPersona(root, id) {
+	const { state } = loadState(root);
+	return saveState(root, { ...state, persona: id }).persona;
+}
+
+/** 裸敲 pi 是否也自动注入（装好的扩展直接读这个位） */
+export function setPiAuto(root, on) {
+	const { state } = loadState(root);
+	return saveState(root, { ...state, piAuto: on === true }).piAuto;
+}
+
+/** pi 的人设走哪一层：false = system（默认），true = 额外塞进用户消息（给忽略 system 的模型用） */
+export function setPiUserLayer(root, on) {
+	const { state } = loadState(root);
+	return saveState(root, { ...state, piUserLayer: on === true }).piUserLayer;
+}
+
+/** armed 变成 {codex: ["shim","install"]}；空数组即删键 */
+export function setArmed(root, id, arm, on) {
+	const { state } = loadState(root);
+	const cur = new Set(state.armed?.[id] ?? []);
+	if (on) cur.add(arm);
+	else cur.delete(arm);
+	const list = ARMS.filter((a) => cur.has(a));
+	const armed = { ...state.armed };
+	if (list.length) armed[id] = list;
+	else delete armed[id];
+	saveState(root, { ...state, armed });
+	return list;
+}
+
+export function armedOf(state, id) {
+	return state.armed?.[id] ?? [];
+}
+
+/** dsh 三个 profile 哪些生效：null = 没设置过（全部），[] = 全关 */
+export function dshProfilesOf(state) {
+	return Array.isArray(state?.dshProfiles) ? state.dshProfiles : null;
+}
+
+/** 开/关单个 dsh profile；all 由调用方传入（列表归属 lib/dsh.mjs，别在状态层再写一份） */
+export function setDshProfile(root, profile, on, all) {
+	const { state } = loadState(root);
+	const cur = new Set(dshProfilesOf(state) ?? all);
+	if (on) cur.add(profile);
+	else cur.delete(profile);
+	const list = all.filter((p) => cur.has(p));
+	return saveState(root, { ...state, dshProfiles: list }).dshProfiles;
+}

package/matrix.json

@@ -2,6 +2,30 @@
 	"note": "每个数字都来自 agent-purge 的方法：本地假 provider 抓请求，或 harness 自带日志。更新时改这里，不要改 README 表格。",
 	"personasDir": "personas",
 	"harnesses": {
+		"dsh": {
+			"class": "plugin",
+			"override": true,
+			"inject": true,
+			"hotSwitch": true,
+			"patch": false,
+			"launcher": "dsh（三个 profile 各放 node_modules/agent-purge 插件，cordis.patch.yml 里 - insert 挂载；不碰 app.asar）",
+			"defaultSystemChars": 5713,
+			"purgedSystemChars": 68,
+			"measuredVersion": "0.2.1-rc.2",
+			"verify": "本地假 provider 抓请求体：headless / desktop / web 三形态各验一遍，插件 canary 进 system（本机走 developer 角色）"
+		},
+		"opencode2": {
+			"class": "plugin",
+			"override": true,
+			"inject": true,
+			"hotSwitch": true,
+			"patch": false,
+			"launcher": "opencode2（~/.config/opencode/plugins/agent-purge-v2.ts，ctx.session.hook(\"context\") 改 event.system）",
+			"defaultSystemChars": 8279,
+			"purgedSystemChars": 3189,
+			"measuredVersion": "0.0.0-beta-17823",
+			"verify": "本地假 provider 抓请求体：canary 进 role=system 消息（--print-logs 可看到 v2 插件加载）"
+		},
 		"pi": {
 			"class": "native-extension",
 			"override": true,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-purge",
-  "version": "0.2.2",
-  "description": "One persona, many coding agents: replace or inject system prompts across codex, claude, opencode, grok, omp, hermes, pi, zcode.",
+  "version": "0.2.4",
+  "description": "One persona, many coding agents: replace or inject system prompts across codex, claude, opencode (v1/v2), grok, omp, hermes, pi, zcode, dsh.",
   "type": "module",
   "bin": {
     "agent-purge": "bin/agent-purge.mjs"
@@ -23,6 +23,7 @@
     "web": "node bin/agent-purge.mjs web",
     "matrix": "node bin/agent-purge.mjs matrix",
     "detect": "node bin/agent-purge.mjs detect",
+    "test": "node magpie-plugin/selftest.mjs && node magpie-plugin/test-page.mjs && node test/harness-adapters.test.mjs",
     "build:exe": "node scripts/build-exe.mjs",
     "prepack": "node -e \"require('node:fs').rmSync('personas/.build',{recursive:true,force:true})\""
   },
@@ -31,6 +32,8 @@
     "codex",
     "claude",
     "opencode",
+    "dsh",
+    "deepseek-harness",
     "coding-agent",
     "pi",
     "persona",

package/web/server.mjs

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 import { detect } from "../lib/detect.mjs";
 import { oneshots } from "../backends/index.mjs";
 import { createStore } from "../lib/personas.mjs";
-import { MODES, armedOf, loadState, patchState, setArmed, setDefault, setPersona, setPiAuto } from "../lib/state.mjs";
+import { MODES, armedOf, dshProfilesOf, loadState, patchState, setArmed, setDefault, setPersona, setPiAuto, setDshProfile } from "../lib/state.mjs";
 import { install, status as persistStatus, uninstall } from "../lib/persist.mjs";
 import { plans, summary as armorSummary } from "../lib/armor.mjs";
 import { installShim, shimStatus, uninstallShim } from "../lib/shim.mjs";
@@ -14,6 +14,7 @@ import { installSlash, refreshSlashes, slashStatus, uninstallSlash } from "../li
 import { reconcileArmed } from "../lib/armed.mjs";
 import { capsFor } from "../lib/caps.mjs";
 import { ensureDataHome } from "../lib/home.mjs";
+import { DSH_PROFILES } from "../lib/dsh.mjs";
 
 const ROOT = process.versions.bun ? dirname(process.execPath) : dirname(dirname(fileURLToPath(import.meta.url)));
 // 数据（state.json + personas/）在用户目录，不在安装目录
@@ -55,6 +56,7 @@ async function handle(req, res) {
 	if (req.method === "GET" && p === "/api/armor") return send(res, 200, armorState());
 	if (req.method === "POST" && p === "/api/defaults") return send(res, 200, saveDefaults(await body(req)));
 	if (req.method === "POST" && p === "/api/pi-auto") return send(res, 200, { piAuto: setPiAuto(DATA, (await body(req)).on === true) });
+	if (req.method === "POST" && p === "/api/dsh-profile") return send(res, 200, saveDshProfile(await body(req)));
 	if (req.method === "POST" && p === "/api/persona") return send(res, 200, savePersona(await body(req)));
 	if (req.method === "DELETE" && p === "/api/persona") return send(res, 200, deletePersona(url.searchParams.get("id")));
 	if (req.method === "POST" && p === "/api/use") return send(res, 200, usePersona(await body(req)));
@@ -137,6 +139,9 @@ async function state(withVersions) {
 		// false = state.json 里还没有默认（defaults 只是 UI 的建议值，裸敲 agent-purge 仍会提示“未设置”）
 		defaultsSet: Boolean(st.default?.harness),
 		armed: st.armed ?? {},
+		// dsh 的三个 profile（desktop/web/headless）；null 就是全开
+		dshProfiles: dshProfilesOf(st) ?? DSH_PROFILES,
+		dshAll: DSH_PROFILES,
 		modes: MODES,
 		piAuto: st.piAuto === true,
 		shimDir: shimStatus()[0]?.dir ?? null,
@@ -173,6 +178,16 @@ function saveDefaults(payload) {
 	}
 }
 
+function saveDshProfile(payload) {
+	const profile = String(payload.profile || "").trim();
+	if (!DSH_PROFILES.includes(profile)) return { error: `未知 profile: ${profile}（${DSH_PROFILES.join(" / ")}）` };
+	try {
+		return { ok: true, dshProfiles: setDshProfile(DATA, profile, payload.on === true, DSH_PROFILES) };
+	} catch (e) {
+		return { error: e.message };
+	}
+}
+
 function savePersona(payload) {
 	const id = String(payload.id || "").trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-");
 	if (!id) return { error: "id 不能为空（小写字母/数字/-/_）" };

package/web/ui.html

@@ -260,6 +260,11 @@ h3{margin:0 0 10px;font-family:var(--font-display);font-size:16px;font-weight:60
 white-space:nowrap;overflow:hidden;text-overflow:ellipsis;text-align:left}
 .chan.on{border-color:var(--accent);background:var(--accent-soft)}
 .chan.on .dot{background:var(--accent)}
+.dprof{display:flex;align-items:center;gap:8px;margin-top:10px;flex-wrap:wrap}
+.dprof-k{font-size:11.5px;color:var(--ink-2);letter-spacing:.02em}
+.chan.mini{padding:7px 11px;align-items:center;gap:7px}
+.chan.mini .dot{margin-top:0}
+.chan.mini b{font-size:12px;font-weight:600}
 .chan.on b u{color:var(--accent);border-color:var(--accent-line)}
 .chan.dis{opacity:.62;cursor:not-allowed}
 /* 结构性做不到（不是“没开”）：虚线 + 不跟手，和“关了”区分开 */
@@ -820,6 +825,19 @@ function harnessCard(h) {
 
   const noChannel = h.caps ? !(h.caps.shim.ok || h.caps.install.ok || h.caps.slash.ok) : false;
 
+  // dsh 的 desktop / web / headless 是三个独立 profile，插件分别装在三处；
+  // 这里只改 state.json，插件每次 assemble 现读，下一轮就生效，不用重启。
+  const dshList = S.dshAll || ["desktop", "web", "headless"];
+  const profileRow = h.id === "dsh"
+    ? `<div class="dprof">
+        <span class="dprof-k">生效形态 <i class="hint" title="dsh 三个形态各用一个 profile 目录，插件装在三处。勾选只改 state.json 的 dshProfiles，下一轮即生效">?</i></span>
+        ${dshList.map((p) => {
+          const on = (S.dshProfiles || []).includes(p);
+          return `<button class="chan mini ${on ? "on" : ""}" data-dshprofile="${esc(p)}" data-on="${on ? "off" : "on"}" type="button"><span class="dot"></span><span><b>${esc(p)}</b></span></button>`;
+        }).join("")}
+      </div>`
+    : "";
+
   return `<div class="hc ${h.found ? "" : "dead"}">
     <div class="hhead">
       <span class="hname"><span class="st ${h.armed && h.armed.length ? "on" : ""}"></span>${esc(h.id)}</span>
@@ -839,6 +857,7 @@ function harnessCard(h) {
     </div>
     ${notes.length ? `<div class="hnote">${notes.map(esc).join("<br>")}</div>` : ""}
     <div class="chans">${chans}</div>
+    ${profileRow}
   </div>`;
 }
 function recommendMode(h) {
@@ -1051,6 +1070,19 @@ $("#selbar").addEventListener("click", async (e) => {
   });
 });
 async function onChan(e) {
+  // dsh 的三个形态：勾/取消只改 state.json，不动磁盘，所以是即时可逆的
+  const pb = e.target.closest("[data-dshprofile]");
+  if (pb) {
+    const profile = pb.dataset.dshprofile;
+    const on = pb.dataset.on === "on";
+    try {
+      await api("/api/dsh-profile", { method: "POST", headers: { "content-type": "application/json" },
+        body: JSON.stringify({ profile, on }) });
+      toast(`dsh · ${profile} ${on ? "已开" : "已关"}`);
+      await load();
+    } catch (err) { toast("失败：" + err.message, true); }
+    return;
+  }
   const b = e.target.closest("[data-chan]"); if (!b) return;
   const { chan, h } = b.dataset;
   const on = S.harnesses.find((x) => x.id === h)?.armed?.includes(chan);