@1e0zj/dsh-plugin-mall 0.2.0 → 0.3.0

package/README.md

@@ -15,7 +15,7 @@ Curated lists only show what has been reviewed and merged. This marketplace is o
 - **Anti-squatting** — an install prefers the npm tarball only when the registry entry's `repository` URL points back to the same GitHub repo; anything else falls back to the explicit `github:` spec.
 - **npm-first installs** — registry tarballs are smaller than whole-repo GitHub downloads and come with integrity checks. Lookups follow the registry pnpm actually installs from (profile `.npmrc` → `pnpm config get registry` → npmjs), so a mirror user keeps npm-first instead of silently falling back to whole-repo clones.
 - **Update management** — installed plugins are compared against the registry `latest`; one-click update per plugin.
-- **Conflict guard** — every install runs an isolated preflight first: the candidate is installed with scripts disabled into a throwaway directory and scanned against the live profile for loader-id collisions, double mounts, host-module shadowing and version/OS/peer ranges. A hard conflict is blocked, warnings require explicit confirmation. The profile's load-bearing files are snapshotted before `pnpm` touches them and restored on failure, and a host-independent CLI guards startup: launched through `guard launch`, a pending install is committed only after dsh survives a grace window, and rolled back + restarted once when it crashes inside it (see [Startup protection](#startup-protection-guard-cli)).
+- **Conflict guard** — every install runs an isolated preflight first: the candidate is installed with scripts disabled into a throwaway directory and scanned against the live profile for loader-id collisions, double mounts, host-module shadowing and version/OS/peer ranges. A hard conflict is blocked, warnings require explicit confirmation. The profile's load-bearing files are snapshotted before `pnpm` touches them and restored on failure. A pending install is resolved on the next start, however you start it: this plugin runs recovery as it loads, which only happens because dsh booted far enough to compose the profile. Starting through `guard launch` adds a grace window on top, so a plugin that boots and then crashes seconds later is rolled back and restarted once (see [Startup protection](#startup-protection-guard-cli)).
 - **Resilience** — rate-limit circuit breaker, GitHub's 1000-result search window handled gracefully, `corepack enable pnpm` self-heal when pnpm is missing, one-click dsh restart (loopback-only, `allowRestart: false` to disable).
 
 ## Install
@@ -71,7 +71,15 @@ node <profile>/node_modules/@1e0zj/dsh-plugin-mall/src/cli.js guard add <spec> -
 node <profile>/node_modules/@1e0zj/dsh-plugin-mall/src/cli.js guard launch --profile web -- dsh web
 ```
 
-**You must start dsh through the guard wrapper to get startup protection.** `guard launch` checks the profile's pending-install marker before starting the command after `--`:
+**A plain `dsh web` already resolves pending installs.** The marketplace plugin runs
+recovery when it loads: reaching that point proves dsh booted far enough to compose
+the profile, so the pending marker is committed (or rolled back when the profile
+fails validation). Without this a single install would wedge the profile — every
+later install and uninstall refuses while a marker is outstanding.
+
+**`guard launch` is still strictly better**, because it also covers what a plain
+start cannot: a plugin that boots fine and then crashes seconds later. It checks the
+profile's pending-install marker before starting the command after `--`:
 
 - **No pending install** — the command runs as-is, inheriting the terminal, and its exit code is preserved.
 - **Clearly broken on disk** — the profile is rolled back to its pre-install snapshot *before* launch, then the command starts on the restored state.
@@ -105,7 +113,7 @@ Limitations: the grace window is the probation period — a failure that only su
 - **防抢注**：仅当 npm registry 条目的 `repository` 指回同一 GitHub 仓库时才用 npm 安装，否则回退 `github:` 源
 - **npm 优先安装**：registry tarball 比整仓库下载更小且带完整性校验；查询用的 registry 跟随 pnpm 实际安装源（profile `.npmrc` → `pnpm config get registry` → npmjs），换了镜像也不会退化成整仓库克隆
 - **更新管理**：已装插件与 registry `latest` 比对，逐个一键更新
-- **冲突防护**：每次安装先跑隔离预检——候选包在一次性目录里以禁用脚本的方式装好后，对照 live profile 扫描 loader-id 冲突、重复挂载、宿主模块遮蔽和版本/OS/peer 范围；硬冲突直接拦截，警告需显式确认。安装前给 profile 的承重文件拍快照、失败即回滚；另有一个独立于宿主的 CLI 守启动——经 `guard launch` 启动的 dsh 只有在活过观察期后才提交 pending 安装，观察期内崩溃则回滚并原样重启一次（见下方「启动保护」）。
+- **冲突防护**：每次安装先跑隔离预检——候选包在一次性目录里以禁用脚本的方式装好后，对照 live profile 扫描 loader-id 冲突、重复挂载、宿主模块遮蔽和版本/OS/peer 范围；硬冲突直接拦截，警告需显式确认。安装前给 profile 的承重文件拍快照、失败即回滚；pending 安装在下次启动时自动了结，**不挑启动方式**：本插件加载时就跑恢复，而能加载本身就证明 dsh 已经组装好 profile、活到了这一步。经 `guard launch` 启动则多一层观察期——插件启动几秒后才崩的情况也能回滚并原样重启一次（见下方「启动保护」）。
 - **工程韧性**：限流熔断、GitHub 5xx/超时退避重试（504 瞬时故障不再直达用户）、GitHub 1000 条搜索上限优雅处理、pnpm 缺失时 `corepack` 自愈、一键重启 dsh（仅 loopback，可 `allowRestart: false` 关闭）
 
 ## 安装
@@ -182,7 +190,13 @@ node <profile>/node_modules/@1e0zj/dsh-plugin-mall/src/cli.js guard add <spec> -
 node <profile>/node_modules/@1e0zj/dsh-plugin-mall/src/cli.js guard launch --profile web -- dsh web
 ```
 
-**必须经由 guard 包装器启动 dsh 才有启动期保护。** `guard launch` 在启动 `--` 之后的命令前检查该 profile 的 pending 安装标记：
+**普通的 `dsh web` 就会了结 pending 安装。** 本插件加载时即执行恢复——能加载
+本身就证明 dsh 已经组装好 profile、启动到了这一步，于是提交 pending 标记
+（profile 校验不过则回滚）。没有这一步的话，装完一个插件就会把 profile 卡住：
+只要标记还在，之后所有安装和卸载都会被拒绝。
+
+**`guard launch` 仍然更强**，因为它覆盖普通启动覆盖不了的情况：插件启动正常、
+几秒后才崩。它在启动 `--` 之后的命令前检查该 profile 的 pending 安装标记：
 
 - **无 pending 安装** —— 命令原样运行（继承终端），透传退出码；
 - **静态校验明显过不了** —— 启动*之前*先把 profile 回滚到安装前快照，再在恢复后的状态上启动；
@@ -220,6 +234,22 @@ node <profile>/node_modules/@1e0zj/dsh-plugin-mall/src/cli.js guard launch --pro
   （这行会出现在任务日志里）。更新检查读的是 registry 的 `/latest` 端点，
   不经过该策略，所以两边看到的「最新版本」本就可能不同。
   首次安装（卡片按钮）不带版本，沿用 pnpm 的策略默认值即可。
