dsh-agent-plugins-market 0.7.2 → 0.8.1

package/lib/application/catalog.js

@@ -12,6 +12,7 @@
 import { qualifiedSuiteId } from '../catalog/paths.js';
 import { loadUserMcpSuite } from '../runtime/mcp-direct-config.js';
 import { loadSuiteOverrides } from '../runtime/mcp-overrides.js';
+import { loadUserHooksSuite } from '../runtime/user-hooks.js';
 import { applyLspOverrides } from '../runtime/server-config.js';
 import { buildSuiteDetail, readSkillContent } from './details.js';
 import { CatalogContext } from './catalog-context.js';
@@ -103,8 +104,14 @@ export class Catalog {
             .map(([key]) => key.slice(0, key.indexOf('/'))));
         const sources = state.sources.filter(source => enabledSources.has(source.id));
         const suites = sources.length === 0 ? [] : (await this.snapshots.build({ ...state, sources }, 'user', this.context.userRoot)).enabledSuites;
-        const direct = await loadUserMcpSuite(this.context.agentsRoot);
-        return applyLspOverrides(this.context.dataRoot, Object.keys(direct.mcp.servers).length === 0 ? suites : [...suites, direct]);
+        // The user's own Agent layout declarations ride the same mount registries
+        // as an installed suite: each direct suite joins the list only when it
+        // declares the content its surface count reports, so an absent or empty
+        // file costs no mount pass.
+        const mcp = await loadUserMcpSuite(this.context.agentsRoot);
+        const hooks = await loadUserHooksSuite(this.context.agentsRoot);
+        const direct = [...(Object.keys(mcp.mcp.servers).length === 0 ? [] : [mcp]), ...(hooks.surfaces.hooks === 0 ? [] : [hooks])];
+        return applyLspOverrides(this.context.dataRoot, direct.length === 0 ? suites : [...suites, ...direct]);
     }
     /** The full market overview from one user snapshot. */
     async overview() {

package/lib/catalog/component-files.js

@@ -1,6 +1,7 @@
 /** Resolve declared component files once; all consumers use the same contained resource paths. */
 import { readFile, readdir, realpath, stat } from 'node:fs/promises';
 import { extname, join, relative, resolve } from 'node:path';
+import { commandCallName } from '../model/command-names.js';
 import { PLUGIN_ROOT_VARIABLES } from '../model/layouts.js';
 import { isFile } from './fs-probes.js';
 import { isWithin } from './paths.js';
@@ -154,6 +155,7 @@ export async function defaultMarkdownResources(root, component) {
 export async function resourceText(resource) {
     return resource.content ?? (await readFile(resource.file, 'utf8'));
 }
+/** Registration name of a command resource; one rule governs suite, project-native, and user-panel commands. */
 export function resourceCommandName(name) {
-    return name.replaceAll('/', '-').replaceAll('\\', '-').toLowerCase();
+    return commandCallName(name);
 }

package/lib/catalog/native-project.js

@@ -47,7 +47,7 @@ export async function discoverNativeProjectSuites(projectRoot, dimension) {
             lspFiles.push('lsp.json');
         for (const path of lspFiles) {
             if (await isFile(join(projectRoot, path))) {
-                errors.push(`${path}: project LSP configuration is not mounted; the host LSP registry does not isolate projects`);
+                errors.push(`${path.replace(/\\/g, '/')}: project LSP configuration is not mounted; the host LSP registry does not isolate projects`);
             }
         }
         // Skills live in `<dir>/skills/<name>/SKILL.md` — the same shape as the

package/lib/catalog/project-config.js

@@ -47,8 +47,6 @@ export async function discoverProjectMcp(projectRoot, files, errors, format = 'm
         found = true;
         Object.assign(servers, table);
     }
-    if (format === 'zcode' && Object.keys(servers).length === 0)
-        return discoverProjectMcp(projectRoot, ['.agents/mcp.json'], errors);
     if (!found)
         return undefined;
     for (const [key, server] of Object.entries(servers)) {

package/lib/catalog/project-hooks.js

@@ -16,9 +16,10 @@ function declarationText(value) {
  * a standalone hook file may carry the bare event table instead of a `hooks`
  * key. A recognized top-level event name is the marker — a document with no
  * event name at the top stays verbatim, so an ordinary settings file missing
- * `hooks` is still not accepted as a bare event table.
+ * `hooks` is still not accepted as a bare event table. Exported because the
+ * user Agent layout root reads the same standalone file shapes.
  */
-function settingsDocument(settings, format) {
+export function standaloneHookDocument(settings, format = 'claude') {
     if (format !== 'claude' || settings.hooks !== undefined)
         return settings;
     const isEventTable = Object.keys(settings).some(key => EVENTS.has(key));
@@ -32,11 +33,15 @@ export async function discoverProjectHooks(projectRoot, files, errors, format =
         if (settings === null)
             return undefined;
         if (settings !== undefined)
-            documents.push({ file, settings: settingsDocument(settings, format) });
+            documents.push({ file, settings: standaloneHookDocument(settings, format) });
     }
     return normalizeHookDocuments(projectRoot, documents, errors, format);
 }
-/** Pure validation shared by native settings and plugin file/inline declarations. */
+/**
+ * Pure validation shared by native settings and plugin file/inline
+ * declarations. `projectRoot` is absent for hooks declared in the user Agent
+ * layout root, which belong to no project.
+ */
 export function normalizeHookDocuments(projectRoot, documents, errors, format = 'claude') {
     const events = Object.create(null);
     const seen = new Set();
@@ -64,7 +69,7 @@ export function normalizeHookDocuments(projectRoot, documents, errors, format =
         }
         for (const [event, groups] of Object.entries(eventTable)) {
             if (!EVENTS.has(event)) {
-                errors.push(`${file}: unsupported project hook event ${event}`);
+                errors.push(`${file}: unsupported hook event ${event}`);
                 continue;
             }
             if (!Array.isArray(groups)) {
@@ -105,7 +110,7 @@ export function normalizeHookDocuments(projectRoot, documents, errors, format =
                         return undefined;
                     }
                     if (hook.async === true || hook.asyncRewake === true) {
-                        errors.push(`${file}: asynchronous project hooks are unsupported`);
+                        errors.push(`${file}: asynchronous hooks are unsupported`);
                         continue;
                     }
                     const key = JSON.stringify([event, matcher, hook.command]);
@@ -125,5 +130,5 @@ export function normalizeHookDocuments(projectRoot, documents, errors, format =
             }
         }
     }
-    return !disabled && Object.keys(events).length > 0 ? { projectRoot, events } : undefined;
+    return !disabled && Object.keys(events).length > 0 ? { ...(projectRoot === undefined ? {} : { projectRoot }), events } : undefined;
 }

package/lib/catalog/surfaces.js

@@ -4,7 +4,8 @@
  *
  * Skills honor any path the winning manifest declares (`skills` may be a
  * string, an array, or absent), scan up to three levels of nesting, and
- * dedupe by frontmatter name. MCP reads both `mcp.json` and the dot-prefixed
+ * dedupe by frontmatter name. A path carrying its own `SKILL.md` is one skill
+ * and nothing else inside it is read. MCP reads both `mcp.json` and the dot-prefixed
  * `.mcp.json`, tolerating unknown transports per server. Every read is
  * fail-closed: broken files produce a diagnostic and are skipped, never a
  * thrown discovery.
@@ -40,10 +41,12 @@ async function declaredSkillDirs(root, declared, errors) {
 }
 /**
  * Discover SKILL.md files under the suite's skills directory, up to 3 levels
- * deep. Portable v1 suites (§7.1) instead discover exactly one level of
- * `skills/` subdirectories each carrying a `SKILL.md` — the spec forbids
- * recursive deeper search and root-level or flat skill files are outside the
- * portable discovery shape.
+ * deep. A path that carries `SKILL.md` is one skill directory — a manifest may
+ * list those individually — and only that document is read from it. Portable
+ * v1 suites (§7.1) instead discover exactly one level of `skills/`
+ * subdirectories each carrying a `SKILL.md` — the spec forbids recursive
+ * deeper search and root-level or flat skill files are outside the portable
+ * discovery shape.
  */
 export async function discoverSkills(root, errors, declared, portable = false) {
     const skills = [];
@@ -96,16 +99,20 @@ export async function discoverSkills(root, errors, declared, portable = false) {
             pushUnique(await parseOneSkill(skillsDir, dirname(skillsDir), '', errors));
             continue;
         }
-        for (const name of await listMdFiles(skillsDir)) {
-            pushUnique(await parseOneSkill(join(skillsDir, name), skillsDir, name.replace(/\.md$/, ''), errors));
-        }
-        // A declared path may be one skill directory (a manifest listing
-        // individual skills, e.g. mattpocock) or a container of skills.
+        // A directory carrying its own `SKILL.md` is one skill, whether a manifest
+        // declared it individually (mattpocock lists every skill directory) or the
+        // conventional container happens to be one. Everything beside that
+        // `SKILL.md` — `references/`, `scripts/`, the notes and formats a skill
+        // attaches — belongs to it, so those documents are neither parsed as flat
+        // skills nor reported as malformed ones.
         if (await isFile(join(skillsDir, 'SKILL.md'))) {
             const name = skillsDir.split(/[\\/]/).at(-1) ?? '';
             pushUnique(await parseOneSkill(join(skillsDir, 'SKILL.md'), skillsDir, name, errors));
             continue;
         }
+        for (const name of await listMdFiles(skillsDir)) {
+            pushUnique(await parseOneSkill(join(skillsDir, name), skillsDir, name.replace(/\.md$/, ''), errors));
+        }
         for (const child of await listChildDirs(skillsDir)) {
             const name = child.split(/[\\/]/).at(-1) ?? '';
             pushUnique(await parseOneSkill(join(child, 'SKILL.md'), child, name, errors));

package/lib/index.js

@@ -1,3 +1,5 @@
+import z from '@deepseek-ai/schemastery';
+import { MarketSettingsFields } from './runtime/mcp-backend.js';
 import { Catalog } from './application/catalog.js';
 import { settlesWithin } from './runtime/deadline.js';
 import { RuntimeReconciler } from './runtime/reconciler.js';
@@ -24,7 +26,26 @@ import { UserCommandMountRegistry } from './runtime/user-commands.js';
 import { presetSourceRef } from './model/preset-source.js';
 export const name = 'dsh-agent-plugins-market';
 export const inject = ['skills', 'commands'];
-export async function apply(ctx, config = {}) {
+export const Config = z.object({
+    userRoot: z.union([z.string(), z.const(undefined)]),
+    dataRoot: z.union([z.string(), z.const(undefined)]),
+    sources: z.any(),
+    git: z.object({
+        proxy: z.string(),
+        insteadOf: z.dict(z.string(), z.any()),
+        timeoutMs: z.natural(),
+        cloneRetry: z.boolean(),
+        fallbackTarball: z.boolean(),
+        allowHttpArchives: z.boolean()
+    }),
+    mcpEnhanced: MarketSettingsFields.mcpEnhanced.volatile(),
+    scanProjectLayouts: MarketSettingsFields.scanProjectLayouts.volatile(),
+    downloadRegion: MarketSettingsFields.downloadRegion.volatile(),
+    feedbackEnabled: MarketSettingsFields.feedbackEnabled.volatile(),
+    autoUpdateSources: MarketSettingsFields.autoUpdateSources.volatile()
+});
+const undefinedRef = { get: () => undefined };
+export async function apply(ctx, config = { mcpEnhanced: undefinedRef, scanProjectLayouts: undefinedRef, downloadRegion: undefinedRef, feedbackEnabled: undefinedRef, autoUpdateSources: undefinedRef }) {
     const userRoot = resolveUserRoot(config.userRoot);
     const dataRoot = resolveDataRoot(config.dataRoot, userRoot);
     const agentsRoot = resolveAgentsRoot();
@@ -110,7 +131,7 @@ export async function apply(ctx, config = {}) {
     };
     // Background source updates: off until the settings switch says otherwise.
     const autoUpdate = new SourceAutoUpdater(ctx, () => catalog.refreshSource());
-    const settings = new MarketSettingsNamespace(ctx, dataRoot, hostLocale, {
+    const settings = new MarketSettingsNamespace(ctx, config, dataRoot, hostLocale, {
         setScanProjectLayouts: enabled => catalog.setScanProjectLayouts(enabled),
         refreshMcpMounts: () => {
             void Promise.all([scheduler.request(), projectMcp?.refresh()]).catch(() => { });

package/lib/model/command-names.js

@@ -0,0 +1,14 @@
+/**
+ * The call name a command resource registers under.
+ *
+ * A command resource may live at any depth under its `commands/` directory,
+ * but the host's slash-command grammar accepts single-segment names only, so
+ * registration flattens the path separators: `git/commit` registers as
+ * `git-commit`. The user panel renders the same call name, so a card never
+ * advertises a slash name the host cannot accept.
+ * @module model/command-names
+ */
+/** Flatten a resource path into the single-segment name a slash command registers under. */
+export function commandCallName(name) {
+    return name.replaceAll('/', '-').replaceAll('\\', '-').toLowerCase();
+}

package/lib/model/layouts.js

@@ -47,6 +47,7 @@ export const PROJECT_LAYOUTS = [
         dirName: '.agents',
         label: 'agents',
         subdirs: ['skills', 'agents', 'commands'],
+        mcpFiles: ['.agents/mcp.json'],
         hookFiles: ['.agents/hooks/hooks.json', '.agents/hooks.json']
     },
     { dirName: '.codex', label: 'Codex', subdirs: ['skills'], mcpFiles: ['.codex/config.toml'], mcpFormat: 'codex' },

package/lib/runtime/commands-mounts.js

@@ -7,6 +7,7 @@ import { expandPluginPaths, pluginRootOf } from '../catalog/plugin-variables.js'
 import { defaultMarkdownResources, resourceText, resourceCommandName } from '../catalog/component-files.js';
 import { bindHostLocale } from './host-locale.js';
 import { injectDynamicContext, shellSeamOf } from './dynamic-context.js';
+import { pluginMarketSource } from './plugin-message-source.js';
 const COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
 export class CommandMountRegistry {
     ctx;
@@ -89,7 +90,7 @@ export class CommandMountRegistry {
                         if (shell === undefined) {
                             agent.followup(createUserMessage({
                                 content: [{ type: 'text', text: body }],
-                                source: { kind: 'plugin', plugin: 'dsh-agent-plugins-market' }
+                                source: pluginMarketSource()
                             }));
                             return { kind: 'success', text: this.t('commandAcknowledged', { command: spec.name }) };
                         }
@@ -102,7 +103,7 @@ export class CommandMountRegistry {
                         }
                         agent.followup(createUserMessage({
                             content: [{ type: 'text', text }],
-                            source: { kind: 'plugin', plugin: 'dsh-agent-plugins-market' }
+                            source: pluginMarketSource()
                         }));
                         return { kind: 'success', text: this.t('commandAcknowledged', { command: spec.name }) };
                     }

package/lib/runtime/hooks-mounts.js

@@ -6,9 +6,12 @@
  *
  * The bridge is a cordis function plugin (`inject: ['shell']`) whose config
  * is a single `configPath` plus `pluginRoot` for `${CLAUDE_PLUGIN_ROOT}`
- * substitution — exactly the shape a suite hook file needs. Mounts reconcile
- * on every enable/disable/install/uninstall; a missing bridge package, a
- * broken hook file, or a mount failure is contained per suite.
+ * substitution — exactly the shape a suite hook file needs. `projectDir` is
+ * forwarded only for hooks declared by a project layout; user Agent layout
+ * hooks carry none, so the bridge defaults `${CLAUDE_PROJECT_DIR}` to the
+ * calling session's workspace. Mounts reconcile on every
+ * enable/disable/install/uninstall; a missing bridge package, a broken hook
+ * file, or a mount failure is contained per suite.
  */
 import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
 import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
@@ -96,7 +99,7 @@ export class HooksMountRegistry {
             handle = mountCtx.plugin(bridge, {
                 configPath,
                 pluginRoot: suite.root,
-                ...(suite.hooks === undefined ? {} : { projectDir: suite.hooks.projectRoot })
+                ...(suite.hooks?.projectRoot === undefined ? {} : { projectDir: suite.hooks.projectRoot })
             });
             await handle.await();
             this.live.set(key, handle);

package/lib/runtime/mcp-backend.js

@@ -24,13 +24,14 @@ import { MARKET_SETTINGS_DEFAULTS } from '../contracts/settings.js';
  * belong to {@link MARKET_SETTINGS_DEFAULTS}; this schema states them, it does
  * not own them.
  */
-export const MarketSettingsSchema = z.object({
+export const MarketSettingsFields = {
     mcpEnhanced: z.boolean().default(MARKET_SETTINGS_DEFAULTS.mcpEnhanced),
     scanProjectLayouts: z.boolean().default(MARKET_SETTINGS_DEFAULTS.scanProjectLayouts),
     downloadRegion: z.union([z.const('auto'), z.const('global'), z.const('china')]).default(MARKET_SETTINGS_DEFAULTS.downloadRegion),
     feedbackEnabled: z.boolean().default(MARKET_SETTINGS_DEFAULTS.feedbackEnabled),
     autoUpdateSources: z.boolean().default(MARKET_SETTINGS_DEFAULTS.autoUpdateSources)
-});
+};
+export const MarketSettingsSchema = z.object(MarketSettingsFields);
 /** Path of the legacy persisted settings file under the plugin data root. */
 export function marketSettingsPath(dataRoot) {
     return join(dataRoot, 'settings.json');

package/lib/runtime/mcp-direct-config.js

@@ -6,11 +6,7 @@ import { effectiveSurfaces } from '../model/types.js';
 export const USER_MCP_SOURCE = '@user-mcp';
 export const USER_MCP_SUITE = 'user-mcp';
 /**
- * User-created services reuse the owned bridge lifecycle without changing host configuration.
- *
- * The declarations live in the shared Agent layout root
- * (`~/.agents/mcp.json`), so a service the user adds by hand is ordinary
- * `mcpServers` JSON in the same place other Agent tools look.
+ * Load the user's own MCP declaration file.
  *
  * The suite always carries an `mcp` document — an absent or malformed
  * `mcp.json` leaves an empty one — so callers read `.mcp.servers` directly
@@ -37,9 +33,10 @@ export async function loadUserMcpSuite(agentsRoot) {
         surfaces: { skills: 0, mcp: Object.keys(mcp.servers).length, commands: 0, agents: 0, hooks: 0, lsp: 0 },
         dimension: 'user',
         enabled: true,
-        // A user-created suite has no install entry and no overrides, so every
-        // surface keeps its enabled default.
-        activeSurfaces: effectiveSurfaces(undefined),
+        // The suite declares MCP only: the other surfaces would otherwise make the
+        // command registry read this root a second time beside the user-command
+        // panel registry.
+        activeSurfaces: effectiveSurfaces({ skills: false, hooks: false, commands: false, agents: false, lsp: false }),
         installedAt: 'user',
         errors
     };
@@ -49,13 +46,25 @@ export async function loadUserMcpSuite(agentsRoot) {
  * keys this client does not know ride along untouched rather than failing the
  * whole file, and the closed-set rule the package schema applies to suites
  * does not apply here.
+ *
+ * A hand-written file may omit `$schema` entirely, so the baseline identifier
+ * is filled in before validation: the document then reads as the baseline
+ * release while every shape and required field the client does know is still
+ * validated. A rejected document keeps the file's own declarations out of the
+ * mount and reports the reason, the same fail-closed rule the write paths
+ * apply.
  */
 async function validateUserMcp(agentsRoot, raw) {
-    const result = await validateMcpJson(agentsRoot, raw, { packageRules: false });
+    const document = isRecord(raw) && raw['$schema'] === undefined ? { ...raw, $schema: MCP_SCHEMA_ID } : raw;
+    const result = await validateMcpJson(agentsRoot, document, { packageRules: false });
     if (result.config === undefined || result.errors.length > 0)
         throw new Error(`invalid MCP configuration: ${result.errors.join('; ')}`);
     return result.config;
 }
+/** Whether a parsed user document is the JSON object the MCP validator reads. */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 /** Add one service atomically; reject collisions and malformed config before writing. */
 export async function addUserMcpServer(agentsRoot, name, server) {
     if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/.test(name))

package/lib/runtime/plugin-message-source.js

@@ -0,0 +1,4 @@
+/** Build the source for one follow-up message; fresh per message, no shared state. */
+export function pluginMarketSource() {
+    return { kind: 'plugin-market', form: 'instructions' };
+}

package/lib/runtime/project-runtime.js

@@ -125,16 +125,19 @@ function mountProjectSurface(ctx, catalog, service, create, withoutProject = fal
         mounts.delete(agent);
         await mount?.fiber.dispose();
     };
-    const unwatchCreated = ctx.on('agent/created', ({ agent }) => attach(agent));
-    const unwatchDisposed = ctx.on('agent/disposed', ({ agent }) => {
-        void detach(agent).catch(warn);
-    });
-    const unwatchStart = ctx.on('agent/session-start', ({ agent }) => {
-        attach(agent);
+    // One lifecycle listener covers every startup path: the host merged the old
+    // agent/session-start emit into agent/created (which now carries the
+    // startup/resume/clear/compact source) and fires it serially.
+    const unwatchCreated = ctx.on('agent/created', ({ agent }) => {
+        const projectAgent = agent;
+        attach(projectAgent);
         // The refresh chain can reject — its queue body re-reads the project
         // catalog — and the host emits this event without awaiting the listener,
         // so an unhandled rejection here would surface at every session start.
-        void mounts.get(agent)?.refresh().catch(warn);
+        void mounts.get(projectAgent)?.refresh().catch(warn);
+    });
+    const unwatchDisposed = ctx.on('agent/disposed', ({ agent }) => {
+        void detach(agent).catch(warn);
     });
     for (const agent of host.agents.list())
         attach(agent);
@@ -146,7 +149,6 @@ function mountProjectSurface(ctx, catalog, service, create, withoutProject = fal
             disposed = true;
             unwatchCreated();
             unwatchDisposed();
-            unwatchStart();
             await Promise.all([...mounts.keys()].map(detach));
         }
     };

package/lib/runtime/settings-namespace.js

@@ -1,12 +1,11 @@
-import { MARKET_SETTINGS_NAMESPACE, resolveMarketSettings } from '../contracts/settings.js';
+import { resolveMarketSettings } from '../contracts/settings.js';
 import { FEEDBACK_TOOL_NAME, mountFeedbackTool } from './feedback-tool.js';
-import { MarketSettingsSchema, readMcpBackend } from './mcp-backend.js';
 export class MarketSettingsNamespace {
     ctx;
+    refs;
     dataRoot;
     locale;
     host;
-    scope;
     watchers = [];
     feedbackDisposer;
     /**
@@ -16,87 +15,66 @@ export class MarketSettingsNamespace {
      * switch, or skipped because the host has no tools registry to register on.
      */
     feedbackMountState;
-    constructor(ctx, dataRoot, locale, host) {
+    constructor(ctx, refs, dataRoot, locale, host) {
         this.ctx = ctx;
+        this.refs = refs;
         this.dataRoot = dataRoot;
         this.locale = locale;
         this.host = host;
     }
-    /** Register the namespace; the host resolves it whenever the settings service mounts. */
+    /** Subscribe the runtime reactions to live settings updates. */
     mount() {
-        this.ctx.inject(['settings'], settingsCtx => this.register(settingsCtx));
+        this.syncProjectLayouts();
+        this.syncAutoUpdateSources();
+        this.syncFeedbackTool();
+        let previousBackend = this.settings().mcpEnhanced;
+        const watcher = this.ctx.on('loader/volatile-update', () => {
+            const backend = this.settings().mcpEnhanced;
+            if (backend !== previousBackend) {
+                previousBackend = backend;
+                this.host.refreshMcpMounts();
+            }
+            this.syncProjectLayouts();
+            this.syncAutoUpdateSources();
+            this.syncFeedbackTool();
+        });
+        this.watchers.push(watcher);
+    }
+    /** Release every watcher and unmount the feedback tool. */
+    dispose() {
+        for (const release of this.watchers.splice(0))
+            release();
+        this.feedbackDisposer?.();
+        this.feedbackDisposer = undefined;
+    }
+    /**
+     * The resolved settings, from the volatile references the host updates in place.
+     */
+    settings() {
+        return resolveMarketSettings({
+            mcpEnhanced: this.refs.mcpEnhanced.get(),
+            scanProjectLayouts: this.refs.scanProjectLayouts.get(),
+            downloadRegion: this.refs.downloadRegion.get(),
+            feedbackEnabled: this.refs.feedbackEnabled.get(),
+            autoUpdateSources: this.refs.autoUpdateSources.get()
+        });
     }
-    /** The persisted MCP backend choice; the built-in client until registration lands. */
+    /** The persisted MCP backend choice; the built-in client until the host applies a value. */
     async backend() {
         return this.settings().mcpEnhanced ? 'builtin' : 'host';
     }
     /**
-     * Persist a backend choice.
-     * @throws when the settings service is not mounted.
+     * Legacy write path for the backend choice: the value now lives in the host
+     * settings document, edited from the Plugins panel's configuration page, so
+     * this accepts the request and lets the volatile reference decide.
      */
     async setBackend(backend) {
-        if (this.scope === undefined)
-            throw new Error('the settings service is not mounted');
-        await this.scope.update({ mcpEnhanced: backend !== 'host' });
+        this.ctx.logger?.info?.(`[dsh-agent-plugins-market] legacy MCP backend write (${backend}) ignored — the value lives in the host settings document`);
     }
     /** The persisted download-region setting. */
     async downloadRegion() {
         return this.settings().downloadRegion;
     }
-    /**
-     * The resolved settings, whether or not the namespace is registered yet.
-     *
-     * Every reader goes through here so "the field is absent" has exactly one
-     * answer — {@link resolveMarketSettings} — instead of each caller inventing
-     * its own fallback for the window before registration lands.
-     */
-    settings() {
-        return resolveMarketSettings(this.scope?.get());
-    }
-    /** Release every watcher and unmount the feedback tool. */
-    dispose() {
-        for (const release of this.watchers.splice(0))
-            release();
-        this.feedbackDisposer?.();
-        this.feedbackDisposer = undefined;
-    }
-    register(settingsCtx) {
-        try {
-            this.ctx.logger?.info?.('[dsh-agent-plugins-market] settings inject resolved — registering namespace');
-            const settings = settingsCtx.settings;
-            const scope = settings.register(MARKET_SETTINGS_NAMESPACE, MarketSettingsSchema);
-            this.scope = scope;
-            this.ctx.logger?.info?.('[dsh-agent-plugins-market] settings namespace registered — plugin-config card will serve');
-            this.syncProjectLayouts();
-            this.watchers.push(scope.watch(() => this.syncProjectLayouts()));
-            this.syncAutoUpdateSources();
-            this.watchers.push(scope.watch(() => this.syncAutoUpdateSources()));
-            // One-time migration from the earlier data-root settings.json choice.
-            void readMcpBackend(this.dataRoot).then(backend => {
-                if (backend === 'host')
-                    void scope.update({ mcpEnhanced: false }).catch(() => { });
-            });
-            let previousBackend = this.settings().mcpEnhanced;
-            this.watchers.push(scope.watch(() => {
-                const backend = this.settings().mcpEnhanced;
-                if (backend === previousBackend)
-                    return;
-                previousBackend = backend;
-                this.host.refreshMcpMounts();
-            }));
-            // The experience-feedback model tool: gated by the namespace's
-            // `feedbackEnabled` field (default on); the switch unregisters it. The
-            // tool mount is doubly contained — its failure must never take the
-            // settings namespace (and with it the config card) down with it. The
-            // mount outcome is logged on every transition so an absent
-            // `report_market_issue` in a session is traceable to its cause.
-            this.syncFeedbackTool();
-            this.watchers.push(scope.watch(() => this.syncFeedbackTool()));
-        }
-        catch (error) {
-            this.ctx.logger?.error?.(`[dsh-agent-plugins-market] settings namespace registration failed — the plugin-config card will be hidden this boot: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
-        }
-    }
     /** Apply the background source-update switch. */
     syncAutoUpdateSources() {
         try {

package/lib/runtime/user-commands.js

@@ -2,12 +2,17 @@
  * User command mounting: every enabled entry of the user commands panel
  * registers as a dsh slash command, so user-authored quick replies behave
  * exactly like suite commands — the body with `$ARGUMENTS` substituted rides
- * one follow-up message on the receiving agent. Reconciled on every catalog
- * change, keyed `user/<name>`.
+ * one follow-up message on the receiving agent. A nested entry registers
+ * under its flattened call name (`git/commit` → `git-commit`) while the panel
+ * keeps addressing it by path; when two entries flatten to one call name the
+ * first registers and the other is reported. Reconciled on every catalog
+ * change, keyed by the call name.
  * @module runtime/user-commands
  */
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
-import { USER_ENTRY_NAME } from './user-store.js';
+import { commandCallName } from '../model/command-names.js';
+import { USER_ENTRY_PATH } from './user-store.js';
+import { pluginMarketSource } from './plugin-message-source.js';
 /** Register/unregister user-panel commands to match the panel's enabled entries. */
 export class UserCommandMountRegistry {
     ctx;
@@ -25,14 +30,24 @@ export class UserCommandMountRegistry {
         const diagnostics = [];
         const entries = await this.store.list();
         const wanted = new Map();
+        // Registration is keyed by call name, so two entries that flatten to the
+        // same one cannot silently shadow each other.
+        const owners = new Map();
         for (const entry of entries) {
             if (entry.disabled)
                 continue;
-            if (!USER_ENTRY_NAME.test(entry.name))
+            if (!USER_ENTRY_PATH.test(entry.name))
                 continue;
-            wanted.set(entry.name, {
-                name: entry.name,
-                description: entry.description === '' ? `[${this.t('userCommandSourceLabel')}] ${entry.name}` : `[${this.t('userCommandSourceLabel')}] ${entry.description}`,
+            const callName = commandCallName(entry.name);
+            const owner = owners.get(callName);
+            if (owner !== undefined) {
+                diagnostics.push(`command "${callName}": "${entry.name}" is shadowed by "${owner}" — both flatten to the same call name`);
+                continue;
+            }
+            owners.set(callName, entry.name);
+            wanted.set(callName, {
+                name: callName,
+                description: entry.description === '' ? `[${this.t('userCommandSourceLabel')}] ${callName}` : `[${this.t('userCommandSourceLabel')}] ${entry.description}`,
                 ...(typeof entry.metadata['argument-hint'] === 'string' && entry.metadata['argument-hint'] !== '' ? { hint: entry.metadata['argument-hint'] } : {}),
                 body: entry.content
             });
@@ -66,7 +81,7 @@ export class UserCommandMountRegistry {
                         const text = spec.body.replaceAll('$ARGUMENTS', invocation.rawInput.trim());
                         agent.followup(createUserMessage({
                             content: [{ type: 'text', text }],
-                            source: { kind: 'plugin', plugin: 'dsh-agent-plugins-market' }
+                            source: pluginMarketSource()
                         }));
                         return { kind: 'success', text: this.t('commandAcknowledged', { command: spec.name }) };
                     }