dsh-waifu-agents 0.2.1 → 0.2.3

package/client.js

@@ -149,6 +149,9 @@ window.__ModuleLoader__.load({
         updateInstallingFrom: '正在从 {registry} 安装（第 {index}/{total} 个源）…',
         updateApplying: '正在应用配置，请稍候…',
         updateCancelling: '正在停止安装…',
+        updateRemoving: '正在卸载旧版本…',
+        updateReinstalling: '正在安装新版本…',
+        updateHandedOff: '插件已随更新重启；到「插件」页确认版本即可。',
         updateWaiting: '安装进行中，别关掉这个窗口',
         updateElapsed: '已用 {s} 秒',
         updateQuiet: '已经 {s} 秒没等到平台的进度回报，但 pnpm 还在跑',
@@ -256,12 +259,14 @@ window.__ModuleLoader__.load({
         purgeHint: '把本插件留在文件系统里的东西一次清掉：会话覆盖记录、全局默认人设指向。打开右边开关会连人设目录一起删。',
         purgeWithDir: '连人设目录一起删',
         purgeAskTitle: '彻底清理本插件的数据',
-        purgeAskBody: '会删除：会话覆盖记录、全局默认人设指向。安装日志、pnpm 索引、pnpm-workspace.yaml 里的放行记录属于平台，这里不动它们，清理完会列给你。',
+        purgeAskBody: '会删除：会话覆盖记录、全局默认人设指向，以及 pnpm-workspace.yaml 里属于本包的放行记录。安装日志、pnpm 索引属于平台，这里不动它们，清理完会列给你。',
         purgeAskAck: '我知道这会清掉本插件的数据',
         updateBanner: '有新版本 {latest}（当前 {installed}）',
         updateGo: '查看',
         checkUpdate: '检查更新',
         recheck: '重新检查更新',
+        updateUpToDate: '已是最新版本 {installed}',
+        updateCheckFailed: '检查更新失败',
         upToDate: '已是最新版本',
         canUpdateTo: '可更新到',
         nowVersion: '当前',
@@ -395,6 +400,9 @@ window.__ModuleLoader__.load({
         updateInstallingFrom: 'Installing from {registry} (source {index} of {total})…',
         updateApplying: 'Applying the configuration, please wait…',
         updateCancelling: 'Stopping the installation…',
+        updateRemoving: 'Removing the old version…',
+        updateReinstalling: 'Installing the new version…',
+        updateHandedOff: 'The plugin restarted with the update; confirm the version on the Plugins page.',
         updateWaiting: 'Installing — leave this window open',
         updateElapsed: '{s}s elapsed',
         updateQuiet: 'no progress report from the platform for {s}s, but pnpm is still running',
@@ -499,12 +507,14 @@ window.__ModuleLoader__.load({
         purgeHint: 'Remove everything this plugin left on disk in one go: the session override store and the global-default pointer. The switch on the right also deletes the persona directory.',
         purgeWithDir: 'Also delete the persona directory',
         purgeAskTitle: 'Purge this plugin\'s data',
-        purgeAskBody: 'Deletes the session override store and the global-default pointer. The install logs, the pnpm store index and the release-age allow-list entry belong to the platform and are listed afterwards instead of touched.',
+        purgeAskBody: 'Deletes the session override store, the global-default pointer, and this package\'s own entries in pnpm-workspace.yaml\'s release-age allow-list. The install logs and the pnpm store index belong to the platform and are listed afterwards instead of touched.',
         purgeAskAck: 'I know this removes the plugin\'s data',
         updateBanner: 'Version {latest} is out (running {installed})',
         updateGo: 'Details',
         checkUpdate: 'Check for updates',
         recheck: 'Check again',
+        updateUpToDate: 'Already on the newest version {installed}',
+        updateCheckFailed: 'The update check failed',
         upToDate: 'Up to date',
         canUpdateTo: 'Update to',
         nowVersion: 'running',
@@ -1401,7 +1411,16 @@ window.__ModuleLoader__.load({
       const phase = String(job.phase ?? 'starting');
       let floor = 3;
       let ceiling = 10;
-      if (phase === 'installing') {
+      if (phase === 'removing') {
+        // The self-removal before the reinstall: brief, but not instant.
+        floor = 6;
+        ceiling = 16;
+      } else if (phase === 'reinstalling') {
+        // The fresh install after the self-removal, before the platform's own
+        // per-registry phases take over and redraw the band.
+        floor = 14;
+        ceiling = 24;
+      } else if (phase === 'installing') {
         // One band per registry tried, so a fallback to a second source is
         // visible as progress instead of as a bar going backwards.
         const index = Math.max(1, Number(job.attempt?.index ?? 1) || 1);
@@ -1431,10 +1450,13 @@ window.__ModuleLoader__.load({
      */
     function progressHeadline(job, t) {
       if (job === null || job === undefined) return '';
+      if (job.handedOff === true) return t('updateHandedOff');
       if (job.done === true) {
         return typeof job.error === 'string' && job.error !== '' ? t('updateFailedTitle') : t('updateDoneTitle');
       }
       const phase = String(job.phase ?? 'starting');
+      if (phase === 'removing') return t('updateRemoving');
+      if (phase === 'reinstalling') return t('updateReinstalling');
       if (phase === 'installing') {
         const attempt = job.attempt;
         const total = Number(attempt?.total ?? 1) || 1;
@@ -1495,6 +1517,7 @@ window.__ModuleLoader__.load({
           .replace('{s}', String(seconds));
       }
       if (typeof job?.error === 'string' && job.error !== '') return t('updateStripFailed');
+      if (job?.handedOff === true) return t('updateHandedOff');
       return t('updateStripDone').replace('{v}', String(job?.result?.version ?? job?.version ?? ''));
     }
 
@@ -1547,7 +1570,17 @@ window.__ModuleLoader__.load({
           { style: { ...L.dialog, maxWidth: '480px', width: '100%' } },
           h('span', { style: L.rowTitle }, t('updateProgressTitle')),
           h('div', { style: L.progressTrack }, h('div', { style: fill })),
-          h('span', { style: failed ? L.error : L.name }, failed ? String(job.error) : done ? progressOutcome(job, t) : progressHeadline(job, t)),
+          h(
+            'span',
+            { style: failed ? L.error : L.name },
+            failed
+              ? String(job.error)
+              : job.handedOff === true
+                ? t('updateHandedOff')
+                : done
+                  ? progressOutcome(job, t)
+                  : progressHeadline(job, t),
+          ),
           note === '' ? null : h('span', { style: L.meta }, note),
           exit === '' ? null : h('span', { style: L.meta }, exit),
           log === ''
@@ -2362,8 +2395,10 @@ window.__ModuleLoader__.load({
               ),
               // No preset, no switch: a default has to name something the
               // registry holds, and this team is not registered yet (the sync
-              // is in flight, or it failed). Saying which is `teamNoPreset`.
-              noPreset ? h('span', { style: L.hint }, t('teamNoPreset')) : null,
+              // is in flight, or it failed). The disabled switch says it on
+              // its own — an inline hint used to sit here and squeezed the
+              // row out of shape on long copy, so it is gone; the refusal
+              // stays said, in the editor, if someone forces the write.
               h('span', { style: L.push }),
               known
                 ? h(SwitchBox, {
@@ -3356,7 +3391,23 @@ window.__ModuleLoader__.load({
         const poll = () => {
           post({ op: 'updateProgress', requestId })
             .then((payload) => {
-              if (!alive || payload.idle === true) return;
+              if (!alive) return;
+              if (payload.idle === true) {
+                /*
+                 * The host no longer knows this job. That is the two-step
+                 * update succeeding the loud way: the removal plus reinstall
+                 * ended in an HMR reload, the module that owned the job is
+                 * gone, and the fresh module answering polls has never heard
+                 * of this requestId. Report it as a hand-off to the restart
+                 * instead of letting the bar sit on its last phase forever.
+                 */
+                setJob((prev) =>
+                  prev !== null && prev !== undefined && prev.done !== true
+                    ? { ...prev, done: true, handedOff: true, error: null }
+                    : prev,
+                );
+                return;
+              }
               setJob((prev) => (prev === null || prev === undefined ? prev : { ...prev, ...payload }));
             })
             .catch(() => {
@@ -4114,9 +4165,32 @@ window.__ModuleLoader__.load({
       async function checkUpdate() {
         setBusy(true);
         try {
-          setUpdate(await post({ op: 'updateCheck' }));
+          const payload = await post({ op: 'updateCheck' });
+          setUpdate(payload);
+          /*
+           * The banner re-renders from `update`, but a silent re-render is not
+           * an answer: the person pressed a button and gets told, out loud,
+           * which of the three outcomes happened — newer version, already
+           * current, or the registry could not be reached.
+           */
+          if (payload?.updateAvailable === true) {
+            setNote({
+              kind: 'ok',
+              text: t('updateBanner')
+                .replace('{latest}', payload.latest ?? '')
+                .replace('{installed}', payload.installed ?? payload.running ?? ''),
+            });
+          } else if (typeof payload?.error === 'string' && payload.error !== '') {
+            setNote({ kind: 'error', text: `${t('updateCheckFailed')}：${payload.error}` });
+          } else {
+            setNote({
+              kind: 'ok',
+              text: t('updateUpToDate').replace('{installed}', payload?.installed ?? payload?.running ?? ''),
+            });
+          }
         } catch (failure) {
           setUpdate({ error: String(failure?.message ?? failure) });
+          setNote({ kind: 'error', text: `${t('updateCheckFailed')}：${failure?.message ?? failure}` });
         } finally {
           setBusy(false);
         }

package/index.js

@@ -40,12 +40,31 @@
  *
  * `updateApply` is what makes a published fix reachable without a shell: the
  * panel posts it, `latestVersion` asks the registry, and the install goes
- * through the very service the Plugins page uses — `pnpm add <name>@<version>`,
- * which also REWRITES the profile's version range. That range, not the plugin,
- * is what keeps an old copy installed: `^0.0.1` can never resolve `0.1.0`, so
- * every release used to need a hand-edited spec. An already-installed package
- * is never hot-reloaded — the manager answers `restart-required`, and so does
- * this op, which is why the panel says so out loud.
+ * through the very service the Plugins page uses. Three layers, tried in
+ * order:
+ *
+ * 1. TARBALL (updates of an installed package): the new version's tarball URL
+ *    is the one spec shape the manager's HMR precheck cannot match by name —
+ *    its package name is only known after pnpm runs — so the install reaches
+ *    pnpm over the installed copy, and the HMR re-composition replaces the
+ *    running plugin in place. No removal, no restart in the success path.
+ *    This also rewrites the profile's saved dependency from a version range
+ *    to the exact URL; the next update's URL differs again, so nothing is
+ *    ever refused as already-installed on this road twice.
+ * 2. NAME (fresh installs, and the two-step's second half): the plain
+ *    `name@version` spec keeps a fresh install's saved dependency a clean
+ *    range.
+ * 3. TWO-STEP (fallback if the tarball road is somehow refused with
+ *    `already-installed`): remove the running bundle, then install the new
+ *    version from the same fiber — a resolved promise never interrupts the
+ *    fiber that awaited it. Whether the fiber survives its own removal is
+ *    what real-machine use finds out; every failure is caught and reported
+ *    with the manual remove-then-install on the Plugins page as the last
+ *    resort.
+ *
+ * The personas directory and `teams.json` live outside the package, so no
+ * path through any layer — success, half-done, or failure — touches user
+ * data.
  *
  * No configuration is required: `resolveDir` picks the directory from the row
  * config, then from `<home>/personas`, then — on a machine that does not have it
@@ -228,6 +247,50 @@ async function latestVersion(registry) {
   return { version: latest, registry: base };
 }
 
+/**
+ * The tarball URL of a published version.
+ *
+ * This is the one spec shape the manager's HMR precheck CANNOT refuse with
+ * `already-installed`: the precheck matches specs it can name before pnpm
+ * runs — a registry name, a local directory, or the exact git/tarball spec the
+ * dependency was saved with — and a fresh tarball URL names a package only
+ * after pnpm has fetched it. Installing version N+1 from its own tarball
+ * therefore reaches pnpm over an installed version N, and the HMR
+ * re-composition replaces the running plugin in place (the documented
+ * behavior). The abbreviated packument names the URL authoritatively
+ * (`dist.tarball`), so one small GET asks the registry; a registry that will
+ * not answer falls back to the npm tarball path convention, which every
+ * registry this plugin can be pointed at follows
+ * (`<base>/<name>/-/<name>-<version>.tgz`). Constructing never throws, so this
+ * helper always returns a usable URL.
+ * @param {string} [registry] registry base URL; the row config may override it
+ * @param {string} version exact published version
+ * @returns {Promise<string>}
+ */
+async function tarballUrlOf(registry, version) {
+  const base = String(registry ?? "").trim() || DEFAULT_REGISTRY;
+  const construct = () =>
+    new URL(
+      `${PACKAGE_NAME}/-/${PACKAGE_NAME}-${version}.tgz`,
+      base.endsWith("/") ? base : `${base}/`,
+    ).href;
+  if (typeof fetch !== "function") return construct();
+  try {
+    const url = new URL(PACKAGE_NAME, base.endsWith("/") ? base : `${base}/`)
+      .href;
+    const response = await fetch(url, {
+      headers: { accept: "application/vnd.npm.install-v1+json" },
+      signal: AbortSignal.timeout(LOOKUP_TIMEOUT_MS),
+    });
+    if (!response.ok) return construct();
+    const meta = await response.json();
+    const tarball = meta?.versions?.[version]?.dist?.tarball;
+    return typeof tarball === "string" && tarball !== "" ? tarball : construct();
+  } catch {
+    return construct();
+  }
+}
+
 /**
  * The shared skeleton: a reserved name in the persona directory that is never a
  * wife. It is the frame a `template:`-using persona is poured into, with
@@ -2459,6 +2522,32 @@ export function apply(ctx, config = {}) {
     owned.set(id, { dispose, rev: registrationRev(skeleton, body) });
   }
 
+  /**
+   * Does this roster row carry OUR fingerprint?
+   *
+   * Both persona presets and team presets are registered through
+   * `buildDefinition`, whose `plugins` rows include `@deepseek-ai/dsh-persona`
+   * rewritten with `PERSONA_PLACEHOLDER` as the prefix — a combination nothing
+   * else registers. A roster row matching it is this plugin's own previous
+   * instance, not a foreign owner.
+   *
+   * The shape of `agentPresets.list()` rows is NOT promised to include the
+   * registered `plugins` array; if it does not, this answers `false` and the
+   * scan reports the conflict exactly as it did before — the fingerprint is
+   * only ever evidence FOR a reclaim, never against a row.
+   * @param {unknown} row - one entry of `ctx.agentPresets.list()`
+   * @returns {boolean}
+   */
+  function isOwnPresetShape(row) {
+    const plugins = row?.plugins;
+    if (!Array.isArray(plugins)) return false;
+    return plugins.some(
+      (plugin) =>
+        plugin?.name === "@deepseek-ai/dsh-persona" &&
+        plugin?.config?.prefix === PERSONA_PLACEHOLDER,
+    );
+  }
+
   /**
    * Register every file that is not already taken by this or another owner, and
    * RE-register the ones whose text changed since they were registered.
@@ -2476,9 +2565,10 @@ export function apply(ctx, config = {}) {
      * entry would be a lie that survives a fix.
      */
     foreign.clear();
-    const taken = new Set();
+    const roster = new Map();
     try {
-      for (const preset of await ctx.agentPresets.list()) taken.add(preset.id);
+      for (const preset of await ctx.agentPresets.list())
+        roster.set(preset.id, preset);
     } catch (error) {
       return {
         added: [],
@@ -2526,14 +2616,40 @@ export function apply(ctx, config = {}) {
         }
         continue;
       }
-      if (taken.has(item.id)) {
+      if (roster.has(item.id)) {
         /*
-         * `taken` counts OUR rows too, and an id that is mid-registration is
+         * `roster` counts OUR rows too, and an id that is mid-registration is
          * still ours. Calling that a foreign conflict is how the panel ended up
          * accusing a wife of stealing her own id; a read that lands here simply
          * has nothing to do.
          */
         if (registering.has(item.id)) continue;
+        /*
+         * Ghost reclaim. Within one DSH process, an uninstall leaves the
+         * preset table holding this plugin's old entries (observed on a
+         * remove-then-reinstall with HMR: every row read 「被别的所有者占用」
+         * until a restart cleared the table). Such a ghost is not another
+         * owner — it is OUR previous instance, and it carries our fingerprint:
+         * only this plugin registers presets whose plugins rows contain
+         * `@deepseek-ai/dsh-persona` with our placeholder as the prefix.
+         * Re-registering over it is therefore reclaiming, not stealing — and
+         * if the registry refuses the duplicate, the catch falls through to
+         * the same foreign report as before, so the attempt cannot make
+         * anything worse.
+         */
+        if (isOwnPresetShape(roster.get(item.id))) {
+          holdRegistration(item.id);
+          try {
+            await registerOne(item.id, parsed.meta, parsed.body);
+            added.push(item.id);
+            continue;
+          } catch {
+            // The registry refused the overwrite: report the conflict below,
+            // exactly as if no reclaim had been attempted.
+          } finally {
+            releaseRegistration(item.id);
+          }
+        }
         foreign.add(item.id);
         skipped.push({ id: item.id, reason: "已经有人注册了这个 id" });
         continue;
@@ -4295,20 +4411,20 @@ export function apply(ctx, config = {}) {
    * Install the newest published version, through the same service the Plugins
    * page uses.
    *
-   * The exact version is passed, never a range. That matters twice over:
-   * `pnpm add <name>@<version>` is what REWRITES the profile's declared range to
-   * `^<version>` (a stale `^0.0.1` can never resolve `0.1.0`, which is the whole
-   * reason a fresh release used to install nothing), and a pinned version keeps
-   * the resolver from having to pick one out of a moving range.
-   *
-   * Pinning buys nothing from the 24h `minimumReleaseAge` policy: the install
-   * has to record the release in the workspace's `minimumReleaseAgeExclude`
-   * first (this profile has carried both a `dsh-waifu-agents@0.2.0` and a
-   * `dsh-waifu-agents@0.2.1` entry ever since those installs), and with no
-   * entry covering it the lockfile check refuses the install outright with
-   * `ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION`. So a fresh release can still be
-   * held back here for up to 24h; surface that failure rather than promising a
-   * bypass.
+   * The exact version is passed, never a range. The spec it installs FROM
+   * depends on what is already on disk (see the comment at the choice below):
+   * an update goes through the new version's tarball URL — the spec shape the
+   * HMR precheck cannot refuse — and a fresh install keeps the plain
+   * `name@version`, whose install rewrites the profile's declared range.
+   *
+   * `minimumReleaseAge`: a registry-name install is subject to the 24h
+   * freshness policy and must be recorded in the workspace's
+   * `minimumReleaseAgeExclude` first, or the lockfile check refuses outright
+   * with `ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION`. A tarball URL install
+   * fetches the package file directly and plausibly never consults publish
+   * times — expected but NOT verified against the manager's pnpm invocation,
+   * so the failure, should it come, is surfaced verbatim rather than promised
+   * away.
    *
    * Returns as soon as the install is STARTED, not when it finishes, and hands
    * back the `requestId` that makes the platform publish progress for it. The
@@ -4375,6 +4491,25 @@ export function apply(ctx, config = {}) {
         },
       };
     }
+    /*
+     * Which spec to install from, decided by what is already on disk.
+     *
+     * An UPDATE of an installed package installs from the new version's
+     * tarball URL: that is the one spec shape the HMR precheck cannot match by
+     * name, so it reaches pnpm over the installed copy and the re-composition
+     * replaces the running plugin in place — no removal, no fiber gamble. It
+     * also rewrites the profile's saved dependency from a version range to the
+     * exact URL, which is deliberate: the next update's URL differs again, so
+     * no future install is ever refused as already-installed.
+     *
+     * A FRESH install (nothing readable on disk) keeps the registry name:
+     * there is nothing installed for the precheck to refuse, and the saved
+     * spec stays a plain dependency. If that judgement is wrong — the copy on
+     * disk was unreadable, not absent — the name spec is refused with
+     * `already-installed` and the two-step below takes over.
+     */
+    let spec = `${PACKAGE_NAME}@${version}`;
+    if (before !== null) spec = await tarballUrlOf(config.registry, version);
     /*
      * The id is minted here, or accepted from the panel when it sent one. It
      * exists because the platform publishes progress ONLY for an installation
@@ -4411,25 +4546,92 @@ export function apply(ctx, config = {}) {
      */
     void (async () => {
       try {
-        const outcome = await manager.installBundle(
-          `${PACKAGE_NAME}@${version}`,
-          { enabled: true, requestId },
-        );
-        job.done = true;
+        const outcome = await manager.installBundle(spec, {
+          enabled: true,
+          requestId,
+        });
         if (outcome?.application === "failed") {
+          /*
+           * The tarball spec should never be refused with `already-installed`
+           * (its package name is only known after pnpm runs), and a fresh
+           * install has nothing installed to refuse. Landing here anyway
+           * means the manager named the installed package from the spec
+           * after all, or the disk judgement above was wrong — either way the
+           * documented cross-version path is remove-then-install, and the
+           * fiber that awaited the removal is never interrupted by the
+           * resolution itself, so this fallback performs the two-step right
+           * here: remove, then install the new version from the same fiber
+           * under its plain registry name. Whether the host lets the fiber
+           * survive its own removal is what real-machine use finds out; every
+           * way it can die is caught below and reported with the manual path
+           * as the last resort. Nothing here can touch user data — personas
+           * and teams.json are outside the package.
+           */
+          const code = String(outcome.error?.code ?? outcome.error?.message ?? "");
+          if (code.includes("already-installed")) {
+            ctx.logger?.warn?.(
+              `dsh-waifu-agents: installBundle refused ${version} (already-installed); performing remove-then-install.`,
+            );
+            job.phase = "removing";
+            try {
+              await manager.removeBundle(PACKAGE_NAME);
+            } catch (removeFailure) {
+              job.done = true;
+              job.error = `卸载旧版本失败（${removeFailure?.message ?? removeFailure}），已安装的版本没有变动。请到「插件」页手动卸载后重新安装 ${version}。`;
+              return;
+            }
+            /*
+             * Still running — the fiber survived its own removal. The spec no
+             * longer names an installed package, so the precheck lets the new
+             * version through to pnpm.
+             */
+            job.phase = "reinstalling";
+            let retry = null;
+            try {
+              retry = await manager.installBundle(`${PACKAGE_NAME}@${version}`, {
+                enabled: true,
+                requestId,
+              });
+            } catch (installFailure) {
+              job.done = true;
+              job.error = `旧版本已卸载，但安装 ${version} 失败：${installFailure?.message ?? installFailure}。请到「插件」页重新安装——人设目录（personas）和团队配置（teams.json）不在包里，不受影响。`;
+              return;
+            }
+            if (retry?.application === "failed") {
+              job.done = true;
+              job.error = `旧版本已卸载，但安装 ${version} 失败：${retry.error?.message ?? retry.error?.code ?? JSON.stringify(retry.error)}。请到「插件」页重新安装——人设目录（personas）和团队配置（teams.json）不在包里，不受影响。`;
+              if (job.log === "") job.log = String(retry?.packageResult?.output ?? "");
+              return;
+            }
+            job.done = true;
+            job.result = {
+              ok: true,
+              version,
+              previous: before,
+              application: retry?.application ?? null,
+              changed: retry?.changed === true,
+              installed: readOwnVersion(),
+              log: String(retry?.packageResult?.output ?? ""),
+              twoStep: true,
+            };
+            return;
+          }
+          job.done = true;
           job.error = `安装失败：${outcome.error?.message ?? outcome.error?.code ?? JSON.stringify(outcome.error)}`;
           // The manager's own transcript is the useful half of this failure,
           // and it is only here if the streaming feed never spoke.
           if (job.log === "") job.log = String(outcome?.packageResult?.output ?? "");
           return;
         }
+        job.done = true;
         job.result = {
           ok: true,
           version,
           previous: before,
-          // The manager never hot-swaps an already-installed package, so this
-          // is `restart-required` in practice. Its own word is passed through
-          // rather than a promise this code cannot keep.
+          // Without HMR this is `restart-required`; with HMR a fresh install
+          // (the two-step above included) may genuinely apply. The manager's
+          // own word is passed through rather than a promise this code cannot
+          // keep.
           application: outcome?.application ?? null,
           changed: outcome?.changed === true,
           installed: readOwnVersion(),
@@ -5076,16 +5278,117 @@ export function apply(ctx, config = {}) {
     return { ok: true, order: ids, changed, reloaded: reloaded.reloaded ?? [] };
   }
 
+  /**
+   * Remove THIS package's entries from `minimumReleaseAgeExclude`.
+   *
+   * The list lives in a profile's `pnpm-workspace.yaml` — a file pnpm owns —
+   * but every entry naming `dsh-waifu-agents` exists BECAUSE of this plugin:
+   * pnpm wrote it to let our install past the 24h freshness policy. Deleting
+   * our own lines is not reaching into another owner's file any more than
+   * unregistering our presets is; the entries that name other packages, and
+   * every other byte of the file, pass through untouched.
+   *
+   * The profile name is only visible when `DSH_PROFILE_DIR` reaches this
+   * process; without it every profile is scanned, which is safe precisely
+   * because the filter matches our name and nothing else. A profile that
+   * never installed this plugin has no matching line and is left identical —
+   * the write happens only when a line was actually removed.
+   * @returns {{ cleaned: string[], failed: string[] }}
+   */
+  function cleanReleaseAgeExcludes() {
+    const cleaned = [];
+    const failed = [];
+    const profileDir = process.env.DSH_PROFILE_DIR
+      ? path.resolve(process.env.DSH_PROFILE_DIR)
+      : null;
+    let candidates;
+    if (profileDir !== null) {
+      candidates = [path.join(profileDir, "pnpm-workspace.yaml")];
+    } else {
+      const profiles = path.join(homeFromEnv(process.env).home, "profiles");
+      try {
+        candidates = fs
+          .readdirSync(profiles, { withFileTypes: true })
+          .filter((row) => row.isDirectory())
+          .map((row) => path.join(profiles, row.name, "pnpm-workspace.yaml"));
+      } catch {
+        candidates = [];
+      }
+    }
+    for (const full of candidates) {
+      let raw;
+      try {
+        raw = fs.readFileSync(full, "utf8");
+      } catch {
+        continue; // no such file — a profile without pnpm state, nothing to do
+      }
+      const lines = raw.split("\n");
+      const keep = [];
+      let changed = false;
+      for (let at = 0; at < lines.length; ) {
+        const line = lines[at];
+        if (!/^minimumReleaseAgeExclude\s*:/.test(line)) {
+          keep.push(line);
+          at += 1;
+          continue;
+        }
+        // Flow form `key: [a, b]`: filter inside the brackets, drop the key
+        // when nothing of ours was in it (then the line is reproduced as-is).
+        const flow = /^minimumReleaseAgeExclude\s*:\s*\[(.*)\]\s*\r?$/.exec(line);
+        if (flow !== null) {
+          const items = flow[1]
+            .split(",")
+            .filter((item) => item.trim() !== "");
+          const rest = items.filter((item) => !item.includes(PACKAGE_NAME));
+          if (rest.length === items.length) {
+            keep.push(line);
+          } else {
+            changed = true;
+            if (rest.length > 0)
+              keep.push(`minimumReleaseAgeExclude: [${rest.join(", ")}]`);
+          }
+          at += 1;
+          continue;
+        }
+        // Block form: gather the list items that follow.
+        const items = [];
+        let cursor = at + 1;
+        while (cursor < lines.length && /^\s+-\s/.test(lines[cursor])) {
+          items.push(lines[cursor]);
+          cursor += 1;
+        }
+        const rest = items.filter((item) => !item.includes(PACKAGE_NAME));
+        if (rest.length === items.length) {
+          keep.push(line, ...items);
+        } else {
+          changed = true;
+          if (rest.length > 0) keep.push(line, ...rest);
+          // zero left: the key goes too — an empty list is noise
+        }
+        at = cursor;
+      }
+      if (!changed) continue;
+      try {
+        writeAtomic(full, keep.join("\n"));
+        cleaned.push(full);
+      } catch (error) {
+        failed.push(`${full}：${error?.message ?? error}`);
+      }
+    }
+    return { cleaned, failed };
+  }
+
   /**
    * Undo everything this plugin put outside its own package.
    *
    * Only three things are ours and outlive an uninstall: the per-session
    * override store, the `selectedDefault` line this panel writes into the
    * agent-preset registry's config, and — only when explicitly asked — the
-   * persona directory itself. Everything else an install leaves behind belongs to
-   * the platform (the plugin-manager's operation logs, pnpm's store index, the
-   * release-age allow-list entry it wrote at install time), so this op names them
-   * instead of pretending to clean them.
+   * persona directory itself. The freshness allow-list lines naming this
+   * package are ours too (pnpm wrote them for OUR install), and are stripped.
+   * Everything else an install leaves behind belongs to
+   * the platform (the plugin-manager's operation logs, pnpm's store index),
+   * so this op names them instead of pretending to clean them.
    * @param {{ dir?: boolean }} request
    */
   async function purge(request) {
@@ -5102,6 +5405,14 @@ export function apply(ctx, config = {}) {
       }
     }
     overrides = {};
+    try {
+      const excludes = cleanReleaseAgeExcludes();
+      for (const full of excludes.cleaned)
+        done.push(`清掉放行记录 ${full} 里属于本包的条目`);
+      for (const message of excludes.failed) failed.push(`放行记录：${message}`);
+    } catch (error) {
+      failed.push(`放行记录：${error?.message ?? error}`);
+    }
     try {
       const configEditor = ctx.get("configEditor");
       const entry =
@@ -5186,7 +5497,6 @@ export function apply(ctx, config = {}) {
       platform: [
         ".plugin-manager\\logs\\operation-*（安装日志，平台自己累积）",
         "pnpm 内容库索引：需要 pnpm store prune",
-        "pnpm-workspace.yaml 的 minimumReleaseAgeExclude（安装时 pnpm 自己写的放行记录）",
       ],
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-waifu-agents",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "description": "Registers every *.md in a persona directory as an agent preset, and manages them from the Plugins settings page.",
   "license": "MIT",