+- **启用 / 停用，不必卸载**：已装面板每行一个开关，关掉即刻卸载该插件的
+  fiber，重新打开时它、以及因依赖它而挂起的插件都会回来。三层落地：内存用
+  `entry.update({disabled})`；持久化改写 profile 的 `cordis.patch.yml`（保留
+  注释），由 dsh 自己的 `watchUserPatches` 事务性重放，所以重启后状态保持；
+  写入前自动备份到 `<profile>/backups/`（留最近 20 份）。
+  市场插件自身不给开关——停用了就没有界面再打开它。用户手写的
+  `disabled: !!js …` 条件表达式会被**拒绝接管**并提示手改：那是条件逻辑，
+  两态开关覆盖它等于把条件永久压成固定值。
+  （界面类插件的变化需要刷新页面才反映：浏览器那半边靠页面加载时注入的
+  启动清单，后端的开关立即生效，已加载的模块不会自行卸载。）
+- **一次点击一个任务，日志从第一毫秒开始流**：预检本身就是一个任务，点安装
+  的瞬间就出现在面板里，隔离探针的 pnpm 输出实时写入——而不是让按钮干等几秒
+  再冒出结果。预检通过后由安装任务接管同一条日志、撤掉预检条目，所以面板上
+  始终只有一条记录。运行中只露最后 8 行，落定后折叠成「查看日志（N 行）」。
+- **预检通过直接装**：verdict 为 safe 时不弹任何确认；只有有风险或被阻止才
+  出面板内联卡片（原因列表 + 取消 / 继续），不用模态弹窗打断。
 - **安装期代码要用户点头**：pnpm 默认拦掉依赖的构建脚本，放行等于让那些命令
   以用户的权限在其机器上运行（早于任何插件代码加载）——这个决定属于用户。
   所以被拦时安装**停下**，如实列出要批准的到底是什么：包名@版本、确切的

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1e0zj/dsh-plugin-mall",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "dsh 插件市场：搜索 GitHub dsh-plugin 话题下的插件仓库，一键安装到本地 dsh profile（agent 工具 + 设置页插件市场 tab）",
   "type": "module",
   "main": "src/index.js",

package/src/client.js

