dsh-agent-plugins-market 0.6.0 → 0.6.2

package/lib/runtime/feedback-tool.js

@@ -0,0 +1,181 @@
+/**
+ * Optional model-facing experience-feedback tool.
+ *
+ * When enabled (the `feedbackEnabled` field of the market settings namespace,
+ * default true), the model can call `report_market_issue` when it concludes a
+ * problem it is looking at is caused by dsh-agent-plugins-market — a failed
+ * install, a misdetected source, a market UI defect the user just described.
+ * The tool files a GitHub issue on the plugin repository through the GitHub
+ * REST API, or falls back to appending a local JSONL record under the plugin
+ * data root when no repository host context is available.
+ *
+ * The tool is deliberately narrow: the title/body must describe the problem,
+ * submissions are rate-limited, and the setting switch unregisters the tool
+ * on the next reconcile pass.
+ * @module runtime/feedback-tool
+ */
+import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+/** The GitHub repository experience feedback files issues against. */
+export const FEEDBACK_REPO_OWNER = 'Sivan757';
+export const FEEDBACK_REPO_NAME = 'dsh-agent-plugins-market';
+/** Label applied to every tool-filed issue so they are filterable. */
+export const FEEDBACK_LABEL = 'agent-feedback';
+/** Minimum milliseconds between two accepted submissions (burst guard). */
+const SUBMIT_COOLDOWN_MS = 60_000;
+/**
+ * Submit one experience report. Tries the GitHub issue API first (works when
+ * the deployment carries a GITHUB_TOKEN / GH_TOKEN with repo scope), then
+ * falls back to the local JSONL spool under `<dataRoot>/feedback/`.
+ */
+export async function submitFeedback(dataRoot, report, now = Date.now()) {
+    const title = report.title.trim();
+    if (title === '')
+        return { ok: false, reason: 'title is required' };
+    const body = renderFeedbackBody(report);
+    const lastAt = await readLastSubmitAt(dataRoot);
+    if (now - lastAt < SUBMIT_COOLDOWN_MS) {
+        return { ok: false, reason: 'a feedback report was submitted less than a minute ago; wait and try again' };
+    }
+    const token = process.env['GITHUB_TOKEN'] ?? process.env['GH_TOKEN'];
+    if (token !== undefined && token !== '') {
+        try {
+            const url = await createIssue(token, title, body);
+            await stampSubmitAt(dataRoot, now);
+            return { ok: true, location: url };
+        }
+        catch (error) {
+            // Network or auth failure: fall through to the local spool so the
+            // report is never lost, and say so in the outcome.
+            const local = await spoolLocally(dataRoot, title, body);
+            await stampSubmitAt(dataRoot, now);
+            return {
+                ok: true,
+                location: local,
+                reason: `GitHub issue failed (${error instanceof Error ? error.message : String(error)}); saved locally instead`
+            };
+        }
+    }
+    const local = await spoolLocally(dataRoot, title, body);
+    await stampSubmitAt(dataRoot, now);
+    return { ok: true, location: local };
+}
+/** POST one issue; returns its html_url. */
+async function createIssue(token, title, body) {
+    const response = await fetch(`https://api.github.com/repos/${FEEDBACK_REPO_OWNER}/${FEEDBACK_REPO_NAME}/issues`, {
+        method: 'POST',
+        headers: {
+            authorization: `Bearer ${token}`,
+            accept: 'application/vnd.github+json',
+            'content-type': 'application/json',
+            'x-github-api-version': '2022-11-28',
+            'user-agent': 'dsh-agent-plugins-market-feedback'
+        },
+        body: JSON.stringify({ title, body, labels: [FEEDBACK_LABEL] }),
+        signal: AbortSignal.timeout(15_000)
+    });
+    if (!response.ok) {
+        const detail = await response.text().catch(() => '');
+        throw new Error(`GitHub API ${response.status}${detail === '' ? '' : `: ${detail.slice(0, 200)}`}`);
+    }
+    const payload = (await response.json());
+    if (payload.html_url === undefined)
+        throw new Error('GitHub API returned no issue URL');
+    return payload.html_url;
+}
+/** Render the model's structured report into a deterministic issue body. */
+export function renderFeedbackBody(report) {
+    const lines = ['## Experience feedback', '', `**Problem:** ${report.description.trim()}`, ''];
+    if (report.expected?.trim() !== undefined && report.expected.trim() !== '')
+        lines.push(`**Expected:** ${report.expected.trim()}`, '');
+    if (report.actual?.trim() !== undefined && report.actual.trim() !== '')
+        lines.push(`**Actual:** ${report.actual.trim()}`, '');
+    lines.push('---', `Filed automatically by the dsh-agent-plugins-market \`${FEEDBACK_TOOL_NAME}\` tool.`);
+    return lines.join('\n');
+}
+/** Append one report to the local spool; returns the spool file path. */
+async function spoolLocally(dataRoot, title, body) {
+    const dir = join(dataRoot, 'feedback');
+    await mkdir(dir, { recursive: true });
+    const file = join(dir, 'reports.jsonl');
+    const record = JSON.stringify({ at: new Date().toISOString(), title, body });
+    await appendFile(file, `${record}\n`, 'utf8');
+    return file;
+}
+/** The last accepted submission's timestamp; 0 when the stamp file is absent. */
+async function readLastSubmitAt(dataRoot) {
+    try {
+        const raw = await readFile(join(dataRoot, 'feedback', 'last-submit-at'), 'utf8');
+        const value = Number.parseInt(raw.trim(), 10);
+        return Number.isSafeInteger(value) ? value : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+async function stampSubmitAt(dataRoot, now) {
+    const dir = join(dataRoot, 'feedback');
+    await mkdir(dir, { recursive: true });
+    // Overwrite, not append: an appending stamp concatenates timestamps and
+    // parseInt on the merged digits disables the cooldown permanently.
+    await writeFile(join(dir, 'last-submit-at'), String(now), 'utf8');
+}
+export const FEEDBACK_TOOL_NAME = 'report_market_issue';
+const FEEDBACK_DESCRIPTION = 'File an experience-feedback issue for dsh-agent-plugins-market (the DeepSeek Harness agent plugin market). ' +
+    'Call this ONLY when the human describes a problem caused by the agent plugins market itself — a failed or ' +
+    'stuck install/uninstall, a market source that will not scan, wrong market UI behavior, or a runtime injection ' +
+    'defect the user attributes to a market suite. Do not call it for problems in other plugins, in the harness, ' +
+    "or in the user's own repositories. Compose a specific title; describe what happened, what was expected, and " +
+    'the exact error text when one appeared.';
+/** Register the feedback tool; returns the disposer. Undefined when the host has no tools service. */
+export function mountFeedbackTool(hostCtx, dataRoot, t) {
+    const host = hostCtx;
+    if (typeof host.tools?.register !== 'function')
+        return undefined;
+    return host.tools.register(defineTool({
+        name: FEEDBACK_TOOL_NAME,
+        description: FEEDBACK_DESCRIPTION,
+        parameters: {
+            title: { type: 'string', required: true, description: 'One-line problem summary for the issue title.' },
+            description: { type: 'string', required: true, description: 'What the problem is, with exact error text when one appeared.' },
+            expected: { type: 'string', description: 'What the user expected to happen.' },
+            actual: { type: 'string', description: 'What actually happened instead.' }
+        },
+        output: {
+            // The dsh-tools value-schema DSL rejects root-level `required`
+            // (verified against dsh-tools@0.1.2-rc.1); required-ness is declared
+            // per property instead.
+            schema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ok: { type: 'boolean', required: true },
+                    location: { type: 'string' },
+                    reason: { type: 'string' }
+                }
+            },
+            render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }]
+        },
+        async execute(args) {
+            const input = args;
+            const report = {
+                title: String(input['title'] ?? ''),
+                description: String(input['description'] ?? ''),
+                ...(typeof input['expected'] === 'string' ? { expected: input['expected'] } : {}),
+                ...(typeof input['actual'] === 'string' ? { actual: input['actual'] } : {})
+            };
+            return await submitFeedback(dataRoot, report);
+        },
+        presentCall: (args) => {
+            const input = args;
+            const view = {
+                card: 'generic',
+                title: t('feedbackToolCardTitle'),
+                kind: 'other',
+                ...(typeof input['title'] === 'string' ? { rawInput: input['title'] } : {})
+            };
+            return view;
+        }
+    }));
+}

