dshmarket 1.46.0 → 1.47.0

package/README.md

@@ -123,6 +123,10 @@ DSHM_REGISTRY_URL=https://your-mirror.example/plugins.json dsh web
 
 [local-dsh](https://github.com/liangchen-harold/local-dsh) — a DeepSeek Harness desktop client that can run the model on your own machine: it bundles llama.cpp next to Node, pnpm and DSH, so a downloaded GGUF model answers without any external API. Built on Tauri; Apple Silicon Macs for now. [localdsh.com](https://localdsh.com)
 
+### dsh desktop (MochiNek0)
+
+[dsh-desktop](https://github.com/MochiNek0/dsh-desktop) — a cross-platform DeepSeek Harness desktop client built on Tauri (Windows, macOS, Linux). It uses the system webview, so the installer is a few megabytes: 2.3 MB on Windows, 5.8 MB on macOS. It starts `dsh web` in the background on launch and embeds it in a native window, sharing sessions and config with the CLI. This market sits first in the recommended list of its built-in plugin panel, one click to install. A Runtime panel enumerates and switches the machine's Node installs and installs or upgrades dsh, no administrator privileges required, and native notifications fire when a turn ends or dsh is waiting on you. [dsh-desktop.cc.cd](https://dsh-desktop.cc.cd/)
+
 ### DSH Get
 
 [DSH Get](https://www.dshget.com/) — a searchable web directory for discovering DeepSeek Harness plugins: category filters, bilingual descriptions, install commands and per-plugin detail pages. Its normalized catalog snapshot is public at [bobby-sheng/dshget-data](https://github.com/bobby-sheng/dshget-data).

package/README.zh.md

@@ -120,6 +120,10 @@ DSHM_REGISTRY_URL=https://your-mirror.example/plugins.json dsh web
 
 [local-dsh](https://github.com/liangchen-harold/local-dsh)——可以把模型跑在本机的 DeepSeek Harness 桌面客户端：发行包内置 llama.cpp 与 Node、pnpm、DSH，下载一个 GGUF 模型就能对话，不必接外部 API。基于 Tauri 构建；目前支持 Apple 芯片的 Mac。[localdsh.com](https://localdsh.com)
 
+### dsh desktop（MochiNek0）
+
+[dsh-desktop](https://github.com/MochiNek0/dsh-desktop)——基于 Tauri 构建的跨平台 DeepSeek Harness 桌面客户端（Windows / macOS / Linux），界面走系统 webview，安装包只有几 MB（Windows 2.3 MB、macOS 5.8 MB）。启动时自动在后台拉起 `dsh web` 并嵌入原生窗口，会话与配置和 CLI 共享；内置插件面板的推荐位第一条就是本市场，点一下即可装上。另有「运行环境」面板枚举与切换本机 Node、安装或升级 dsh，全程无需管理员权限；回合结束或 dsh 等待你确认时发出系统通知。[dsh-desktop.cc.cd](https://dsh-desktop.cc.cd/)
+
 ### DSH Get
 
 [DSH Get](https://www.dshget.com/)——DeepSeek Harness 插件的网页检索目录：分类筛选、中英描述、安装命令与插件详情页；其规范化的目录快照公开在 [bobby-sheng/dshget-data](https://github.com/bobby-sheng/dshget-data)。

package/client/client.js

@@ -1591,10 +1591,20 @@ window.__ModuleLoader__.load({ id: "dshmarket", factory: (require) => {
 		* dependency's spec pins a github repo AND the entry states one, the repos
 		* decide — the loose name/npm identities only apply when at least one side
 		* carries no repo evidence (npm installs, non-github entries).
+		*
+		* Repo evidence only ever decides by repository ROOT. A monorepo catalog
+		* entry states `owner/repo#path:/pkg` while an npm-installed manifest
+		* usually states the bare `owner/repo` (it rarely declares
+		* `repository.directory`), and reading that asymmetry as a source conflict
+		* kept a genuinely installed subpackage from ever reading as installed.
 		*/
+		/** Repository root: the part before any `#path:/…` subpath selection. */
+		function repoRoots(ids) {
+			return new Set([...ids].map((id) => id.split("#path:/")[0]));
+		}
 		function sameSourceConflict(plugin, spec, repoIdentities = []) {
-			const entry = entryRepoIds(plugin);
-			const dep = depRepoIds(spec, repoIdentities);
+			const entry = repoRoots(entryRepoIds(plugin));
+			const dep = repoRoots(depRepoIds(spec, repoIdentities));
 			if (entry.size === 0 || dep.size === 0) return false;
 			for (const id of dep) if (entry.has(id)) return false;
 			return true;
@@ -1645,6 +1655,56 @@ window.__ModuleLoader__.load({ id: "dshmarket", factory: (require) => {
 			for (const id of entryIdentities(plugin)) if (dep.has(id)) return true;
 			return false;
 		}
+		/**
+		* The same memo, for the branch #262 left behind (#589).
+		*
+		* `looseMatchCount` above covers dependencies installed by version. A
+		* `link:` or `file:` dependency takes the other branch, into
+		* `findCatalogEntryForLocal`, which walks the whole catalog at least twice
+		* per call — once to filter by name, once to collect `/tree/` repos — and
+		* up to twice more when there are identities to probe. Both callers below
+		* run once per rendered card. The reporter profiled ~300ms per repaint at
+		* 24 cards against a 3,627-entry catalog where a version-pinned dependency
+		* paid 1.1ms; a local benchmark measured ~38ms per render at that shape,
+		* and ~1.4s at 96 cards with eight local dependencies.
+		*
+		* The inner key carries the EVIDENCE, not just the name. Installing a plugin
+		* hands the next render a fresh identities array while the catalog array
+		* stays the same, so a name-only key would answer the post-install question
+		* with the pre-install result — which is the same-named-fork confusion #485
+		* asked this matcher to stop making, reintroduced as a cache bug.
+		*
+		* A miss is cached as `null`, which is why the "not cached yet" sentinel
+		* has to be `undefined`: `null` is a real answer here, and it costs the
+		* same full scan to establish as a hit does. It is also the common case —
+		* a checkout you are developing is usually not in the catalog at all.
+		*
+		* The invariant this rests on, stated because the WeakMap cannot enforce it:
+		* the catalog array and the entries inside it are frozen once handed here. A
+		* refetch replaces the array — which is what the outer key is for — but an
+		* in-place `push`, `sort` or `reverse`, or editing a row's `url`, would keep
+		* the key and change the answer. Order is load-bearing too: the matcher
+		* returns the FIRST row that fits. Nothing in the client does any of this
+		* today; `visiblePlugins` and `themePlugins` both sort copies.
+		*/
+		const localMatchCache = /* @__PURE__ */ new WeakMap();
+		function cachedEntryForLocal(plugins, name, identities, hints) {
+			let byKey = localMatchCache.get(plugins);
+			if (byKey === void 0) {
+				byKey = /* @__PURE__ */ new Map();
+				localMatchCache.set(plugins, byKey);
+			}
+			const key = JSON.stringify([
+				name,
+				identities,
+				hints
+			]);
+			const hit = byKey.get(key);
+			if (hit !== void 0) return hit;
+			const entry = findCatalogEntryForLocal(plugins, name, identities, hints);
+			byKey.set(key, entry);
+			return entry;
+		}
 		/** The installed dependency name a registry entry corresponds to, or null. */
 		function matchInstalledName(plugin, installed, repoIdentities = {}, plugins, repoHints = {}) {
 			const ids = entryIdentities(plugin);
@@ -1653,7 +1713,7 @@ window.__ModuleLoader__.load({ id: "dshmarket", factory: (require) => {
 				const repos = repoIdentities[name] ?? [];
 				if (/^(?:link|file):/i.test(specStr)) {
 					if (plugins === void 0) continue;
-					const entry = findCatalogEntryForLocal(plugins, name, repos, repoHints[name] ?? []);
+					const entry = cachedEntryForLocal(plugins, name, repos, repoHints[name] ?? []);
 					if (entry !== null && entry.url === plugin.url) return name;
 					continue;
 				}
@@ -2055,7 +2115,7 @@ window.__ModuleLoader__.load({ id: "dshmarket", factory: (require) => {
 		}
 		/** Catalog row for an installed dependency — strict for local link:/file: specs. */
 		function catalogEntryForInstalled(plugins, name, spec, repoIdentities = [], repoHints = []) {
-			if (/^(?:link|file):/i.test(spec)) return findCatalogEntryForLocal(plugins, name, repoIdentities, repoHints) ?? void 0;
+			if (/^(?:link|file):/i.test(spec)) return cachedEntryForLocal(plugins, name, repoIdentities, repoHints) ?? void 0;
 			return entryForDep(plugins, name, spec, repoIdentities, repoHints);
 		}
 		//#endregion
@@ -8614,7 +8674,7 @@ window.__ModuleLoader__.load({ id: "dshmarket", factory: (require) => {
 											children: updatingName === self ? t("updating") : status.restoreRequired === true ? t("restoreOnline") : t("marketUpdate")
 										});
 									})(),
-									reminderBatchUpdatableNames.length >= 2 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
+									reminderBatchUpdatableNames.length >= 1 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.Button, {
 										variant: "primary",
 										size: "sm",
 										disabled: updatingAll || updatingName !== null || busyUrl !== null || removingName !== null,

package/lib/accelerate.js

@@ -112,6 +112,16 @@ async function tryHeadCommit(repo, proxy, signal, ref) {
         // metacharacters (`.` is legal in a branch name).
         const quoted = ref.replace(/[.*+?^${}()|[\]\\]/gu, String.raw `\$&`);
         for (const namespace of ['heads', 'tags']) {
+            // An annotated tag advertises two refs — the tag object and its
+            // peeled commit (`refs/tags/<ref>^{}`). pnpm resolves the tag to the
+            // peeled commit and codeload records that sha in the lockfile, so the
+            // peeled line is the one that must equal `current`; answering with
+            // the tag-object sha made annotated-tag installs report an update
+            // forever (#597). Lightweight tags have no peeled line and fall
+            // through to the direct one.
+            const peeled = new RegExp(String.raw `([0-9a-f]{40}) refs/${namespace}/${quoted}\^\{\}(?![^\s])`, 'u').exec(body);
+            if (peeled !== null)
+                return { kind: 'valid', sha: peeled[1] };
             const found = new RegExp(String.raw `([0-9a-f]{40}) refs/${namespace}/${quoted}(?![^\s])`, 'u').exec(body);
             if (found !== null)
                 return { kind: 'valid', sha: found[1] };

package/lib/changelog.js

@@ -20,8 +20,8 @@
 import { fileFromTarball } from './catalog-npm.js';
 import { marketFetch } from './net.js';
 import { activeRegion, routesFor } from './regions.js';
-import { profileDir, readInstalled, readLockCommits } from './profile.js';
-import { lookupRepoFromUrl, repoOfTarget } from './sources.js';
+import { profileDir, readInstalled, readInstalledRepoEvidence, readLockCommits } from './profile.js';
+import { lookupRepoFromUrl, repoOf, repoOfTarget } from './sources.js';
 import { checkUpdates } from './updates.js';
 import { loadRegistry } from './registry.js';
 const UPDATES_PACKAGE = 'dsh-plugin-updates';
@@ -198,7 +198,24 @@ export async function updateNotesFor(profile, explicitDir, name) {
         if (key === null) {
             try {
                 const registry = await loadRegistry();
-                const plugin = registry.plugins.find(p => p.name === name);
+                const candidates = registry.plugins.filter(p => p.name === name);
+                let plugin;
+                if (candidates.length === 1) {
+                    plugin = candidates[0];
+                }
+                else if (candidates.length > 1) {
+                    // Same-named packages exist in the catalog; a bare name match can
+                    // pick someone else's repo and answer "no notes" for a plugin that
+                    // ships updates data under its own repository (#598). The installed
+                    // package declares its repository, so prefer the catalog entry that
+                    // agrees with it; only a unique agreement is trusted — an ambiguous
+                    // name falls through to npm publish times, which are honest for any
+                    // installed npm package.
+                    const evidence = readInstalledRepoEvidence(profile, name, spec, explicitDir);
+                    const matches = candidates.filter(p => evidence.identities.some(id => repoOf(p.url)?.toLowerCase() === id.split('#')[0].toLowerCase()));
+                    if (matches.length === 1)
+                        plugin = matches[0];
+                }
                 if (plugin !== undefined) {
                     key = plugin.url;
                 }

package/lib/hot.js

@@ -24,11 +24,62 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { asChannel } from './channels.js';
 import { asRegion, normalizeGithubProxy } from './regions.js';
 import { logEvent } from './log.js';
+import { entryArtifactExists } from './profile.js';
+/**
+ * Profile-scoped resolution for hot-mount rows: turn a bare package name into
+ * the absolute `file://` entry URL of the package just installed into
+ * `profileDir`.
+ *
+ * Include-tree rows reach `Include.import` as BARE names (`name:
+ * '@scope/pkg'`), and the base class resolves them against the LOADER's own
+ * location — the host closure
+ * (`closures/<fp>/node_modules/…/cordis-plugin-loader`), whose parent walk
+ * can never reach `home/profiles/<profile>/node_modules/`. Under a host whose
+ * loader sits in an immutable dependency closure, EVERY market hot mount dies
+ * with `Cannot find module '<pkg>' from '…/cordis-plugin-loader/…'` and falls
+ * back to "restart required", blaming the plugin for what is a resolution
+ * anchor problem.
+ *
+ * Resolving the row name HERE, against the profile the package was actually
+ * installed into, is anchor-independent: `require.resolve` walks
+ * `profileDir/node_modules` natively, so the tree hands the loader a
+ * `file://` URL needing no further resolution. Non-bare specifiers (relative
+ * paths, `file://`, `cordis:` builtins) and names that do not resolve under
+ * the profile pass through unchanged, preserving base-class semantics for
+ * every shape this fix does not own.
+ *
+ * The fallback keeps the name bare rather than synthesising a URL: a package
+ * whose entry cannot be located via `require.resolve` (no `main`/exports —
+ * the market's own `entryArtifactExists` heuristic covers those shapes before
+ * an install is accepted) is not something this resolver should guess about.
+ * Client-only shims never reach this function (their rows are replaced by a
+ * no-op host module before the file is written).
+ */
+export function resolveProfileEntry(profileDir, name) {
+    if (!name || name.startsWith('.') || name.startsWith('cordis:') || name.startsWith('file://'))
+        return name;
+    const packageDir = join(profileDir, 'node_modules', ...name.split('/'));
+    try {
+        return pathToFileURL(createRequire(join(profileDir, 'package.json')).resolve(name)).href;
+    }
+    catch {
+        // require.resolve needs a resolvable package entry; the market's install
+        // validation accepts a broader artifact set (exports objects, index.js).
+        // Fall back to the index.js artifact so a valid mount is not refused over
+        // resolver strictness — and keep the bare name when no checkable entry
+        // exists, letting the loader produce its own (accurate) error.
+        if (entryArtifactExists(packageDir)) {
+            return pathToFileURL(join(packageDir, 'index.js')).href;
+        }
+        return name;
+    }
+}
 const HOT_DIR = '.dsh-market';
 /**
  * Ceiling for one hot-mount activation, env-overridable like the install
@@ -394,8 +445,14 @@ export async function hotMount(ctx, profileDir, packageName) {
         mkdirSync(dir, { recursive: true, mode: 0o700 });
         hotSequence += 1;
         const file = join(dir, `hot-${String(hotSequence)}.yml`);
+        // Rows carry ABSOLUTE file:// entry URLs, resolved against this profile:
+        // the loader's own parent-walk (from the host closure) can never reach
+        // `profileDir/node_modules`, so bare names in the file would fail to
+        // import on closure-hosted loaders. The file remains a faithful record —
+        // `cleanHotDir` wipes it on every boot and the bundle layer owns
+        // persistence, so nothing reads these files back.
         const yml = rows
-            .map(row => `- id: 'mkt-${row.id}'\n  name: '${row.name}'\n`)
+            .map(row => `- id: 'mkt-${row.id}'\n  name: '${resolveProfileEntry(profileDir, row.name)}'\n`)
             .join('');
         writeFileSync(file, yml);
         const handle = ctx.plugin(HotTree, { path: pathToFileURL(file).href });
@@ -403,16 +460,25 @@ export async function hotMount(ctx, profileDir, packageName) {
             await raceActivationTimeout(handle.await());
         }
         catch (error) {
+            // A failed or wedged mount must leave NOTHING behind: the disposed
+            // subtree stops retrying the import, and the input file is removed so
+            // it cannot be re-imported by a later boot or replay (a leftover file
+            // re-throwing the same resolve error on every composition replay
+            // produced unbounded error-log growth on a closure-hosted loader).
+            try {
+                Promise.resolve(handle.dispose()).catch(() => { });
+            }
+            catch { /* best effort */ }
+            try {
+                rmSync(file, { force: true });
+            }
+            catch { /* best effort */ }
             if (error instanceof ActivationTimeout) {
                 // A wedged activation would otherwise hold this request open forever:
                 // the route's `finally { installing = false }` never runs, so every
                 // later install/update/uninstall gets 409'd until a host restart.
                 // Unwind the half-mounted subtree best-effort; disposal never blocks
                 // the reply, and the caller falls back to restart activation.
-                try {
-                    Promise.resolve(handle.dispose()).catch(() => { });
-                }
-                catch { /* best effort */ }
             }
             throw error;
         }

package/lib/routes.js

@@ -433,14 +433,31 @@ export function mountMarketRoutes(host, config, commandRuntime, agentsLookup) {
         return { changed: [...changed], partial: changed.size > 0 };
     }
     /**
-     * Apply one enable/disable request: persist the choice in state.json, then
-     * drive the live composition. Covers every mount form — hot mounts and
-     * client-only shims go through hotUnmount/hotMount, bundle-layer entries
-     * through setEntryDisabled. Enabling a THEME goes through the caller's
-     * activateTheme instead so the Themes tab's exclusivity stays intact.
+     * Apply one enable/disable request: drive the live composition, then
+     * persist the choice in state.json. Covers every mount form — hot mounts
+     * and client-only shims go through hotUnmount/hotMount, bundle-layer
+     * entries through setEntryDisabled. Enabling a THEME goes through the
+     * caller's activateTheme instead so the Themes tab's exclusivity stays
+     * intact.
+     *
+     * A FAILED ENABLE LEAVES EVERYTHING AS IT WAS (#575). The choice used to be
+     * recorded before the mount was attempted and persisted whatever happened,
+     * so enabling a plugin that crashes on import — deterministically, every
+     * time — wrote "enabled" into state.json anyway. The next boot tried the
+     * import again and died again; the reporter measured 24 restarts before
+     * restoring the disable by hand. The toggle route's patch-layer gate
+     * (@JINITAIMEI121 in #584) closed the same hole in cordis.patch.yml; this
+     * closes it in the market's own store, which is the ONLY durable state a
+     * client-only plugin has — that plugin kind has no bundle rows, so the
+     * patch gate never runs for it.
+     *
+     * A failed DISABLE still persists, and that asymmetry is deliberate: the
+     * user asked for OFF, and a failed unmount leaves the plugin live only for
+     * this session. There the durable disable is the contract, not an error.
      */
     async function setPluginEnabled(name, enabled) {
         const dir = activeProfileDir;
+        const wasDisabled = disabled.has(name);
         if (enabled)
             disabled.delete(name);
         else
@@ -474,6 +491,14 @@ export function mountMarketRoutes(host, config, commandRuntime, agentsLookup) {
                 ok = true;
             }
         }
+        if (!ok && enabled) {
+            // Put the in-memory view back before persisting: it is the same object
+            // the route reports as `disabled`, so restoring it keeps the reply, the
+            // store and the patch layer telling one story.
+            if (wasDisabled)
+                disabled.add(name);
+            logEvent('warn', 'toggle', `${name}: enable failed; leaving it disabled rather than persisting a state that crashes at boot (#575)`);
+        }
         writeMarketState(dir, { disabled, groups, groupOrder });
         return { ok, reason };
     }
@@ -2004,7 +2029,18 @@ export function mountMarketRoutes(host, config, commandRuntime, agentsLookup) {
                             }
                         }
                         let patchWrite = null;
-                        if (patchRows.length > 0) {
+                        // #575: a failed ENABLE must not flip the durable patch layer.
+                        // The hot-mount failure may be deterministic (a plugin that
+                        // crashes on import), and persisting "enabled" turns a transient
+                        // in-session error into a boot crash loop — the loader re-applies
+                        // the flipped rows on every start. The frontend already shows the
+                        // plugin as still disabled, and the next explicit enable retries
+                        // cleanly. Disables keep their unconditional write: a failed
+                        // unmount leaves the plugin live in-session, and the user asked
+                        // for it OFF — the durable disable is then the contract, not an
+                        // error.
+                        const patchGate = ok || !enabled;
+                        if (patchRows.length > 0 && patchGate) {
                             for (const rowId of patchRows) {
                                 const result = enabled ? await enableRow(userPatchPath, rowId) : await disableRow(userPatchPath, rowId);
                                 if (!result.ok && patchWrite === null)

package/lib/types/hot.d.ts

@@ -32,6 +32,37 @@ interface HotContext {
         warn(message: string): void;
     };
 }
+/**
+ * Profile-scoped resolution for hot-mount rows: turn a bare package name into
+ * the absolute `file://` entry URL of the package just installed into
+ * `profileDir`.
+ *
+ * Include-tree rows reach `Include.import` as BARE names (`name:
+ * '@scope/pkg'`), and the base class resolves them against the LOADER's own
+ * location — the host closure
+ * (`closures/<fp>/node_modules/…/cordis-plugin-loader`), whose parent walk
+ * can never reach `home/profiles/<profile>/node_modules/`. Under a host whose
+ * loader sits in an immutable dependency closure, EVERY market hot mount dies
+ * with `Cannot find module '<pkg>' from '…/cordis-plugin-loader/…'` and falls
+ * back to "restart required", blaming the plugin for what is a resolution
+ * anchor problem.
+ *
+ * Resolving the row name HERE, against the profile the package was actually
+ * installed into, is anchor-independent: `require.resolve` walks
+ * `profileDir/node_modules` natively, so the tree hands the loader a
+ * `file://` URL needing no further resolution. Non-bare specifiers (relative
+ * paths, `file://`, `cordis:` builtins) and names that do not resolve under
+ * the profile pass through unchanged, preserving base-class semantics for
+ * every shape this fix does not own.
+ *
+ * The fallback keeps the name bare rather than synthesising a URL: a package
+ * whose entry cannot be located via `require.resolve` (no `main`/exports —
+ * the market's own `entryArtifactExists` heuristic covers those shapes before
+ * an install is accepted) is not something this resolver should guess about.
+ * Client-only shims never reach this function (their rows are replaced by a
+ * no-op host module before the file is written).
+ */
+export declare function resolveProfileEntry(profileDir: string, name: string): string;
 /**
  * Insert rows of a plugin's bundle patch, or null when the patch contains
  * anything beyond plain `id`/`name` insert rows (config blocks, disables,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dshmarket",
   "description": "Visual plugin market inside DeepSeek Harness — browse, search, and one-click install community plugins. · DSH 可视化插件市场：逛一逛，点一下，装好。",
-  "version": "1.46.0",
+  "version": "1.47.0",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",

package/src/accelerate.ts

@@ -132,6 +132,15 @@ async function tryHeadCommit(
     // metacharacters (`.` is legal in a branch name).
     const quoted = ref.replace(/[.*+?^${}()|[\]\\]/gu, String.raw`\$&`)
     for (const namespace of ['heads', 'tags']) {
+      // An annotated tag advertises two refs — the tag object and its
+      // peeled commit (`refs/tags/<ref>^{}`). pnpm resolves the tag to the
+      // peeled commit and codeload records that sha in the lockfile, so the
+      // peeled line is the one that must equal `current`; answering with
+      // the tag-object sha made annotated-tag installs report an update
+      // forever (#597). Lightweight tags have no peeled line and fall
+      // through to the direct one.
+      const peeled = new RegExp(String.raw`([0-9a-f]{40}) refs/${namespace}/${quoted}\^\{\}(?![^\s])`, 'u').exec(body)
+      if (peeled !== null) return { kind: 'valid', sha: peeled[1]! }
       const found = new RegExp(String.raw`([0-9a-f]{40}) refs/${namespace}/${quoted}(?![^\s])`, 'u').exec(body)
       if (found !== null) return { kind: 'valid', sha: found[1]! }
     }

package/src/changelog.ts

@@ -21,10 +21,10 @@
 import { fileFromTarball } from './catalog-npm.ts'
 import { marketFetch } from './net.ts'
 import { activeRegion, routesFor } from './regions.ts'
-import { profileDir, readInstalled, readLockCommits } from './profile.ts'
-import { lookupRepoFromUrl, repoOfTarget } from './sources.ts'
+import { profileDir, readInstalled, readInstalledRepoEvidence, readLockCommits } from './profile.ts'
+import { lookupRepoFromUrl, repoOf, repoOfTarget } from './sources.ts'
 import { checkUpdates } from './updates.ts'
-import { loadRegistry } from './registry.ts'
+import { loadRegistry, type RegistryPlugin } from './registry.ts'
 
 const UPDATES_PACKAGE = 'dsh-plugin-updates'
 const UPDATES_FILE = 'package/updates.json'
@@ -236,7 +236,24 @@ export async function updateNotesFor(
     if (key === null) {
       try {
         const registry = await loadRegistry()
-        const plugin = registry.plugins.find(p => p.name === name)
+        const candidates = registry.plugins.filter(p => p.name === name)
+        let plugin: RegistryPlugin | undefined
+        if (candidates.length === 1) {
+          plugin = candidates[0]!
+        } else if (candidates.length > 1) {
+          // Same-named packages exist in the catalog; a bare name match can
+          // pick someone else's repo and answer "no notes" for a plugin that
+          // ships updates data under its own repository (#598). The installed
+          // package declares its repository, so prefer the catalog entry that
+          // agrees with it; only a unique agreement is trusted — an ambiguous
+          // name falls through to npm publish times, which are honest for any
+          // installed npm package.
+          const evidence = readInstalledRepoEvidence(profile, name, spec, explicitDir)
+          const matches = candidates.filter(p => evidence.identities.some(
+            id => repoOf(p.url)?.toLowerCase() === id.split('#')[0]!.toLowerCase(),
+          ))
+          if (matches.length === 1) plugin = matches[0]!
+        }
         if (plugin !== undefined) {
           key = plugin.url
         }

package/src/client/MarketSection.tsx

@@ -3745,7 +3745,7 @@ export function MarketSection(props: MarketSectionProps) {
                 >{updatingName === self ? t('updating') : status.restoreRequired === true ? t('restoreOnline') : t('marketUpdate')}</Button>
               )
           })()}
-          {reminderBatchUpdatableNames.length >= 2 && (
+          {reminderBatchUpdatableNames.length >= 1 && (
             <Button
               variant="primary"
               size="sm"

package/src/client/market-data.ts

@@ -691,10 +691,20 @@ function entryRepoIds(plugin: RegistryPlugin): Set<string> {
  * dependency's spec pins a github repo AND the entry states one, the repos
  * decide — the loose name/npm identities only apply when at least one side
  * carries no repo evidence (npm installs, non-github entries).
+ *
+ * Repo evidence only ever decides by repository ROOT. A monorepo catalog
+ * entry states `owner/repo#path:/pkg` while an npm-installed manifest
+ * usually states the bare `owner/repo` (it rarely declares
+ * `repository.directory`), and reading that asymmetry as a source conflict
+ * kept a genuinely installed subpackage from ever reading as installed.
  */
+/** Repository root: the part before any `#path:/…` subpath selection. */
+function repoRoots(ids: ReadonlySet<string>): Set<string> {
+  return new Set([...ids].map(id => id.split('#path:/')[0]!))
+}
 function sameSourceConflict(plugin: RegistryPlugin, spec: string, repoIdentities: readonly string[] = []): boolean {
-  const entry = entryRepoIds(plugin)
-  const dep = depRepoIds(spec, repoIdentities)
+  const entry = repoRoots(entryRepoIds(plugin))
+  const dep = repoRoots(depRepoIds(spec, repoIdentities))
   if (entry.size === 0 || dep.size === 0) return false
   for (const id of dep) if (entry.has(id)) return false
   return true
@@ -754,6 +764,66 @@ function looseMatches(plugin: RegistryPlugin, name: string): boolean {
   return false
 }
 
+/**
+ * The same memo, for the branch #262 left behind (#589).
+ *
+ * `looseMatchCount` above covers dependencies installed by version. A
+ * `link:` or `file:` dependency takes the other branch, into
+ * `findCatalogEntryForLocal`, which walks the whole catalog at least twice
+ * per call — once to filter by name, once to collect `/tree/` repos — and
+ * up to twice more when there are identities to probe. Both callers below
+ * run once per rendered card. The reporter profiled ~300ms per repaint at
+ * 24 cards against a 3,627-entry catalog where a version-pinned dependency
+ * paid 1.1ms; a local benchmark measured ~38ms per render at that shape,
+ * and ~1.4s at 96 cards with eight local dependencies.
+ *
+ * The inner key carries the EVIDENCE, not just the name. Installing a plugin
+ * hands the next render a fresh identities array while the catalog array
+ * stays the same, so a name-only key would answer the post-install question
+ * with the pre-install result — which is the same-named-fork confusion #485
+ * asked this matcher to stop making, reintroduced as a cache bug.
+ *
+ * A miss is cached as `null`, which is why the "not cached yet" sentinel
+ * has to be `undefined`: `null` is a real answer here, and it costs the
+ * same full scan to establish as a hit does. It is also the common case —
+ * a checkout you are developing is usually not in the catalog at all.
+ *
+ * The invariant this rests on, stated because the WeakMap cannot enforce it:
+ * the catalog array and the entries inside it are frozen once handed here. A
+ * refetch replaces the array — which is what the outer key is for — but an
+ * in-place `push`, `sort` or `reverse`, or editing a row's `url`, would keep
+ * the key and change the answer. Order is load-bearing too: the matcher
+ * returns the FIRST row that fits. Nothing in the client does any of this
+ * today; `visiblePlugins` and `themePlugins` both sort copies.
+ */
+const localMatchCache = new WeakMap<RegistryPlugin[], Map<string, RegistryPlugin | null>>()
+
+function cachedEntryForLocal(
+  plugins: RegistryPlugin[],
+  name: string,
+  identities: readonly string[],
+  hints: readonly string[],
+): RegistryPlugin | null {
+  let byKey = localMatchCache.get(plugins)
+  if (byKey === undefined) {
+    byKey = new Map<string, RegistryPlugin | null>()
+    localMatchCache.set(plugins, byKey)
+  }
+  // JSON, not a delimiter-joined string. `[]` and `['']` join to the same
+  // thing and they are NOT the same question: an empty-but-present identity
+  // list has size 1, so it enters the evidence branch and refuses to guess,
+  // while an absent one falls through to the unique-name match. A key that
+  // cannot tell those apart lets whichever ran first answer for both, which
+  // is the guess this matcher exists to refuse. Stringifying the arrays is
+  // injective for free, and its cost is noise beside the scan it replaces.
+  const key = JSON.stringify([name, identities, hints])
+  const hit = byKey.get(key)
+  if (hit !== undefined) return hit
+  const entry = findCatalogEntryForLocal(plugins, name, identities, hints)
+  byKey.set(key, entry)
+  return entry
+}
+
 /** The installed dependency name a registry entry corresponds to, or null. */
 export function matchInstalledName(
   plugin: RegistryPlugin,
@@ -772,7 +842,7 @@ export function matchInstalledName(
     // else's fork as installed (#485).
     if (/^(?:link|file):/i.test(specStr)) {
       if (plugins === undefined) continue
-      const entry = findCatalogEntryForLocal(plugins, name, repos, repoHints[name] ?? [])
+      const entry = cachedEntryForLocal(plugins, name, repos, repoHints[name] ?? [])
       if (entry !== null && entry.url === plugin.url) return name
       continue
     }
@@ -1316,7 +1386,7 @@ export function catalogEntryForInstalled(
   repoHints: readonly string[] = [],
 ): RegistryPlugin | undefined {
   if (/^(?:link|file):/i.test(spec)) {
-    return findCatalogEntryForLocal(plugins, name, repoIdentities, repoHints) ?? undefined
+    return cachedEntryForLocal(plugins, name, repoIdentities, repoHints) ?? undefined
   }
   return entryForDep(plugins, name, spec, repoIdentities, repoHints)
 }

package/src/hot.ts

@@ -17,11 +17,13 @@
  */
 
 import { mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
 import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { asChannel, type Channel } from './channels.ts'
 import { asRegion, normalizeGithubProxy, type Region } from './regions.ts'
 import { logEvent } from './log.ts'
+import { entryArtifactExists } from './profile.ts'
 
 interface HotRow {
   id: string
@@ -38,6 +40,54 @@ interface HotContext {
   logger?: { info?(message: string): void; warn(message: string): void }
 }
 
+/**
+ * Profile-scoped resolution for hot-mount rows: turn a bare package name into
+ * the absolute `file://` entry URL of the package just installed into
+ * `profileDir`.
+ *
+ * Include-tree rows reach `Include.import` as BARE names (`name:
+ * '@scope/pkg'`), and the base class resolves them against the LOADER's own
+ * location — the host closure
+ * (`closures/<fp>/node_modules/…/cordis-plugin-loader`), whose parent walk
+ * can never reach `home/profiles/<profile>/node_modules/`. Under a host whose
+ * loader sits in an immutable dependency closure, EVERY market hot mount dies
+ * with `Cannot find module '<pkg>' from '…/cordis-plugin-loader/…'` and falls
+ * back to "restart required", blaming the plugin for what is a resolution
+ * anchor problem.
+ *
+ * Resolving the row name HERE, against the profile the package was actually
+ * installed into, is anchor-independent: `require.resolve` walks
+ * `profileDir/node_modules` natively, so the tree hands the loader a
+ * `file://` URL needing no further resolution. Non-bare specifiers (relative
+ * paths, `file://`, `cordis:` builtins) and names that do not resolve under
+ * the profile pass through unchanged, preserving base-class semantics for
+ * every shape this fix does not own.
+ *
+ * The fallback keeps the name bare rather than synthesising a URL: a package
+ * whose entry cannot be located via `require.resolve` (no `main`/exports —
+ * the market's own `entryArtifactExists` heuristic covers those shapes before
+ * an install is accepted) is not something this resolver should guess about.
+ * Client-only shims never reach this function (their rows are replaced by a
+ * no-op host module before the file is written).
+ */
+export function resolveProfileEntry(profileDir: string, name: string): string {
+  if (!name || name.startsWith('.') || name.startsWith('cordis:') || name.startsWith('file://')) return name
+  const packageDir = join(profileDir, 'node_modules', ...name.split('/'))
+  try {
+    return pathToFileURL(createRequire(join(profileDir, 'package.json')).resolve(name)).href
+  } catch {
+    // require.resolve needs a resolvable package entry; the market's install
+    // validation accepts a broader artifact set (exports objects, index.js).
+    // Fall back to the index.js artifact so a valid mount is not refused over
+    // resolver strictness — and keep the bare name when no checkable entry
+    // exists, letting the loader produce its own (accurate) error.
+    if (entryArtifactExists(packageDir)) {
+      return pathToFileURL(join(packageDir, 'index.js')).href
+    }
+    return name
+  }
+}
+
 const HOT_DIR = '.dsh-market'
 
 /**
@@ -505,21 +555,33 @@ export async function hotMount(ctx: HotContext, profileDir: string, packageName:
     mkdirSync(dir, { recursive: true, mode: 0o700 })
     hotSequence += 1
     const file = join(dir, `hot-${String(hotSequence)}.yml`)
+    // Rows carry ABSOLUTE file:// entry URLs, resolved against this profile:
+    // the loader's own parent-walk (from the host closure) can never reach
+    // `profileDir/node_modules`, so bare names in the file would fail to
+    // import on closure-hosted loaders. The file remains a faithful record —
+    // `cleanHotDir` wipes it on every boot and the bundle layer owns
+    // persistence, so nothing reads these files back.
     const yml = rows
-      .map(row => `- id: 'mkt-${row.id}'\n  name: '${row.name}'\n`)
+      .map(row => `- id: 'mkt-${row.id}'\n  name: '${resolveProfileEntry(profileDir, row.name)}'\n`)
       .join('')
     writeFileSync(file, yml)
     const handle = ctx.plugin(HotTree, { path: pathToFileURL(file).href })
     try {
       await raceActivationTimeout(handle.await())
     } catch (error) {
+      // A failed or wedged mount must leave NOTHING behind: the disposed
+      // subtree stops retrying the import, and the input file is removed so
+      // it cannot be re-imported by a later boot or replay (a leftover file
+      // re-throwing the same resolve error on every composition replay
+      // produced unbounded error-log growth on a closure-hosted loader).
+      try { Promise.resolve(handle.dispose()).catch(() => {}) } catch { /* best effort */ }
+      try { rmSync(file, { force: true }) } catch { /* best effort */ }
       if (error instanceof ActivationTimeout) {
         // A wedged activation would otherwise hold this request open forever:
         // the route's `finally { installing = false }` never runs, so every
         // later install/update/uninstall gets 409'd until a host restart.
         // Unwind the half-mounted subtree best-effort; disposal never blocks
         // the reply, and the caller falls back to restart activation.
-        try { Promise.resolve(handle.dispose()).catch(() => {}) } catch { /* best effort */ }
       }
       throw error
     }

package/src/routes.ts

@@ -487,14 +487,31 @@ export function mountMarketRoutes(
   }
 
   /**
-   * Apply one enable/disable request: persist the choice in state.json, then
-   * drive the live composition. Covers every mount form — hot mounts and
-   * client-only shims go through hotUnmount/hotMount, bundle-layer entries
-   * through setEntryDisabled. Enabling a THEME goes through the caller's
-   * activateTheme instead so the Themes tab's exclusivity stays intact.
+   * Apply one enable/disable request: drive the live composition, then
+   * persist the choice in state.json. Covers every mount form — hot mounts
+   * and client-only shims go through hotUnmount/hotMount, bundle-layer
+   * entries through setEntryDisabled. Enabling a THEME goes through the
+   * caller's activateTheme instead so the Themes tab's exclusivity stays
+   * intact.
+   *
+   * A FAILED ENABLE LEAVES EVERYTHING AS IT WAS (#575). The choice used to be
+   * recorded before the mount was attempted and persisted whatever happened,
+   * so enabling a plugin that crashes on import — deterministically, every
+   * time — wrote "enabled" into state.json anyway. The next boot tried the
+   * import again and died again; the reporter measured 24 restarts before
+   * restoring the disable by hand. The toggle route's patch-layer gate
+   * (@JINITAIMEI121 in #584) closed the same hole in cordis.patch.yml; this
+   * closes it in the market's own store, which is the ONLY durable state a
+   * client-only plugin has — that plugin kind has no bundle rows, so the
+   * patch gate never runs for it.
+   *
+   * A failed DISABLE still persists, and that asymmetry is deliberate: the
+   * user asked for OFF, and a failed unmount leaves the plugin live only for
+   * this session. There the durable disable is the contract, not an error.
    */
   async function setPluginEnabled(name: string, enabled: boolean): Promise<{ ok: boolean; reason?: string }> {
     const dir = activeProfileDir
+    const wasDisabled = disabled.has(name)
     if (enabled) disabled.delete(name)
     else disabled.add(name)
     let ok: boolean
@@ -522,6 +539,13 @@ export function mountMarketRoutes(
         ok = true
       }
     }
+    if (!ok && enabled) {
+      // Put the in-memory view back before persisting: it is the same object
+      // the route reports as `disabled`, so restoring it keeps the reply, the
+      // store and the patch layer telling one story.
+      if (wasDisabled) disabled.add(name)
+      logEvent('warn', 'toggle', `${name}: enable failed; leaving it disabled rather than persisting a state that crashes at boot (#575)`)
+    }
     writeMarketState(dir, { disabled, groups, groupOrder })
     return { ok, reason }
   }
@@ -2109,7 +2133,18 @@ export function mountMarketRoutes(
             }
           }
           let patchWrite: { ok: boolean; reason: string | null } | null = null
-          if (patchRows.length > 0) {
+          // #575: a failed ENABLE must not flip the durable patch layer.
+          // The hot-mount failure may be deterministic (a plugin that
+          // crashes on import), and persisting "enabled" turns a transient
+          // in-session error into a boot crash loop — the loader re-applies
+          // the flipped rows on every start. The frontend already shows the
+          // plugin as still disabled, and the next explicit enable retries
+          // cleanly. Disables keep their unconditional write: a failed
+          // unmount leaves the plugin live in-session, and the user asked
+          // for it OFF — the durable disable is then the contract, not an
+          // error.
+          const patchGate = ok || !enabled
+          if (patchRows.length > 0 && patchGate) {
             for (const rowId of patchRows) {
               const result = enabled ? await enableRow(userPatchPath, rowId) : await disableRow(userPatchPath, rowId)
               if (!result.ok && patchWrite === null) patchWrite = result