@@ -64,7 +64,14 @@ window.__ModuleLoader__.load({
       ".mkt_approvePkg{display:flex;flex-direction:column;gap:4px}",
       ".mkt_approveName{font-size:13px;font-weight:600;color:var(--dsw-alias-label-primary);margin-right:8px;overflow-wrap:anywhere}",
       ".mkt_approveCmd{max-height:none;margin:0}",
-      ".mkt_jobDone{display:flex;align-items:center;gap:8px;flex-wrap:wrap}",
+      ".mkt_jobDone{display:flex;align-items:center;gap:8px;flex-wrap:wrap;margin-top:2px}",
+      ".mkt_logBlock{display:flex;flex-direction:column;gap:4px;align-items:flex-start}",
+      ".mkt_depOff{opacity:.5;text-decoration:line-through}",
+      ".mkt_switch{position:relative;width:34px;height:18px;border-radius:999px;border:1px solid var(--dsw-alias-border-l2);background:var(--dsw-alias-bg-secondary,#e5e7eb);cursor:pointer;padding:0;transition:background .15s,border-color .15s}",
+      ".mkt_switch:disabled{opacity:.55;cursor:default}",
+      ".mkt_switchOn{background:var(--dsw-alias-state-business-primary,#2b6cb0);border-color:transparent}",
+      ".mkt_switchKnob{position:absolute;top:1px;left:1px;width:14px;height:14px;border-radius:50%;background:#fff;transition:transform .15s;box-shadow:0 1px 2px rgba(0,0,0,.25)}",
+      ".mkt_switchOn .mkt_switchKnob{transform:translateX(16px)}",
       ".mkt_issueList{list-style:none;display:flex;flex-direction:column;gap:8px;margin:0;padding:0}",
       ".mkt_issue{border:1px solid var(--dsw-alias-border-l2);border-radius:8px;padding:8px 10px;background:var(--dsw-alias-bg-secondary,#fff)}",
       ".mkt_issueBlock{border-color:var(--dsw-alias-state-error-primary)}",
@@ -123,7 +130,9 @@ window.__ModuleLoader__.load({
     }
 
     // ── job polling ─────────────────────────────────────────────────────────
-    function useJobPolling(call, onSettled, onApprovalToken) {
+    // onPreflightSettled：预检 job（kind=dsh-plugin-preflight）落定时回调，
+    // 携带 (spec, report)。safe 由调用方直接续装；有风险由调用方出内联卡片。
+    function useJobPolling(call, onSettled, onApprovalToken, onPreflightSettled) {
       var jobsRef = useRef({});
       var _jobs = useState({});
       var jobs = _jobs[0];
@@ -145,8 +154,15 @@ window.__ModuleLoader__.load({
               if (snapshot.needsApproval && snapshot.approvalToken && onApprovalToken) {
                 try { onApprovalToken(snapshot.spec, snapshot.approvalToken); } catch (e) { /* best effort */ }
               }
-              if (!wasTerminal && nowTerminal && onSettled) {
-                try { onSettled(id, snapshot); } catch (e) { /* best effort */ }
+              if (!wasTerminal && nowTerminal) {
+                if (onSettled) {
+                  try { onSettled(id, snapshot); } catch (e) { /* best effort */ }
+                }
+                // 预检 job 落定 → 把结论交给上层后继（只触发一次）
+                if (snapshot.kind === "dsh-plugin-preflight" && !old.preflightHandled && onPreflightSettled) {
+                  jobsRef.current[id] = Object.assign({}, old, { preflightHandled: true });
+                  try { onPreflightSettled(snapshot.spec, snapshot.extras, id); } catch (e) { /* best effort */ }
+                }
               }
               var output = (old.output || "") + (value.output || "");
               jobsRef.current = Object.assign({}, jobsRef.current, { [id]: Object.assign({}, old, {
@@ -154,6 +170,7 @@ window.__ModuleLoader__.load({
                 detail: snapshot.detail,
                 needsApproval: snapshot.needsApproval,
                 approvalToken: snapshot.approvalToken,
+                kind: snapshot.kind,
                 output: output,
               }) });
               setJobs(Object.assign({}, jobsRef.current));
@@ -162,9 +179,19 @@ window.__ModuleLoader__.load({
         }, 1200);
         return function () { clearInterval(timer); };
       }, [call, onSettled, onApprovalToken]);
-      var track = useCallback(function (id, spec) {
-        jobsRef.current = Object.assign({}, jobsRef.current, { [id]: { status: "running", spec: spec, output: "" } });
-        setJobs(Object.assign({}, jobsRef.current));
+      // carryFromId：把上一阶段（预检）的日志接过来并撤掉它的条目。一次点击
+      // 只应该在面板里留下一个任务，日志连续——而不是 market-1 预检、
+      // market-2 安装两条并排，让人以为自己点了两次。
+      var track = useCallback(function (id, spec, carryFromId) {
+        var next = Object.assign({}, jobsRef.current);
+        var carried = "";
+        if (carryFromId && next[carryFromId]) {
+          carried = next[carryFromId].output || "";
+          delete next[carryFromId];
+        }
+        next[id] = { status: "running", spec: spec, output: carried };
+        jobsRef.current = next;
+        setJobs(Object.assign({}, next));
       }, []);
       var clear = useCallback(function () {
         jobsRef.current = {};
@@ -317,6 +344,54 @@ window.__ModuleLoader__.load({
       );
     }
 
+    var MARKET_PACKAGE = "@1e0zj/dsh-plugin-mall";
+
+    function jobKindLabel(kind) {
+      if (kind === "dsh-plugin-preflight") return "预检 ";
+      if (kind === "dsh-plugin-uninstall") return "卸载 ";
+      return "安装 ";
+    }
+
+    function jobStatusLabel(status) {
+      if (status === "completed") return "完成";
+      if (status === "failed") return "失败";
+      if (status === "killed") return "已取消";
+      return "进行中";
+    }
+
+    function jobStatusClass(status) {
+      if (status === "completed") return "mkt_ok";
+      if (status === "failed" || status === "killed") return "mkt_error";
+      return "";
+    }
+
+    // 任务日志：跑的时候只露尾部几行（够看进度，不霸屏），落定后默认折叠
+    // ——成功的日志没人回头读，失败的才需要，点开即可。
+    var LOG_TAIL_LINES = 8;
+    function JobLog(props) {
+      var _open = useState(false);
+      var open = _open[0];
+      var setOpen = _open[1];
+      var text = String(props.output || "").trimEnd();
+      if (text.length === 0) return null;
+      var lines = text.split("\n");
+      var collapsed = props.done && !open;
+      var shown = (props.done || lines.length <= LOG_TAIL_LINES) ? lines : lines.slice(-LOG_TAIL_LINES);
+      // 展开/收起始终在日志块上方：放在下方的话，点开后按钮会被推到长长的
+      // 日志末尾，想收起还得先滚回去。
+      return h("div", { className: "mkt_logBlock" },
+        props.done
+          ? h("span", {
+            className: "mkt_link",
+            onClick: function () { setOpen(!open); },
+          }, open ? "收起日志" : "查看日志（" + lines.length + " 行）")
+          : lines.length > LOG_TAIL_LINES
+            ? h("div", { className: "mkt_meta" }, "只显示最后 " + LOG_TAIL_LINES + " 行")
+            : null,
+        collapsed ? null : h("pre", { className: "mkt_pre" }, shown.join("\n").slice(-4000))
+      );
+    }
+
     // ── jobs panel ──────────────────────────────────────────────────────────
     function JobsPanel(props) {
       var ids = Object.keys(props.jobs);
@@ -330,8 +405,13 @@ window.__ModuleLoader__.load({
           var job = props.jobs[id];
           var done = job.status === "completed" || job.status === "failed" || job.status === "killed";
           return h("div", { key: id, style: { display: "flex", flexDirection: "column", gap: "4px" } },
+            // 不再显示 market-N 这种内部 id——对用户没有意义，反而让人以为
+            // 自己点了两次。只说清「在做什么 · 到哪一步了」。
+            // 状态词单独上色（完成绿、失败/取消红），前半段保持灰——整行
+            // 都染色会喧宾夺主，只有结论需要一眼看见。
             h("div", { className: "mkt_meta" },
-              id + " · " + clip(job.spec || "", 40) + " · " + (job.status || "running")),
+              jobKindLabel(job.kind) + clip(job.spec || "", 44) + " · ",
+              h("span", { className: jobStatusClass(job.status) }, jobStatusLabel(job.status))),
             job.needsApproval && job.needsApproval.length > 0
               ? h(ApprovalRequest, {
                 needsApproval: job.needsApproval,
@@ -345,9 +425,10 @@ window.__ModuleLoader__.load({
                 onDismiss: function () { props.onDismiss(id); },
               })
               : job.detail ? h("div", { className: "mkt_desc" }, job.detail) : null,
-            done && job.status === "completed"
+            // 预检完成不提示重启——它没有改动任何东西，接下来才是安装。
+            // 也不再重复一个绿色「完成」：状态行已经写了「· 完成」。
+            done && job.status === "completed" && job.kind !== "dsh-plugin-preflight"
               ? h("div", { className: "mkt_jobDone" },
-                h("span", { className: "mkt_ok" }, "完成"),
                 h("button", {
                   className: "mkt_btn mkt_btnPrimary mkt_btnSm",
                   disabled: props.restarting === true,
@@ -356,7 +437,7 @@ window.__ModuleLoader__.load({
               : job.status === "failed" && !(job.needsApproval && job.needsApproval.length > 0)
                 ? h("div", { className: "mkt_error" }, "失败，见下方输出")
                 : null,
-            job.output ? h("pre", { className: "mkt_pre" }, job.output.slice(-4000)) : null
+            h(JobLog, { output: job.output, done: done })
           );
         })
       );
@@ -389,10 +470,23 @@ window.__ModuleLoader__.load({
             : h("div", { className: "mkt_depList" }, (installed.deps || []).map(function (dep) {
               var busy = (props.removing || {})[dep.name] === true;
               var upd = (props.updates || {})[dep.name];
+              var entry = (props.entries || {})[dep.name];
+              // 没在装配树里的依赖（普通依赖、或声明了 client 但没挂载的）
+              // 没有可切换的东西，不给开关。
+              var togglable = entry !== undefined && dep.name !== MARKET_PACKAGE;
+              var enabled = entry === undefined ? true : entry.enabled !== false;
+              var toggling = (props.toggling || {})[dep.name] === true;
               return h("div", { key: dep.name, className: "mkt_depRow" },
-                h("span", { className: "mkt_desc" }, dep.name + "@" + dep.version),
+                h("span", { className: "mkt_desc" + (enabled ? "" : " mkt_depOff") }, dep.name + "@" + dep.version),
                 h("span", { className: "mkt_depActions" },
-                  h("span", { className: "mkt_badge" }, kindLabel(dep.kind)),
+                  h("span", { className: "mkt_badge" }, enabled ? kindLabel(dep.kind) : "已停用"),
+                  togglable ? h("button", {
+                    className: "mkt_switch" + (enabled ? " mkt_switchOn" : ""),
+                    disabled: toggling,
+                    title: enabled ? "停用（立即生效，不卸载）" : "启用（立即生效）",
+                    "aria-pressed": enabled ? "true" : "false",
+                    onClick: function () { props.onToggle(dep.name, !enabled); },
+                  }, h("span", { className: "mkt_switchKnob" })) : null,
                   upd && upd.hasUpdate ? h("button", {
                     className: "mkt_btn mkt_btnSm",
                     onClick: function () { props.onInstallSpec(dep.name + "@" + upd.latest); },
@@ -433,6 +527,9 @@ window.__ModuleLoader__.load({
       var _removing = useState({});
       var removing = _removing[0];
       var setRemoving = _removing[1];
+      var _toggling = useState({});
+      var toggling = _toggling[0];
+      var setToggling = _toggling[1];
       var _page = useState(1);
       var page = _page[0];
       var setPage = _page[1];
@@ -558,6 +655,26 @@ window.__ModuleLoader__.load({
         return function () { observer.disconnect(); };
       }, [loadMore]);
 
+      // 启用/停用：热生效，不重启也不重装——所以成功后只刷新已装列表，
+      // 不提示重启，也不动任务面板（它不是一个需要看日志的长任务）。
+      var doToggle = useCallback(function (packageName, enabled) {
+        setToggling(function (prev) { return Object.assign({}, prev, { [packageName]: true }); });
+        setError(null);
+        call("togglePlugin", { package: packageName, enabled: enabled }).then(function (value) {
+          setInstalled(function (prev) {
+            return prev && !prev.error ? Object.assign({}, prev, { entries: value.entries }) : prev;
+          });
+        }).catch(function (e) {
+          setError(errorText(e));
+        }).finally(function () {
+          setToggling(function (prev) {
+            var next = Object.assign({}, prev);
+            delete next[packageName];
+            return next;
+          });
+        });
+      }, [call]);
+
       var refreshInstalled = useCallback(function () {
         call("installed", {}).then(function (value) {
           setInstalled(value);
@@ -584,7 +701,14 @@ window.__ModuleLoader__.load({
         }
       }, []);
 
-      var polling = useJobPolling(call, onJobSettled, onApprovalToken);
+      // 预检落定的后继动作要用到下面才定义的 doRawInstall，用 ref 转接，
+      // 免得为了闭包顺序把整块逻辑往上搬。
+      var preflightHandlerRef = useRef(null);
+      var onPreflightSettled = useCallback(function (spec, report, jobId) {
+        if (preflightHandlerRef.current) preflightHandlerRef.current(spec, report, jobId);
+      }, []);
+
+      var polling = useJobPolling(call, onJobSettled, onApprovalToken, onPreflightSettled);
       var track = polling.track;
       var jobs = polling.jobs;
       var clearJobs = polling.clear;
@@ -595,7 +719,7 @@ window.__ModuleLoader__.load({
         // eslint-disable-next-line react-hooks/exhaustive-deps
       }, []);
 
-      var doRawInstall = useCallback(function (spec, extra) {
+      var doRawInstall = useCallback(function (spec, extra, carryFromId) {
         setInstalling(function (prev) {
           var next = Object.assign({}, prev, { [spec]: true });
           return next;
@@ -603,7 +727,7 @@ window.__ModuleLoader__.load({
         setError(null);
         var payload = Object.assign({ spec: spec }, extra || {});
         call("install", payload).then(function (value) {
-          track(value.jobId, spec);
+          track(value.jobId, spec, carryFromId);
         }).catch(function (e) {
           delete approvalTokensRef.current[spec];
           setError(errorText(e));
@@ -626,31 +750,33 @@ window.__ModuleLoader__.load({
         doRawInstall(spec, extra);
       }, [doRawInstall]);
 
-      var preflightAndInstall = useCallback(function (spec) {
-        delete approvalTokensRef.current[spec];
-        setInstalling(function (prev) {
-          var next = Object.assign({}, prev, { [spec]: true });
-          return next;
-        });
-        setError(null);
-        call("preflight", { spec: spec }).then(function (report) {
-          // 检查通过直接装，不打扰；有风险才出内联卡片等人表态；被阻止
-          // 只告知原因。任何路径都不再弹模态框。
+      // 预检落定后的去向：safe 直接续装，其余出内联风险卡片。
+      useEffect(function () {
+        preflightHandlerRef.current = function (spec, report, jobId) {
+          if (!report || !report.verdict) {
+            setError("预检没有返回结论，请重试");
+            return;
+          }
           if (report.verdict === "safe") {
-            doRawInstall(spec, {});
+            // 安全：接过预检的日志、撤掉预检条目，面板上只剩这一个任务。
+            doRawInstall(spec, {}, jobId);
           } else {
-            setPreflight({ spec: spec, report: report });
+            setPreflight({ spec: spec, report: report, jobId: jobId });
           }
+        };
+      }, [doRawInstall]);
+
+      // 点安装 = 立刻起一个预检 job，面板马上有东西看、日志实时流。
+      // 结论由轮询经 onPreflightSettled 交回上面的 handler，这里不等待。
+      var preflightAndInstall = useCallback(function (spec) {
+        delete approvalTokensRef.current[spec];
+        setError(null);
+        call("preflight", { spec: spec }).then(function (value) {
+          track(value.jobId, value.spec || spec);
         }).catch(function (e) {
           setError(errorText(e));
-        }).finally(function () {
-          setInstalling(function (prev) {
-            var next = Object.assign({}, prev);
-            delete next[spec];
-            return next;
-          });
         });
-      }, [call, doRawInstall]);
+      }, [call, track]);
 
       var doInstall = useCallback(function (repo) {
         preflightAndInstall("github:" + repo);
@@ -746,7 +872,16 @@ window.__ModuleLoader__.load({
             "只看已验证插件")
         ),
         error ? h("div", { className: "mkt_error" }, error) : null,
-        h(InstalledPanel, { installed: installed, removing: removing, updates: updates, onUninstall: doUninstall, onInstallSpec: preflightAndInstall }),
+        h(InstalledPanel, {
+          installed: installed,
+          removing: removing,
+          updates: updates,
+          entries: installed && !installed.error ? installed.entries : undefined,
+          toggling: toggling,
+          onToggle: doToggle,
+          onUninstall: doUninstall,
+          onInstallSpec: preflightAndInstall,
+        }),
         h(JobsPanel, {
           jobs: jobs,
           onClear: function () {
@@ -777,8 +912,9 @@ window.__ModuleLoader__.load({
           busy: installing[preflight.spec] === true,
           onConfirm: function () {
             var spec = preflight.spec;
+            var carry = preflight.jobId;
             setPreflight(null);
-            doRawInstall(spec, { acceptWarnings: true });
+            doRawInstall(spec, { acceptWarnings: true }, carry);
           },
           onClose: function () {
             if (preflight && preflight.spec) delete approvalTokensRef.current[preflight.spec];

package/src/index.js

@@ -24,11 +24,16 @@ import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { resolveProfileDir } from "@deepseek-ai/dsh-app-boot";
 import { repoInfo, searchPlugins, verifyPlugins, cachedRepoManifest, fetchRawFile, preferNpmSpec, npmPackageInfo, compareVersions, assertSafeToInstall, mapLimit, NETWORK_CONCURRENCY } from "./github.js";
-import { ensureProfile, listInstalled, normalizeSpec, runInstall, runRemove, assertSafeSpec, resolveRegistry, serializeCanonicalProof } from "./installer.js";
-import { preflightInstall, inspectRemoteCandidate } from "./guard.js";
+import { ensureProfile, listInstalled, normalizeSpec, runInstall, runRemove, assertSafeSpec, resolveRegistry, serializeCanonicalProof, persistPluginDisabled } from "./installer.js";
+import { preflightInstall, inspectRemoteCandidate, recoverProfile } from "./guard.js";
 
 export const name = "@1e0zj/dsh-plugin-mall";
-export const inject = ["tools", "jobs", "systemPrompt"];
+// `loader` 用来读装配树、并对单个 entry 做热开关（entry.update）。读法照抄
+// 官方的 @deepseek-ai/dsh-host-plugin-inventory —— 它是只读投影
+// （"Read-only Remote projection of current Cordis Loader plugin state"），
+// 写入侧留白，正是这里补的位置。持久化不走 loader（见 togglePlugin 的说明）。
+// loader 必然存在——没有它我们根本加载不了。
+export const inject = ["tools", "jobs", "systemPrompt", "loader"];
 
 export const Config = z.object({
   defaultProfile: z.string().default("web"),
@@ -194,7 +199,7 @@ function pinPreflight(profileDir, spec) {
  * Run the isolated preflight for a resolved install spec, reusing a fresh
  * cache entry ONLY if the profile fingerprint matches.
  */
-async function runPreflight({ profile, spec, force = false }) {
+async function runPreflight({ profile, spec, force = false, onOutput }) {
   let profileDir;
   try {
     profileDir = resolveProfileDir(profile);
@@ -220,7 +225,7 @@ async function runPreflight({ profile, spec, force = false }) {
     return { report: validCached.report, profileDir, fingerprint: currentFingerprint };
   }
 
-  const report = await preflightInstall({ profileDir, spec });
+  const report = await preflightInstall({ profileDir, spec, onOutput });
   preflightCache.set(key, {
     report,
     fingerprint: currentFingerprint,
@@ -858,6 +863,57 @@ export function createJobTracker({ producerFactory } = {}) {
       return id;
     },
 
+    /**
+     * A visible, log-streaming job for a phase that is not install/remove.
+     * Preflight above all: it used to run inside the RPC call before any job
+     * existed, so the panel sat empty for the seconds the probe took. Now the
+     * job appears the instant the user clicks and the probe's pnpm output
+     * streams into it. The verdict rides `extras` on the snapshot so the
+     * polling client can continue into the install (or raise a risk card).
+     * Cancel is advisory — the probe has no kill handle — so it just marks the
+     * record killed and discards the outcome; the throwaway probe directory
+     * lives in the system tmpdir and is reclaimed by the OS.
+     */
+    startCustom({ kind, label, profile, spec, surface = "browser", session, run }) {
+      const id = `market-${++trackerCounter}`;
+      const queue = [];
+      const push = (text) => { queue.push(String(text ?? "")); };
+      const record = {
+        id,
+        kind,
+        label,
+        profile,
+        spec,
+        surface,
+        session: session ?? "",
+        status: "running",
+        detail: undefined,
+        extras: undefined,
+        startedAt: Date.now(),
+        finishedAt: undefined,
+        cancelled: false,
+        readOutput: () => (queue.length === 0 ? "" : queue.splice(0).join("")),
+      };
+      (async () => {
+        try {
+          const outcome = await run(push);
+          if (record.cancelled) return; // 用户已放弃，结果作废
+          record.status = outcome?.status ?? "failed";
+          record.detail = outcome?.detail;
+          record.extras = outcome?.extras;
+        } catch (error) {
+          if (record.cancelled) return;
+          record.status = "failed";
+          record.detail = error?.message ?? String(error);
+        } finally {
+          if (!record.cancelled) record.finishedAt = Date.now();
+        }
+      })();
+      records.set(id, record);
+      prune();
+      return id;
+    },
+
     get(jobId, session) {
       const record = records.get(String(jobId));
       if (record === undefined) throw new Error(`unknown install job ${JSON.stringify(String(jobId))}`);
@@ -871,11 +927,15 @@ export function createJobTracker({ producerFactory } = {}) {
           detail: record.detail,
           needsApproval: record.needsApproval,
           approvalToken: isSameSession ? record.approvalToken : undefined,
+          // extras（如预检结论）同样只对同一 session 可见，与 approvalToken 同规格。
+          extras: isSameSession ? record.extras : undefined,
           spec: record.spec,
           startedAt: record.startedAt,
           finishedAt: record.finishedAt,
         },
-        output: typeof record.producer?.readOutput === "function" ? record.producer.readOutput() : "",
+        output: typeof record.readOutput === "function"
+          ? record.readOutput()
+          : typeof record.producer?.readOutput === "function" ? record.producer.readOutput() : "",
       };
     },
 
@@ -885,6 +945,13 @@ export function createJobTracker({ producerFactory } = {}) {
       if (record.surface === "browser" && (record.session === "" || record.session !== session)) {
         throw new Error("unauthorized to cancel job from another session");
       }
+      if (record.cancelled !== undefined) { // startCustom：无句柄可杀，立即标 killed 并作废结果
+        record.cancelled = true;
+        if (record.status === "running") {
+          record.status = "killed";
+          record.finishedAt = Date.now();
+        }
+      }
       if (typeof record.producer?.cancel === "function") {
         record.producer.cancel();
       }
@@ -911,6 +978,53 @@ export function createJobTracker({ producerFactory } = {}) {
   };
 }
 
+/**
+ * Group the loader's mounted entries by the package that provides them, so a
+ * profile dependency can be shown (and toggled) as one row.
+ *
+ * One package can insert several rows, so `enabled` means EVERY row of that
+ * package is live — a half-disabled package is reported as disabled, and
+ * toggling acts on the whole set. Group rows are skipped, mirroring the
+ * official read-only projection in @deepseek-ai/dsh-host-plugin-inventory.
+ */
+export function loaderEntriesByPackage(ctx) {
+  const byPackage = {};
+  try {
+    for (const entry of ctx.loader.entries()) {
+      if (entry.options?.group) continue;
+      const moduleName = entry.options?.name;
+      if (typeof moduleName !== "string" || moduleName.length === 0) continue;
+      const bucket = byPackage[moduleName] ??= { entryIds: [], entries: [], enabled: true };
+      // 两个 id 必须分清：
+      //   entry.id        运行时全路径，父链拼出来的（`include:dsh-at-file`）
+      //   entry.options.id 配置文件里写的那个（`dsh-at-file`）
+      // patch 层的 id 定向覆盖按后者匹配（applyEntryPatches 从组装数据建
+      // entryMap，键是各 patch 声明的 id）。拿前者去写 patch，那条覆盖行
+      // 永远匹配不到目标，dsh 只会 warn 一句然后忽略——停用看着成功了，
+      // 重启后插件照常回来。
+      const configId = entry.options?.id;
+      bucket.entryIds.push(entry.id);
+      bucket.entries.push({ id: entry.id, configId, entry });
+      if (entry.disabled) bucket.enabled = false;
+    }
+  } catch {
+    /* loader 读不到就不给开关，安装/卸载照常可用 */
+  }
+  return byPackage;
+}
+
+/**
+ * The serializable half of loaderEntriesByPackage — live `entry` objects must
+ * never reach the RPC envelope (they carry the whole fiber graph).
+ */
+function serializableEntries(byPackage) {
+  const out = {};
+  for (const [moduleName, bucket] of Object.entries(byPackage)) {
+    out[moduleName] = { entryIds: bucket.entryIds, enabled: bucket.enabled };
+  }
+  return out;
+}
+
 /** Render one preflight issue as a compact line for model/error output. */
 function renderPreflightIssue(entry) {
   const badge = entry.severity === "block" ? "BLOCK" : "WARN";
@@ -1131,10 +1245,74 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
       } catch (error) {
         return rpcFail(new Error(`invalid profile: ${error.message}`));
       }
-      return rpcOk(listInstalled(profile));
+      // 带上每个依赖在装配树里的启用状态，浏览器据此渲染开关。
+      return rpcOk({ ...listInstalled(profile), entries: serializableEntries(loaderEntriesByPackage(ctx)) });
+    }
+    case "togglePlugin": {
+      // 启用/停用，三层（同 cynch18/plugin-switch 的做法）：
+      //   1. 内存 —— entry.update({disabled}) 立即 dispose/start 对应 fiber
+      //   2. 持久化 —— 文本改写用户的 cordis.patch.yml，由 dsh 自己的
+      //      watchUserPatches 事务性重放（启动时若无 HMR 会当场创建一个，
+      //      见 @deepseek-ai/dsh 的 profile-boot：ctx.loader.create(hmr) →
+      //      watchUserPatches(profile patch) + watchUserPatches(home patch)）
+      //   3. 保险 —— 写前备份到 <profile>/backups/，留最近 20 份
+      // 刻意不用 ctx.loader.update()：它的 tree.write() 写的是 cordis.yml，
+      // 那是组装产物；用户的选择该留在自己的 patch 层。
+      const profile = String(payload?.profile ?? defaultProfile).trim();
+      const packageName = String(payload?.package ?? "").trim();
+      const enabled = payload?.enabled === true;
+      if (packageName.length === 0) return rpcFail(new Error("togglePlugin: package name is required"));
+      if (packageName === name) {
+        // 停用市场自己 = 关掉正在操作的这个界面，之后只能手改配置文件才能回来。
+        return rpcFail(new Error("refusing to disable the marketplace itself — you would lose the UI needed to re-enable it"));
+      }
+      let profileDir;
+      try {
+        profileDir = resolveProfileDir(profile);
+      } catch (error) {
+        return rpcFail(new Error(`invalid profile: ${error.message}`));
+      }
+      const targets = loaderEntriesByPackage(ctx)[packageName]?.entries ?? [];
+      if (targets.length === 0) {
+        return rpcFail(new Error(`no loader entry found for ${packageName} — it may not be mounted in this profile`));
+      }
+      // 先持久化：patch 层写不了（!!js 表达式等）就整个放弃，不留下
+      // 「内存里关了、重启又回来」的错位状态。
+      const backups = [];
+      try {
+        for (const target of targets) {
+          // 用 options.id（配置文件里的 id），不是 entry.id（运行时全路径）。
+          if (typeof target.configId !== "string" || target.configId.length === 0) {
+            throw new Error(`${packageName} has a loader entry without a configured id — it cannot be targeted from the patch layer`);
+          }
+          const result = persistPluginDisabled(profileDir, target.configId, !enabled, packageName);
+          if (result.backup !== undefined) backups.push(result.backup);
+        }
+      } catch (error) {
+        return rpcFail(error);
+      }
+      try {
+        for (const target of targets) {
+          await target.entry.update({ disabled: enabled ? undefined : true });
+        }
+      } catch (error) {
+        return rpcFail(new Error(`${packageName} was written to the patch layer but the live toggle failed: ${error.message} — restart dsh to apply it`));
+      }
+      return rpcOk({ package: packageName, enabled, backups, entries: serializableEntries(loaderEntriesByPackage(ctx)) });
     }
     case "preflight": {
+      // 预检本身做成 job：点击安装的瞬间任务就出现在面板里，探针的 pnpm
+      // 输出实时流入——此前预检阻塞在 RPC 里，面板数秒空白只有按钮干等。
+      // 结论经 snapshot.extras 返回，轮询端据此后接安装或出风险卡片；
+      // 缓存同时被填热，随后的 install 调用不再重复探装。
       const profile = String(payload?.profile ?? defaultProfile).trim();
+      let session;
+      try {
+        // 与 install 同规格：job 归属浏览器 session，extras 才只对本人可见。
+        session = requireBrowserSession(payload?.session);
+      } catch (error) {
+        return rpcFail(error);
+      }
       let spec;
       try {
         spec = normalizeSpec(payload?.spec);
@@ -1144,9 +1322,22 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
       }
       try {
         const registry = await registryFor(profile, npmRegistry);
-        spec = await preferNpmSpec({ spec, registry, sources: rawSources });
-        const { report } = await runPreflight({ profile, spec });
-        return rpcOk(report);
+        const resolved = await preferNpmSpec({ spec, registry, sources: rawSources });
+        const jobId = tracker.startCustom({
+          kind: "dsh-plugin-preflight",
+          label: `preflight ${resolved}`,
+          profile,
+          spec: resolved,
+          surface: "browser",
+          session,
+          run: async (push) => {
+            push(`[dsh-plugin-mall] 预检 ${resolved}：隔离目录探装（脚本禁用）\n`);
+            const { report } = await runPreflight({ profile, spec: resolved, onOutput: (text) => push(text) });
+            push(`[dsh-plugin-mall] 预检结论：${report.verdict}\n`);
+            return { status: "completed", detail: `预检完成：${report.verdict}`, extras: report };
+          },
+        });
+        return rpcOk({ jobId, profile, spec: resolved });
       } catch (error) {
         return rpcFail(error);
       }
@@ -1363,6 +1554,31 @@ export function apply(ctx, config = {}) {
   const { defaultProfile = "web", apiBase = "https://api.github.com", perPageMax = 30, npmRegistry = "", rawSources = [] } = config;
   const token = process.env.GITHUB_TOKEN ?? process.env.DSH_MARKET_GITHUB_TOKEN;
 
+  // Startup recovery. A pending install marker blocks every later install and
+  // uninstall in that profile until something resolves it — and until now the
+  // only thing that did was `guard launch`, a wrapper nobody uses: people type
+  // `dsh web`. One install then wedged the profile permanently, with an error
+  // telling users to run a CLI they have never heard of.
+  //
+  // Reaching `apply` IS the proof the pending install did not break the host:
+  // this code only runs because dsh booted far enough to compose the profile
+  // and load this plugin. So resolve the marker right here — recoverProfile
+  // commits when the profile validates and rolls back when it does not. The
+  // grace-window probation of `guard launch` stays strictly better (it also
+  // catches a crash seconds later); this is the floor for a plain start.
+  try {
+    const result = recoverProfile(resolveProfileDir(defaultProfile));
+    if (result.action === "committed") {
+      console.log(`[dsh-plugin-mall] startup recovery: committed the pending install for profile "${defaultProfile}"`);
+    } else if (result.action === "rolled-back") {
+      console.warn(`[dsh-plugin-mall] startup recovery: rolled back the pending install for profile "${defaultProfile}" — ${result.reason ?? "profile failed validation"}`);
+    }
+  } catch (error) {
+    // 恢复失败绝不能拖垮插件加载：报出来，让市场照常可用（用户还能手动
+    // `dsh-plugin-guard guard recover`），而不是连界面都进不去。
+    console.error("[dsh-plugin-mall] startup recovery failed:", error);
+  }
+
   ctx.systemPrompt.section({
     name: "tool:market",
     order: 120,
@@ -2124,6 +2340,39 @@ export async function runSelfTests() {
       "tracker rejection fixture 使用注入 producer，不触碰真实 profile",
       producerCalls === 1 && trackerSnapshot.status === "failed" && settledOutcome?.status === "failed",
     );
+
+    // ── 8. 启用/停用：装配树条目按包分组 ─────────────────────────────────
+    // 一个包可以插入多行，所以分组、以及「有一行停用就算整体停用」是这块最
+    // 容易写错的地方；group 行必须跳过（照 dsh-host-plugin-inventory 的读法）。
+    const fakeLoaderCtx = (entries) => ({ loader: { entries: () => entries } });
+    const grouped = loaderEntriesByPackage(fakeLoaderCtx([
+      { id: "e1", options: { name: "dsh-at-file" }, disabled: false },
+      { id: "e2", options: { name: "multi-row" }, disabled: false },
+      { id: "e3", options: { name: "multi-row" }, disabled: true },
+      { id: "g1", options: { name: "some-group", group: true }, disabled: false },
+      { id: "e4", options: {}, disabled: false },
+    ]));
+    check("单行包：分组并标记启用", grouped["dsh-at-file"]?.entryIds.length === 1 && grouped["dsh-at-file"].enabled === true);
+    check("多行包：合并为一项", grouped["multi-row"]?.entryIds.length === 2);
+    check("多行包有一行停用 → 整体判为停用", grouped["multi-row"]?.enabled === false);
+    check("group 行被跳过", grouped["some-group"] === undefined);
+    check("无名条目被跳过", Object.keys(grouped).length === 2);
+    check("loader 抛错时降级为空表，不拖垮已装列表", Object.keys(loaderEntriesByPackage({
+      loader: { entries: () => { throw new Error("loader unavailable"); } },
+    })).length === 0);
+
+    // entry.id 是运行时全路径（父链拼接，`include:dsh-at-file`），
+    // entry.options.id 才是配置文件里的 id（`dsh-at-file`）。patch 层的
+    // id 定向覆盖按后者匹配——用错了那条覆盖行永远命中不了目标，
+    // 停用看着成功、重启后插件照常回来（真实环境踩过）。
+    const prefixed = loaderEntriesByPackage(fakeLoaderCtx([
+      { id: "include:dsh-at-file", options: { id: "dsh-at-file", name: "dsh-at-file" }, disabled: false },
+    ]));
+    check("运行时 id 与配置 id 分别保留", prefixed["dsh-at-file"]?.entries[0].id === "include:dsh-at-file"
+      && prefixed["dsh-at-file"]?.entries[0].configId === "dsh-at-file");
+    check("configId 缺失时可被识别（调用方据此拒绝写 patch）", loaderEntriesByPackage(fakeLoaderCtx([
+      { id: "anon-1", options: { name: "no-id-pkg" }, disabled: false },
+    ]))["no-id-pkg"]?.entries[0].configId === undefined);
   } finally {
     rmSync(root, { recursive: true, force: true });
   }

package/src/installer.js

@@ -368,6 +368,134 @@ export function removeClientRow(profileDir, packageName) {
   return { removed: true, rowId };
 }
 
+// ── enable / disable persistence ────────────────────────────────────────────
+//
+// Toggling a plugin is three layers, and only the middle one lives here:
+//   1. memory — `entry.update({disabled})` disposes/starts the fiber (index.js)
+//   2. persistence — rewrite the profile's cordis.patch.yml, replayed
+//      transactionally by dsh's own `watchUserPatches` (this file)
+//   3. safety — back the file up before every edit so a bad write is undoable
+//
+// Persistence deliberately does NOT go through `loader.update()` even though
+// that would write for us: its `tree.write()` targets `cordis.yml`, the
+// composed artifact. A user's choice belongs in the patch layer they own, not
+// baked into the thing composition regenerates. Same conclusion as
+// cynch18/plugin-switch, which spells it out in its header comment.
+
+/** A patch row's `disabled:` line, when it is a plain literal we may rewrite. */
+const DISABLED_LINE_RE = /^(\s*)disabled\s*:\s*(.*?)\s*$/;
+
+/**
+ * Text-level edit of one entry's `disabled` in a patch file, preserving every
+ * other byte (comments included — users hand-write this file).
+ *
+ * A profile's patch layer normally starts EMPTY (`[]`): plugins are mounted by
+ * the bundle layers, not by the user's file. So "no row for this id" is the
+ * common case, not an error — we append an id-targeted override row, which is
+ * exactly what the patch layer is for (dsh-app-boot's applyEntryPatches treats
+ * a non-insert row as "override these keys on the entry with this id", and
+ * warns on a `name` mismatch, so we pass `name` as a guard).
+ *
+ * @param content - current cordis.patch.yml text.
+ * @param entryId - the loader entry id whose row to edit.
+ * @param disabled - desired state.
+ * @param moduleName - the entry's module name, written alongside a NEW row so
+ *   dsh can detect a stale patch if the id is ever reused.
+ * @returns the new text, or undefined when it already reads that way.
+ * @throws when the row's `disabled` is a `!!js` expression.
+ */
+export function setPatchRowDisabled(content, entryId, disabled, moduleName) {
+  const lines = String(content ?? "").split("\n");
+  // 行尾允许跟注释：`- id: at-file   # 我的备注` 是用户会写的形状。
+  const idPattern = new RegExp(`^(\\s*)-?\\s*id\\s*:\\s*['"]?${entryId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"]?\\s*(?:#.*)?$`);
+  const rowIndex = lines.findIndex((line) => idPattern.test(line));
+  if (rowIndex === -1) {
+    // patch 层里还没有这一条——这是常态（profile 的 patch 层默认是空的 `[]`，
+    // 插件由 bundle 层挂载）。追加一条 id 定向覆盖行。
+    if (!disabled) return undefined; // 没有覆盖行 = 本来就是启用状态
+    const block = moduleName === undefined
+      ? `- id: ${entryId}\n  disabled: true\n`
+      : `- id: ${entryId}\n  name: '${moduleName}'\n  disabled: true\n`;
+    const trimmed = String(content ?? "").trim();
+    // 模板是注释 + `[]`，整体替换掉那个空数组；否则在末尾追加。
+    if (trimmed.endsWith("[]")) {
+      return `${trimmed.slice(0, trimmed.lastIndexOf("[]")).trimEnd()}\n${block}`.replace(/^\n/, "");
+    }
+    return `${trimmed.length === 0 ? "" : `${trimmed}\n`}${block}`;
+  }
+  const indent = (idPattern.exec(lines[rowIndex])[1] ?? "").length;
+  // 同一条目的后续行：缩进更深，或与 `- id:` 的内容对齐。遇到下一个条目/顶格即止。
+  let existing = -1;
+  for (let index = rowIndex + 1; index < lines.length; index++) {
+    const line = lines[index];
+    if (line.trim().length === 0) continue;
+    const lead = line.length - line.trimStart().length;
+    if (lead <= indent && /^\s*-\s/.test(line)) break; // 下一个条目
+    if (lead < indent) break;                          // 退出该块
+    const match = DISABLED_LINE_RE.exec(line);
+    if (match !== null) { existing = index; break; }
+  }
+  if (existing !== -1) {
+    const value = DISABLED_LINE_RE.exec(lines[existing])[2];
+    // 用户写的是条件逻辑（如「只在 Windows 上停用」）。我们的开关只有两态，
+    // 覆盖它等于把条件永久压成固定值，而且用户不会察觉——拒绝接管，让人手改。
+    if (value.startsWith("!!js")) {
+      throw new Error(`cannot toggle ${entryId}: its "disabled" is a !!js expression — edit cordis.patch.yml by hand`);
+    }
+    if ((value === "true") === disabled) return undefined; // 已是目标状态
+    lines[existing] = lines[existing].replace(DISABLED_LINE_RE, `$1disabled: ${disabled}`);
+    return lines.join("\n");
+  }
+  if (!disabled) return undefined; // 没有 disabled 行本就是启用状态
+  // 插在 id 行之后，缩进与 id 的内容列对齐。
+  lines.splice(rowIndex + 1, 0, `${" ".repeat(indent + 2)}disabled: true`);
+  return lines.join("\n");
+}
+
+/** Keep the most recent N backups of a profile file, oldest pruned first. */
+const PATCH_BACKUP_KEEP = 20;
+
+/**
+ * Snapshot cordis.patch.yml before editing it. The file is hand-editable and
+ * carries the user's own rows; a bad automated write must be undoable without
+ * reaching for git.
+ * @returns the backup path, or undefined when there was nothing to back up.
+ */
+export function backupProfilePatch(profileDir) {
+  const patchPath = join(profileDir, PROFILE_PATCH_FILENAME);
+  if (!existsSync(patchPath)) return undefined;
+  const dir = join(profileDir, "backups");
+  mkdirSync(dir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const target = join(dir, `cordis.patch.${stamp}.yml`);
+  writeFileSync(target, readFileSync(patchPath, "utf8"));
+  try {
+    const kept = readdirSync(dir).filter((entry) => /^cordis\.patch\..*\.yml$/.test(entry)).sort();
+    for (const stale of kept.slice(0, Math.max(0, kept.length - PATCH_BACKUP_KEEP))) {
+      rmSync(join(dir, stale), { force: true });
+    }
+  } catch {
+    /* 清理失败不该让切换失败 */
+  }
+  return target;
+}
+
+/**
+ * Persist a toggle into the profile's patch layer: back up, edit, write through
+ * the checked writer. dsh's own `watchUserPatches` replays the file
+ * transactionally, so this is also what makes the change survive a restart.
+ * @returns `{changed, backup?}`; `changed:false` means it already read that way.
+ */
+export function persistPluginDisabled(profileDir, entryId, disabled, moduleName) {
+  const patchPath = join(profileDir, PROFILE_PATCH_FILENAME);
+  const content = existsSync(patchPath) ? readFileSync(patchPath, "utf8") : "[]\n";
+  const next = setPatchRowDisabled(content, entryId, disabled, moduleName);
+  if (next === undefined) return { changed: false };
+  const backup = backupProfilePatch(profileDir);
+  writePatchChecked(patchPath, next);
+  return { changed: true, backup };
+}
+
 // ── build-script allow-listing ──────────────────────────────────────────────
 
 /** Extract package names from pnpm's "Ignored build scripts: ..." output. */
@@ -2492,9 +2620,76 @@ async function runTransactionFixtures() {
   return failed;
 }
 
+/**
+ * The patch-layer edit behind enable/disable. Text surgery on a file users
+ * hand-write, so every shape it can meet is pinned here.
+ */
+function runToggleFixtures() {
+  let failed = 0;
+  const check = (label, ok, extra = "") => {
+    if (!ok) failed++;
+    console.log(`  ${ok ? "PASS" : "FAIL"} ${label}${ok ? "" : `  ${extra}`}`);
+  };
+  // 真实环境里 patch 层默认就是这个样子——注释 + 空数组。插件由 bundle 层
+  // 挂载，用户文件里一条都没有。第一版只测了「行已存在」的情形，于是停用
+  // 被静默跳过、重启后插件又回来了。这组用例先钉死这个场景。
+  const stockTemplate = "# Your patch layer for this dsh profile\n[]\n";
+  const fresh = setPatchRowDisabled(stockTemplate, "at-file", true, "dsh-at-file");
+  check("空 patch 层（模板 []）→ 追加 id 定向覆盖行", /- id: at-file/.test(fresh ?? "") && /disabled: true/.test(fresh ?? ""), JSON.stringify(fresh));
+  check("空 patch 层：替换掉 [] 而不是留着", !/\[\]/.test(fresh ?? ""), JSON.stringify(fresh));
+  check("空 patch 层：保留原有注释", (fresh ?? "").includes("# Your patch layer"));
+  check("新建行带 name 便于 dsh 校验陈旧 patch", /name: 'dsh-at-file'/.test(fresh ?? ""));
+  check("空 patch 层 + 要启用 → 不改动", setPatchRowDisabled(stockTemplate, "at-file", false, "dsh-at-file") === undefined);
+  check("新建的行能被 YAML 解析且是数组", (() => {
+    try { return Array.isArray(load(fresh)); } catch { return false; }
+  })());
+  check("新建行的语义正确（id + disabled）", (() => {
+    try { const doc = load(fresh); return doc[0].id === "at-file" && doc[0].disabled === true; } catch { return false; }
+  })());
+
+  const base = "- id: at-file\n  name: dsh-at-file\n";
+
+  const off = setPatchRowDisabled(base, "at-file", true);
+  check("无 disabled 行 → 插入 disabled: true", /^\s{2}disabled: true$/m.test(off ?? ""), JSON.stringify(off));
+  check("插入后其余字节不变", (off ?? "").includes("name: dsh-at-file"));
+
+  const on = setPatchRowDisabled(`- id: at-file\n  name: dsh-at-file\n  disabled: true\n`, "at-file", false);
+  check("已停用 → 改回 false", /disabled: false/.test(on ?? ""), JSON.stringify(on));
+
+  check("已是目标状态 → 不改动", setPatchRowDisabled(`- id: at-file\n  disabled: true\n`, "at-file", true) === undefined);
+  check("本就启用且要启用 → 不改动", setPatchRowDisabled(base, "at-file", false) === undefined);
+  check("条目不在 patch 层 → 追加新行，原有条目不动", (() => {
+    const out = setPatchRowDisabled(base, "other-id", true, "pkg-other");
+    return /- id: other-id/.test(out ?? "") && (out ?? "").includes("- id: at-file");
+  })());
+
+  // 用户写的条件逻辑不能被两态开关压平——必须拒绝并让人手改。
+  let threw = false;
+  try { setPatchRowDisabled(`- id: at-file\n  disabled: !!js process.platform === 'win32'\n`, "at-file", false); }
+  catch (error) { threw = /!!js expression/.test(error.message); }
+  check("disabled 是 !!js 表达式 → 拒绝接管", threw);
+
+  // 注释是用户手写的，一个字节都不能动。
+  const commented = "# 我的覆盖\n- id: at-file   # 保留这个注释\n  name: dsh-at-file\n";
+  const kept = setPatchRowDisabled(commented, "at-file", true);
+  check("注释原样保留", (kept ?? "").includes("# 我的覆盖") && (kept ?? "").includes("# 保留这个注释"));
+
+  // 多条目：只动目标那条，相邻条目不受影响。
+  const multi = "- id: a\n  name: pkg-a\n- id: at-file\n  name: dsh-at-file\n- id: z\n  name: pkg-z\n  disabled: true\n";
+  const one = setPatchRowDisabled(multi, "at-file", true);
+  check("多条目：只动目标条目", (one ?? "").split("disabled: true").length - 1 === 2 && (one ?? "").includes("- id: z"));
+  check("多条目：不误伤相邻条目的 disabled", setPatchRowDisabled(multi, "a", true)?.includes("- id: z\n  name: pkg-z\n  disabled: true") === true);
+
+  check("带引号的 id 也能匹配", setPatchRowDisabled(`- id: '@scope/pkg'\n  name: x\n`, "@scope/pkg", true) !== undefined);
+  return failed;
+}
+
 if (process.argv[1]?.endsWith("installer.js") && process.argv.includes("--self-test")) {
+  console.log("启用/停用 patch 层 fixtures:");
+  const toggleFailed = runToggleFixtures();
+  console.log();
   console.log("allowBuilds 合并 fixtures:");
-  const failed = runAllowBuildsFixtures();
+  const failed = runAllowBuildsFixtures() + toggleFailed;
   console.log(`${ALLOW_BUILDS_FIXTURES.length - failed}/${ALLOW_BUILDS_FIXTURES.length} passed`);
   // 实装 pnpm add 的参数/环境（纯函数）：peer 自动安装必须关闭，否则
   // marketplace 安装会把 @deepseek-ai 宿主依赖栈拉进 profile；构建脚本必须