package/lib/runtime/hooks-mounts.js

@@ -10,19 +10,29 @@
  * on every enable/disable/install/uninstall; a missing bridge package, a
  * broken hook file, or a mount failure is contained per suite.
  */
-import { stat } from 'node:fs/promises';
+import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { qualifiedSuiteId } from '../catalog/paths.js';
 export class HooksMountRegistry {
     ctx;
     live = new Map();
+    fingerprints = new Map();
+    temporary = new Map();
+    queue = Promise.resolve();
     constructor(ctx) {
         this.ctx = ctx;
     }
     /** Mount/unmount one bridge per suite to match the enabled suites exactly. */
     async reconcile(enabledSuites) {
+        const run = this.queue.then(() => this.reconcileNow(enabledSuites));
+        this.queue = run.then(() => { }, () => { });
+        return run;
+    }
+    async reconcileNow(enabledSuites) {
         const diagnostics = [];
-        const active = enabledSuites.filter(suite => suite.activeSurfaces?.hooks !== false);
+        const active = enabledSuites.filter(suite => suite.activeSurfaces?.hooks !== false && (suite.resources === undefined || suite.hooks !== undefined));
         // Keys are the qualified suite id: bare ids are unique per source only.
         const wanted = new Set(active.map(suite => qualifiedSuiteId(suite.sourceId, suite.id)));
         for (const [suiteId, handle] of [...this.live]) {
@@ -32,9 +42,25 @@ export class HooksMountRegistry {
         }
         for (const suite of active) {
             const key = qualifiedSuiteId(suite.sourceId, suite.id);
-            if (this.live.has(key))
+            const originalPath = suite.hooks === undefined ? await hookConfigPath(suite.root) : undefined;
+            const content = suite.hooks === undefined
+                ? originalPath === undefined
+                    ? undefined
+                    : await readFile(originalPath, 'utf8').catch(() => undefined)
+                : JSON.stringify({ hooks: suite.hooks.events });
+            const fingerprint = content === undefined
+                ? undefined
+                : createHash('sha256')
+                    .update(JSON.stringify([content, suite.root, suite.hooks?.projectRoot]))
+                    .digest('hex');
+            const previous = this.live.get(key);
+            if (previous !== undefined && fingerprint === this.fingerprints.get(key))
+                continue;
+            if (previous !== undefined)
+                await this.unmount(key, previous);
+            if (content === undefined || fingerprint === undefined)
                 continue;
-            const reason = await this.mount(key, suite);
+            const reason = await this.mount(key, suite, content, fingerprint, originalPath);
             if (reason !== undefined)
                 diagnostics.push({ suiteId: key, reason });
         }
@@ -42,14 +68,14 @@ export class HooksMountRegistry {
     }
     /** Dispose every live bridge; used at plugin teardown. */
     async disposeAll() {
-        for (const [suiteId, handle] of [...this.live]) {
-            await this.unmount(suiteId, handle);
-        }
+        const run = this.queue.then(async () => {
+            for (const [suiteId, handle] of [...this.live])
+                await this.unmount(suiteId, handle);
+        });
+        this.queue = run.catch(() => { });
+        await run;
     }
-    async mount(key, suite) {
-        const configPath = await hookConfigPath(suite.root);
-        if (configPath === undefined)
-            return undefined;
+    async mount(key, suite, content, fingerprint, originalPath) {
         let bridge;
         try {
             bridge = await import('@deepseek-ai/dsh-hooks-claude-code');
@@ -60,27 +86,54 @@ export class HooksMountRegistry {
         const mountCtx = this.ctx;
         if (typeof mountCtx.plugin !== 'function')
             return 'the host context does not support dynamic plugin mounting';
+        let temporary;
+        let handle;
         try {
-            const handle = mountCtx.plugin(bridge, {
+            let configPath = originalPath;
+            if (configPath === undefined) {
+                temporary = await mkdtemp(join(tmpdir(), 'dsh-project-hooks-'));
+                configPath = join(temporary, 'hooks.json');
+                await writeFile(configPath, content, { mode: 0o600 });
+            }
+            handle = mountCtx.plugin(bridge, {
                 configPath,
-                pluginRoot: suite.root
+                pluginRoot: suite.root,
+                ...(suite.hooks === undefined ? {} : { projectDir: suite.hooks.projectRoot })
             });
             await handle.await();
             this.live.set(key, handle);
+            this.fingerprints.set(key, fingerprint);
+            if (temporary !== undefined)
+                this.temporary.set(key, temporary);
             return undefined;
         }
         catch (error) {
+            try {
+                await handle?.dispose();
+            }
+            catch {
+                /* Preserve the startup failure. */
+            }
+            if (temporary !== undefined)
+                await rm(temporary, { recursive: true, force: true });
             return `mount failed: ${error instanceof Error ? error.message : String(error)}`;
         }
     }
     async unmount(suiteId, handle) {
         this.live.delete(suiteId);
+        this.fingerprints.delete(suiteId);
         try {
             await handle.dispose();
         }
         catch (error) {
             this.ctx.logger?.warn(`[dsh-agent-plugins-market] hooks unmount ${suiteId} failed: ${error instanceof Error ? error.message : String(error)}`);
         }
+        finally {
+            const temporary = this.temporary.get(suiteId);
+            this.temporary.delete(suiteId);
+            if (temporary !== undefined)
+                await rm(temporary, { recursive: true, force: true });
+        }
     }
 }
 /** The first existing CC hook config of a suite root. */

package/lib/runtime/host-locale.js

@@ -1,6 +1,6 @@
 /**
  * Host-side runtime locale: bilingual copy for strings injected into agent
- * context (agent-definition wrappers and command acknowledgements), resolved
+ * context (subagent catalogs and command acknowledgements), resolved
  * from the harness's `locale.preference` setting.
  *
  * The web client resolves locale through its own injected service; the host
@@ -11,18 +11,34 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { resolveDshHome } from '../catalog/paths.js';
 const zh = {
-    agentDefinitionTitle: '## 子代理定义（来自 Agent Plugins {suite}，Claude Code agents 格式）',
-    agentDefinitionIntro: '当任务匹配下方描述时，通过 subagent 工具创建子代理并将「定义正文」原样作为指令执行。',
+    subagentCatalogIntro: '以下子代理角色可用于当前会话。目录仅包含角色摘要，不是供当前代理执行的角色指令。',
+    subagentCatalogUpdated: '可用子代理角色已变更。以下完整目录替代本会话此前的所有子代理角色目录。',
+    subagentCatalogEmpty: '当前没有可通过 subagents_run 调用的角色，不要使用旧目录中的角色 ID。',
+    subagentCatalogCall: '任务适合某个角色时，使用 subagents_run(role=目录中的准确 ID, prompt=完整任务与必要上下文)。工具会应用角色的供应商、模型、思考强度、指令和工具限制，并等待结果。子代理不继承父会话对话。不要通过 skill 或 Slash Command 加载这些角色，也不要用其它委派工具绕过角色配置。',
+    subagentCatalogInherit: '继承父代理',
+    subagentCatalogDefaultEffort: '同路由继承，否则使用模型默认值',
     commandForwardTitle: '[Agent Plugins 命令 /{command}（来自 {suite}）]',
     commandAcknowledged: '/{command} 已转交模型执行（{suite}）',
-    agentCommandHint: '子代理'
+    userCommandSourceLabel: '用户命令',
+    userCommandForwardTitle: '[用户快捷命令 /{command}]',
+    userCommandAcknowledged: '/{command} 已转交模型执行',
+    userSkillDescription: '[用户技能] {description}',
+    feedbackToolCardTitle: '提交市场体验反馈'
 };
 const en = {
-    agentDefinitionTitle: '## Subagent definition (from Agent Plugins {suite}, Claude Code agents format)',
-    agentDefinitionIntro: 'When the task matches the description below, create a subagent through the subagent tool and pass the definition body verbatim as its instructions.',
+    subagentCatalogIntro: 'The following subagent roles are available in this session. These are role summaries, not instructions for the current agent to execute.',
+    subagentCatalogUpdated: 'The available subagent roles changed. This complete catalog replaces every earlier subagent role catalog in this session.',
+    subagentCatalogEmpty: 'No roles are currently available through subagents_run. Do not use role IDs from earlier catalogs.',
+    subagentCatalogCall: 'When a task fits a role, call subagents_run with its exact catalog ID as role and a complete task and necessary context as prompt. The tool applies the saved provider, model, reasoning effort, persona and tool restrictions, and waits for the result. The child does not inherit the parent conversation. Do not load these roles through skill or slash commands, or bypass their configuration with another delegation tool.',
+    subagentCatalogInherit: 'inherit parent',
+    subagentCatalogDefaultEffort: 'inherit on the same route, otherwise model default',
     commandForwardTitle: '[Agent Plugins command /{command} (from {suite})]',
     commandAcknowledged: '/{command} forwarded to the model for execution ({suite})',
-    agentCommandHint: 'subagent'
+    userCommandSourceLabel: 'user command',
+    userCommandForwardTitle: '[User quick command /{command}]',
+    userCommandAcknowledged: '/{command} forwarded to the model for execution',
+    userSkillDescription: '[user skill] {description}',
+    feedbackToolCardTitle: 'File market feedback'
 };
 const DICTS = { zh, en };
 /** Resolve the active host language from settings; unknown values default to zh. */

package/lib/runtime/legacy-root-migration.js

@@ -0,0 +1,12 @@
+/** Compatibility migration for the pre-0.5.4 sibling data directory. */
+import { readdir, rmdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { mergeStorageTree } from './storage-migration.js';
+/** Move owned data subtrees without overwriting or deleting conflicting files. */
+export async function migrateLegacyDataRoot(legacyRoot, dataRoot) {
+    const result = { conflicts: [] };
+    for (const subtree of ['data', 'overrides'])
+        await mergeStorageTree(join(legacyRoot, subtree), join(dataRoot, subtree), result);
+    if ((await readdir(legacyRoot).catch(() => ['keep'])).length === 0)
+        await rmdir(legacyRoot);
+}

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

@@ -21,11 +21,13 @@ export async function loadLspServers(dataRoot) {
     try {
         raw = JSON.parse(await readFile(lspServersPath(dataRoot), 'utf8'));
     }
-    catch {
-        return { servers: {}, errors: [] };
+    catch (error) {
+        return { servers: {}, errors: error.code === 'ENOENT' ? [] : [`lsp-servers.json: ${error instanceof Error ? error.message : String(error)}`] };
     }
     const errors = [];
     const table = raw?.['lspServers'];
+    if (table === undefined || table === null || Array.isArray(table) || typeof table !== 'object')
+        return { servers: {}, errors: ['lsp-servers.json: lspServers must be an object'] };
     const servers = parseLspServers(table, errors);
     return { servers, errors: errors.map(error => `lsp-servers.json: ${error}`) };
 }
@@ -39,6 +41,7 @@ export async function saveLspServers(dataRoot, raw) {
     }
     const path = lspServersPath(dataRoot);
     await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, `${JSON.stringify({ lspServers: servers }, null, 2)}\n`, 'utf8');
+    const persisted = Object.fromEntries(Object.entries(servers).map(([name, { key: _key, ...config }]) => [name, config]));
+    await writeFile(path, `${JSON.stringify({ lspServers: persisted }, null, 2)}\n`, { mode: 0o600 });
     return { servers };
 }

package/lib/runtime/lsp-mounts.js

@@ -37,6 +37,8 @@ export class LspMountRegistry {
     lastDiagnostics = new Map();
     /** Direct (user-configured) server provider; defaults to none. */
     directProvider = async () => ({});
+    disabledProvider = async () => new Set();
+    disabledSnapshot = new Set();
     constructor(ctx, loadHost) {
         this.ctx = ctx;
         this.loadHost =
@@ -62,6 +64,8 @@ export class LspMountRegistry {
         const active = enabledSuites.filter(suite => suite.activeSurfaces?.lsp !== false);
         const wanted = new Map();
         const diagnostics = [];
+        const disabled = await this.disabledProvider();
+        this.disabledSnapshot = new Set(disabled);
         for (const suite of active) {
             const servers = Object.values(suite.lsp?.servers ?? {});
             if (servers.length === 0)
@@ -72,8 +76,10 @@ export class LspMountRegistry {
             const key = qualifiedSuiteId(suite.sourceId, suite.id);
             const config = {};
             for (const spec of servers)
-                config[`${key}/${spec.key}`] = toLspServerConfig(spec);
-            wanted.set(key, { suite, config });
+                if (!disabled.has(`${key}/${spec.key}`))
+                    config[`${key}/${spec.key}`] = toLspServerConfig(spec);
+            if (Object.keys(config).length > 0)
+                wanted.set(key, { suite, config });
         }
         // Direct user-configured servers ride the same mount path under the
         // sentinel suite id, so their lifecycle (retries, diagnostics, disposal)
@@ -83,28 +89,30 @@ export class LspMountRegistry {
         if (directKeys.length > 0) {
             const config = {};
             for (const [key, spec] of Object.entries(direct))
-                config[`${DIRECT_LSP_SUITE_ID}/${key}`] = toLspServerConfig(spec);
-            wanted.set(DIRECT_LSP_SUITE_ID, {
-                suite: {
-                    sourceId: '',
-                    id: DIRECT_LSP_SUITE_ID,
-                    root: '',
-                    manifest: { layout: 'claude-code', path: '', id: DIRECT_LSP_SUITE_ID, name: DIRECT_LSP_SUITE_ID },
-                    skills: [],
-                    surfaces: { skills: 0, mcp: 0, hooks: 0, commands: 0, agents: 0, lsp: directKeys.length },
-                    dimension: 'user',
-                    enabled: true,
-                    errors: []
-                },
-                config
-            });
+                if (!disabled.has(`${DIRECT_LSP_SUITE_ID}/${key}`))
+                    config[`${DIRECT_LSP_SUITE_ID}/${key}`] = toLspServerConfig(spec);
+            if (Object.keys(config).length > 0)
+                wanted.set(DIRECT_LSP_SUITE_ID, {
+                    suite: {
+                        sourceId: '',
+                        id: DIRECT_LSP_SUITE_ID,
+                        root: '',
+                        manifest: { layout: 'claude-code', path: '', id: DIRECT_LSP_SUITE_ID, name: DIRECT_LSP_SUITE_ID },
+                        skills: [],
+                        surfaces: { skills: 0, mcp: 0, hooks: 0, commands: 0, agents: 0, lsp: directKeys.length },
+                        dimension: 'user',
+                        enabled: true,
+                        errors: []
+                    },
+                    config
+                });
         }
         for (const [key, live] of [...this.live]) {
-            if (!wanted.has(key)) {
+            if (!wanted.has(key) || live.fingerprint !== JSON.stringify(wanted.get(key).config)) {
                 const reason = await this.unmount(key, live);
-                this.lastDiagnostics.delete(live.suiteId);
+                this.lastDiagnostics.delete(key);
                 if (reason !== undefined)
-                    diagnostics.push({ suiteId: live.suiteId, serverKey: live.serverKeys.join(','), reason, code: 'unmount-failed' });
+                    diagnostics.push({ suiteId: key, serverKey: live.serverKeys.join(','), reason, code: 'unmount-failed' });
             }
         }
         for (const [key, entry] of wanted) {
@@ -128,6 +136,12 @@ export class LspMountRegistry {
     setDirectProvider(provider) {
         this.directProvider = provider;
     }
+    setDisabledProvider(provider) {
+        this.disabledProvider = provider;
+    }
+    disabledServers() {
+        return new Set(this.disabledSnapshot);
+    }
     /** The latest mount diagnostic per suite, for the LSP status surface. */
     diagnosticsSnapshot() {
         return new Map(this.lastDiagnostics);
@@ -141,12 +155,12 @@ export class LspMountRegistry {
         const hostKeys = Object.keys(servers).join(',');
         const module = await this.loadHost();
         if (module === undefined) {
-            return { suiteId: suite.id, serverKey: hostKeys, reason: HOST_MISSING_REASON, code: 'host-missing' };
+            return { suiteId: key, serverKey: hostKeys, reason: HOST_MISSING_REASON, code: 'host-missing' };
         }
         const plugin = module.default ?? module;
         const mountCtx = this.ctx;
         if (typeof mountCtx.plugin !== 'function') {
-            return { suiteId: suite.id, serverKey: hostKeys, reason: 'the host context does not support dynamic plugin mounting', code: 'host-missing' };
+            return { suiteId: key, serverKey: hostKeys, reason: 'the host context does not support dynamic plugin mounting', code: 'host-missing' };
         }
         let handle;
         try {
@@ -167,13 +181,13 @@ export class LspMountRegistry {
             const message = error instanceof Error ? error.message : String(error);
             const conflict = /already handled by another LSP provider|already registered/.test(message);
             return {
-                suiteId: suite.id,
+                suiteId: key,
                 serverKey: hostKeys,
                 reason: `mount failed: ${message}`,
                 code: conflict ? 'seam-conflict' : 'mount-failed'
             };
         }
-        this.live.set(key, { suiteId: suite.id, serverKeys: Object.keys(servers), disposer: () => handle.dispose() });
+        this.live.set(key, { fingerprint: JSON.stringify(servers), suiteId: key, serverKeys: Object.keys(servers), disposer: () => handle.dispose() });
         return undefined;
     }
     async unmount(key, live) {

package/lib/runtime/lsp-server-state.js

@@ -0,0 +1,19 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+export function lspServerStatePath(dataRoot) {
+    return join(dataRoot, 'lsp-server-state.json');
+}
+export async function loadDisabledLspServers(dataRoot) {
+    try {
+        const value = JSON.parse(await readFile(lspServerStatePath(dataRoot), 'utf8'));
+        return new Set(Array.isArray(value.disabled) ? value.disabled.filter((id) => typeof id === 'string') : []);
+    }
+    catch {
+        return new Set();
+    }
+}
+export async function saveDisabledLspServers(dataRoot, disabled) {
+    const path = lspServerStatePath(dataRoot);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify({ disabled: [...new Set(disabled)].sort() }, null, 2)}\n`, 'utf8');
+}

package/lib/runtime/lsp-status.js

@@ -30,6 +30,7 @@ function deriveState(disabled, diagnostic, anyLive) {
 export function buildLspStatus(suites, registry, direct = { servers: {}, errors: [] }) {
     const diagnostics = registry.diagnosticsSnapshot();
     const anyLive = registry.hasLiveMounts();
+    const disabledServers = registry.disabledServers?.() ?? new Set();
     const entries = [];
     const mountedSuiteIds = new Set();
     for (const suite of suites) {
@@ -55,7 +56,7 @@ export function buildLspStatus(suites, registry, direct = { servers: {}, errors:
                 command: spec.command,
                 args: spec.args,
                 extensions: spec.extensionToLanguage,
-                state,
+                state: disabled || disabledServers.has(`${suiteKey}/${spec.key}`) ? 'disabled' : state,
                 ...(reason === undefined ? {} : { reason }),
                 ...(retryable === undefined ? {} : { retryable })
             });
@@ -78,7 +79,7 @@ export function buildLspStatus(suites, registry, direct = { servers: {}, errors:
             command: spec.command,
             args: spec.args,
             extensions: spec.extensionToLanguage,
-            state: directState,
+            state: disabledServers.has(`${DIRECT_LSP_SUITE_ID}/${spec.key}`) ? 'disabled' : directState,
             ...(directReason === undefined ? {} : { reason: directReason }),
             ...(directRetryable === undefined ? {} : { retryable: directRetryable })
         });

package/lib/runtime/mcp-backend.js

@@ -20,12 +20,16 @@ import z from '@deepseek-ai/schemastery';
 export const MCP_BACKENDS = ['builtin', 'host'];
 /** Settings namespace this plugin registers; the key the plugin-config tab pairs our card by. */
 export const MCP_SETTINGS_NAMESPACE = 'dsh-agent-plugins-market';
-/** Schema of the market settings namespace: the MCP enhancement switch and the download region. */
+/** Schema of the market settings namespace: the MCP enhancement switch, the download region, and the feedback tool switch. */
 export const MarketSettingsSchema = z.object({
     /** ON (default) = the built-in bridge with OAuth and SSE; OFF = host client compat mode. */
     mcpEnhanced: z.boolean().default(true),
+    /** Read native Agent layouts under the project root; default preserves existing discovery. */
+    scanProjectLayouts: z.boolean().default(true),
     /** Download region for GitHub acquisition; `auto` follows the interface language. */
-    downloadRegion: z.union([z.const('auto'), z.const('global'), z.const('china')]).default('auto')
+    downloadRegion: z.union([z.const('auto'), z.const('global'), z.const('china')]).default('auto'),
+    /** ON (default) = the `report_market_issue` model tool is registered; OFF = unregistered. */
+    feedbackEnabled: z.boolean().default(true)
 });
 /** Path of the legacy persisted settings file under the plugin data root. */
 export function marketSettingsPath(dataRoot) {

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

@@ -23,6 +23,12 @@ export const SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]{1,32}$/;
  */
 export function validateConfig(config) {
     const fields = config;
+    for (const field of ['enabledTools', 'disabledTools']) {
+        if (fields[field] !== undefined && (!Array.isArray(fields[field]) || !fields[field].every(name => typeof name === 'string')))
+            throw new Error(`bridge config ${field} must be an array of strings`);
+    }
+    if (fields.startupTimeoutMs !== undefined && (!Number.isFinite(fields.startupTimeoutMs) || fields.startupTimeoutMs <= 0 || fields.startupTimeoutMs > 2_147_483_647))
+        throw new Error('bridge config startupTimeoutMs must be a positive finite timeout within the timer range');
     if (!SERVER_NAME_PATTERN.test(config.serverName)) {
         throw new Error(`bridge config serverName "${config.serverName}" must match ${String(SERVER_NAME_PATTERN)}`);
     }

package/lib/runtime/mcp-client/connection.js

@@ -87,7 +87,10 @@ export function startConnection(host, config, policy, credentials) {
     const opts = {
         registrationFailure: 'contain',
         serverName: config.serverName,
-        toolCallTimeoutMs: config.toolCallTimeoutMs
+        toolCallTimeoutMs: config.toolCallTimeoutMs,
+        ...(config.enabledTools === undefined ? {} : { enabledTools: config.enabledTools }),
+        ...(config.disabledTools === undefined ? {} : { disabledTools: config.disabledTools }),
+        ...(config.startupTimeoutMs === undefined ? {} : { startupTimeoutMs: config.startupTimeoutMs })
     };
     // The initial sync uses 'throw' when failOnStartupError is configured, so
     // a registration conflict propagates to the startup-await path. Re-syncs
@@ -229,7 +232,10 @@ export function startConnection(host, config, policy, credentials) {
             host.logger.info(message);
         });
         try {
-            await generation.connect(transport);
+            if (config.startupTimeoutMs === undefined)
+                await generation.connect(transport);
+            else
+                await generation.connect(transport, { timeout: config.startupTimeoutMs });
             if (hasClosed()) {
                 attemptSettled = true;
                 generationDown(generation);