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

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,12 @@ node <profile>/node_modules/@1e0zj/dsh-plugin-mall/src/cli.js guard launch --pro
   （这行会出现在任务日志里）。更新检查读的是 registry 的 `/latest` 端点，
   不经过该策略，所以两边看到的「最新版本」本就可能不同。
   首次安装（卡片按钮）不带版本，沿用 pnpm 的策略默认值即可。
+- **一次点击一个任务，日志从第一毫秒开始流**：预检本身就是一个任务，点安装
+  的瞬间就出现在面板里，隔离探针的 pnpm 输出实时写入——而不是让按钮干等几秒
+  再冒出结果。预检通过后由安装任务接管同一条日志、撤掉预检条目，所以面板上
+  始终只有一条记录。运行中只露最后 8 行，落定后折叠成「查看日志（N 行）」。
+- **预检通过直接装**：verdict 为 safe 时不弹任何确认；只有有风险或被阻止才
+  出面板内联卡片（原因列表 + 取消 / 继续），不用模态弹窗打断。
 - **安装期代码要用户点头**：pnpm 默认拦掉依赖的构建脚本，放行等于让那些命令
   以用户的权限在其机器上运行（早于任何插件代码加载）——这个决定属于用户。
   所以被拦时安装**停下**，如实列出要批准的到底是什么：包名@版本、确切的

package/package.json

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

package/src/client.js

@@ -64,7 +64,8 @@ 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_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 +124,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 +148,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 +164,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 +173,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 +338,52 @@ window.__ModuleLoader__.load({
       );
     }
 
+    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 +397,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 +417,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 +429,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 })
           );
         })
       );
@@ -584,7 +657,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 +675,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 +683,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 +706,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);
@@ -777,8 +859,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

@@ -25,7 +25,7 @@ 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 { preflightInstall, inspectRemoteCandidate, recoverProfile } from "./guard.js";
 
 export const name = "@1e0zj/dsh-plugin-mall";
 export const inject = ["tools", "jobs", "systemPrompt"];
@@ -194,7 +194,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 +220,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 +858,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 +922,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 +940,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();
       }
@@ -1134,7 +1196,18 @@ async function rpcDispatch(ctx, endpoint, payload, config, token, tracker) {
       return rpcOk(listInstalled(profile));
     }
     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 +1217,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 +1449,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,