dsh-agent-plugins-market 0.5.0 → 0.5.2

package/lib/runtime/mcp-mounts.js

@@ -4,21 +4,36 @@ export class McpMountRegistry {
     pluginDataRoot;
     live = new Map();
     names = new Map();
+    overridesProvider = async () => new Map();
+    /** Serialize mount and unmount passes so a disable cannot race an in-flight spawn. */
+    reconcileQueue = Promise.resolve();
     constructor(ctx, pluginDataRoot) {
         this.ctx = ctx;
         this.pluginDataRoot = pluginDataRoot;
     }
-    /** Mount/unmount MCP servers to match the enabled suites exactly. */
+    /** Install the per-suite overrides provider (suiteId -> overrides). */
+    setOverridesProvider(provider) {
+        this.overridesProvider = provider;
+    }
+    /** Queue one reconciliation behind any in-flight mount/unmount pass. */
     async reconcile(enabledSuites) {
+        const run = this.reconcileQueue.then(() => this.reconcileNow(enabledSuites));
+        this.reconcileQueue = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    /** Mount/unmount MCP servers to match the enabled suites exactly. */
+    async reconcileNow(enabledSuites) {
+        const active = enabledSuites.filter(suite => suite.activeSurfaces?.mcp !== false);
+        const overrides = await this.overridesProvider();
         const wanted = new Map();
         const diagnostics = [];
-        for (const suite of enabledSuites) {
-            const { mounts, failures } = toMcpMounts(suite, this.pluginDataRoot);
+        for (const suite of active) {
+            const { mounts, failures } = toMcpMounts(suite, this.pluginDataRoot, overrides.get(suite.id));
             for (const failure of failures) {
                 diagnostics.push({ suiteId: suite.id, serverKey: failure.serverKey, reason: failure.reason });
             }
             for (const mount of mounts) {
-                wanted.set(mountKey(mount.suiteId, mount.serverKey), { suite, serverKey: mount.serverKey });
+                wanted.set(mountKey(mount.suiteId, mount.serverKey), { suite, serverKey: mount.serverKey, request: mount });
             }
         }
         for (const [key, live] of [...this.live]) {
@@ -30,23 +45,24 @@ export class McpMountRegistry {
         for (const [key, entry] of wanted) {
             if (this.live.has(key))
                 continue;
-            const reason = await this.mount(entry.suite, entry.serverKey);
+            const reason = await this.mountWith(entry.request);
             if (reason !== undefined)
                 diagnostics.push({ suiteId: entry.suite.id, serverKey: entry.serverKey, reason });
         }
         return diagnostics.filter(diagnostic => diagnostic.reason !== 'unmounted');
     }
-    /** Dispose every live mount; used at plugin teardown. */
+    /** Dispose every live mount after queued reconciliation passes settle. */
     async disposeAll() {
-        for (const [key, live] of [...this.live]) {
-            await this.unmount(key, live);
-        }
+        const run = this.reconcileQueue.then(async () => {
+            for (const [key, live] of [...this.live]) {
+                await this.unmount(key, live);
+            }
+        });
+        this.reconcileQueue = run.then(() => undefined, () => undefined);
+        await run;
     }
-    async mount(suite, serverKey) {
-        const { mounts } = toMcpMounts(suite, this.pluginDataRoot);
-        const request = mounts.find(mount => mount.serverKey === serverKey);
-        if (request === undefined)
-            return 'server no longer present in mcp.json';
+    /** Mount one precomputed request (source config merged with overrides). */
+    async mountWith(request) {
         const owner = this.names.get(request.config.serverName);
         if (owner !== undefined)
             return `derived serverName "${request.config.serverName}" already mounted by ${owner}`;
@@ -63,9 +79,9 @@ export class McpMountRegistry {
         try {
             const handle = mountCtx.plugin(mcpClient, request.config);
             await handle.await();
-            const key = mountKey(suite.id, serverKey);
-            this.live.set(key, { suiteId: suite.id, serverKey, serverName: request.config.serverName, disposer: () => handle.dispose() });
-            this.names.set(request.config.serverName, `${suite.id}/${serverKey}`);
+            const key = mountKey(request.suiteId, request.serverKey);
+            this.live.set(key, { suiteId: request.suiteId, serverKey: request.serverKey, serverName: request.config.serverName, disposer: () => handle.dispose() });
+            this.names.set(request.config.serverName, `${request.suiteId}/${request.serverKey}`);
             return undefined;
         }
         catch (error) {

package/lib/runtime/mcp-overrides.js

@@ -0,0 +1,113 @@
+/**
+ * MCP server overrides: user-owned edits layered over a suite's read-only
+ * `mcp.json`.
+ *
+ * The suite's mcp.json is source-controlled content — editing it in place
+ * would be clobbered by the next refresh and would blur authorship. Overrides
+ * live in `${dataRoot}/overrides/<suiteId>.json` and win at mount time.
+ * Editable scope is deliberate: connection inputs (`url`, `headers`, `env`,
+ * `args`) and enable/disable are local-adaptation concerns; transport type,
+ * command, and the derived serverName stay source-owned so mounts stay
+ * coherent across refreshes. Secret values should reference the process
+ * environment through `${NAME}` placeholders so keys never persist in plain
+ * text.
+ */
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+/** The overrides directory under the plugin data root. */
+export function overridesDir(dataRoot) {
+    return join(dataRoot, 'overrides');
+}
+/** One suite's override file path. */
+export function suiteOverridePath(dataRoot, suiteId) {
+    return join(overridesDir(dataRoot), `${sanitizeFileName(suiteId)}.json`);
+}
+/** Load one suite's persisted overrides; unreadable files yield none. */
+export async function loadSuiteOverrides(dataRoot, suiteId) {
+    try {
+        const raw = JSON.parse(await readFile(suiteOverridePath(dataRoot, suiteId), 'utf8'));
+        if (typeof raw !== 'object' || raw === null)
+            return {};
+        const parsed = sanitizeOverrides(raw);
+        return parsed;
+    }
+    catch {
+        return {};
+    }
+}
+/** Persist one suite's overrides atomically-ish (single writer, small file). */
+export async function saveSuiteOverrides(dataRoot, suiteId, overrides) {
+    const path = suiteOverridePath(dataRoot, suiteId);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(overrides, null, 2)}\n`, 'utf8');
+}
+/** Keep only recognized fields with correct shapes; drop everything else. */
+export function sanitizeOverrides(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return {};
+    const result = {};
+    for (const [serverKey, value] of Object.entries(raw)) {
+        if (typeof value !== 'object' || value === null)
+            continue;
+        const record = value;
+        const override = {};
+        if (typeof record['enabled'] === 'boolean')
+            override.enabled = record['enabled'];
+        if (typeof record['url'] === 'string' && record['url'] !== '')
+            override.url = record['url'];
+        const headers = stringMap(record['headers']);
+        if (headers !== undefined)
+            override.headers = headers;
+        const env = stringMap(record['env']);
+        if (env !== undefined)
+            override.env = env;
+        if (Array.isArray(record['args']) && record['args'].every(entry => typeof entry === 'string')) {
+            override.args = record['args'];
+        }
+        if (Object.keys(override).length > 0)
+            result[serverKey] = override;
+    }
+    return result;
+}
+/** Validate a client-supplied patch for one server into an override value. */
+export function sanitizeOverridePatch(patch) {
+    return sanitizeOverrides({ server: patch })['server'];
+}
+function stringMap(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry !== 'string')
+            continue;
+        result[key] = entry;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+/**
+ * Apply one server's overrides onto its source shape. Field replacement is
+ * whole-map (headers/env/args), never per-key merge, so removing a key in the
+ * UI actually removes it at mount time. Values pass through the ordinary
+ * mount-time placeholder pipeline afterwards, so override authors may
+ * reference secrets as `${NAME}` or `${NAME:-fallback}` (resolved from the
+ * process environment in memory) instead of persisting them here.
+ */
+export function applyOverride(server, override) {
+    if (override === undefined)
+        return server;
+    if (server.type === 'stdio') {
+        return {
+            ...server,
+            ...(override.args !== undefined ? { args: override.args } : {}),
+            ...(override.env !== undefined ? { env: override.env } : {})
+        };
+    }
+    return {
+        ...server,
+        ...(override.url !== undefined ? { url: override.url } : {}),
+        ...(override.headers !== undefined ? { headers: override.headers } : {})
+    };
+}
+function sanitizeFileName(raw) {
+    return raw.replace(/[^A-Za-z0-9_-]+/g, '_');
+}

package/lib/runtime/mcp-status.js

@@ -2,7 +2,7 @@ import { deriveServerName } from './mcp-config.js';
 import { inspectToolRegistry } from './tool-registry-observer.js';
 export { inspectToolRegistry };
 /** Build status rows from discovered plugin MCP definitions and observed tool names. */
-export function buildMcpStatus(suites, diagnostics, observed) {
+export function buildMcpStatus(suites, diagnostics, observed, overrides = new Map()) {
     const entries = [];
     const claimedServers = new Set();
     const knownServerNames = new Set();
@@ -19,12 +19,16 @@ export function buildMcpStatus(suites, diagnostics, observed) {
         // definitions only appear after their suite is both installed and enabled.
         if (suite.mcp === undefined || suite.installedAt === undefined || !suite.enabled)
             continue;
+        const suiteOverrides = overrides.get(suite.id);
         for (const [serverKey, server] of Object.entries(suite.mcp.servers)) {
+            const override = suiteOverrides?.[serverKey];
             const serverName = deriveServerName(suite.id, serverKey);
             const tools = observedByServer.get(serverName) ?? [];
             claimedServers.add(serverName);
             const diagnostic = diagnosticsByKey.get(`${suite.id}\u0000${serverKey}`);
-            const state = diagnostic !== undefined ? 'failed' : tools.length > 0 ? 'connected' : 'degraded';
+            const disabled = override?.enabled === false;
+            const state = diagnostic !== undefined ? 'failed' : disabled ? 'disabled' : tools.length > 0 ? 'connected' : 'degraded';
+            const reason = diagnostic?.reason ?? (override === undefined ? undefined : disabled ? 'disabled by override' : 'modified by override');
             entries.push({
                 id: `plugin:${suite.sourceId}/${suite.id}/${serverKey}`,
                 name: serverName,
@@ -36,8 +40,8 @@ export function buildMcpStatus(suites, diagnostics, observed) {
                 transport: server.type,
                 endpoint: endpointOf(server),
                 config: redactConfig(server),
-                tools: tools.map(tool => ({ name: tool.name, ...(tool.description === undefined ? {} : { description: tool.description }) })),
-                ...(diagnostic === undefined ? {} : { reason: diagnostic.reason })
+                tools: disabled ? [] : tools.map(tool => ({ name: tool.name, ...(tool.description === undefined ? {} : { description: tool.description }) })),
+                ...(reason === undefined ? {} : { reason })
             });
         }
     }

package/lib/runtime/reconciler.js

@@ -1,15 +1,20 @@
 import { CommandMountRegistry } from './commands-mounts.js';
 import { HooksMountRegistry } from './hooks-mounts.js';
 import { McpMountRegistry } from './mcp-mounts.js';
+import { bindHostLocale } from './host-locale.js';
 export class RuntimeReconciler {
     mcp;
     commands;
     hooks;
-    constructor(ctx, dataRoot) {
+    constructor(ctx, dataRoot, t = bindHostLocale(undefined)) {
         this.mcp = new McpMountRegistry(ctx, dataRoot);
-        this.commands = new CommandMountRegistry(ctx);
+        this.commands = new CommandMountRegistry(ctx, t);
         this.hooks = new HooksMountRegistry(ctx);
     }
+    /** Install the per-suite MCP overrides provider used at mount time. */
+    setMcpOverridesProvider(provider) {
+        this.mcp.setOverridesProvider(provider);
+    }
     /** Reconcile all runtime surfaces against one enabled-suite snapshot. */
     async reconcile(enabledSuites) {
         const suites = [...enabledSuites];

package/lib/runtime/skills-provider.js

@@ -15,23 +15,39 @@
 import { readFile, readdir, stat } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parseSkillFrontmatter, stripFrontmatter } from '../catalog/skills-parse.js';
+import { bindHostLocale } from './host-locale.js';
 export const SUITE_PROJECT_SOURCE = 'agent-plugin-project';
 export const SUITE_USER_SOURCE = 'agent-plugin-user';
 const PROJECT_RANK = 250;
 const USER_RANK = 450;
 export class SuiteSkillProvider {
     manager;
+    t;
     name = 'agent-plugin';
-    constructor(manager) {
+    constructor(manager, t = bindHostLocale(undefined)) {
         this.manager = manager;
+        this.t = t;
     }
     async list(options) {
         const located = await this.locate(options.cwd);
         located.sort((a, b) => a.rank - b.rank || a.suite.id.localeCompare(b.suite.id) || a.skill.name.localeCompare(b.skill.name));
-        return located.map(entry => this.candidateFor(entry));
+        // Dedupe by skill name across dimensions: the sort above puts project
+        // suites (250) ahead of user suites (450), so a project's own skill
+        // always wins over an installed suite shipping a skill of the same name.
+        const seen = new Set();
+        const unique = [];
+        for (const entry of located) {
+            if (seen.has(entry.skill.name))
+                continue;
+            seen.add(entry.skill.name);
+            unique.push(entry);
+        }
+        return unique.map(entry => this.candidateFor(entry));
     }
     /** Parse `agents/*.md` of one suite into agent-definition candidates. */
     async agentsOf(suite) {
+        if (suite.activeSurfaces?.agents === false)
+            return [];
         const dir = join(suite.root, 'agents');
         let entries;
         try {
@@ -91,15 +107,7 @@ export class SuiteSkillProvider {
         }
         if (locator.kind === 'agent') {
             const suiteName = locator.suiteRoot.split(/[\\/]/).at(-1) ?? 'suite';
-            const content = [
-                `## 子代理定义（来自 Agent Plugins ${suiteName}，Claude Code agents 格式）`,
-                '',
-                '当任务匹配下方描述时，通过 subagent 工具创建子代理并将「定义正文」原样作为指令执行。',
-                '',
-                '```markdown',
-                text,
-                '```'
-            ].join('\n');
+            const content = [this.t('agentDefinitionTitle', { suite: suiteName }), '', this.t('agentDefinitionIntro'), '', '```markdown', text, '```'].join('\n');
             return {
                 name: candidate.name,
                 description: candidate.description,
@@ -150,7 +158,7 @@ export class SuiteSkillProvider {
         const located = [];
         const userSuites = await this.manager.enabledUserSuites();
         for (const suite of userSuites) {
-            for (const skill of suite.skills) {
+            for (const skill of suite.activeSurfaces?.skills === false ? [] : suite.skills) {
                 located.push({ rank: USER_RANK, source: SUITE_USER_SOURCE, suite, skill });
             }
             located.push(...(await this.agentsOf(suite)));
@@ -164,9 +172,10 @@ export class SuiteSkillProvider {
         const snapshot = await this.manager.readProjectCatalog(cwd);
         const located = [];
         for (const suite of snapshot.enabledSuites) {
-            for (const skill of suite.skills) {
+            for (const skill of suite.activeSurfaces?.skills === false ? [] : suite.skills) {
                 located.push({ rank: PROJECT_RANK, source: SUITE_PROJECT_SOURCE, suite, skill });
             }
+            located.push(...(await this.agentsOf(suite)));
         }
         return located;
     }

package/lib/types/application/catalog.d.ts

@@ -1,12 +1,21 @@
 import { type McpToolSnapshot } from '../runtime/mcp-status.js';
+import { type McpServerOverride, type McpSuiteOverrides } from '../runtime/mcp-overrides.js';
 import type { McpStatusPayload } from '../contracts/mcp-status.js';
 import type { OverviewPayload, SkillContent, SuiteDetail } from '../contracts/market.js';
-import type { SourceRef, Suite, SuiteDimension } from '../model/types.js';
+import { type SourceRef, type Suite, type SuiteDimension, type SuiteSurfaceKey } from '../model/types.js';
 /** Dependencies and host callback used by the catalog application module. */
 export interface CatalogOptions {
     userRoot: string;
     dataRoot: string;
     onChanged: () => void;
+    /**
+     * Freshness window for cached project-dimension snapshots. The project
+     * catalog sits on the skill-list hot path (every provider `list()` call),
+     * and its inputs — the project's own files — change only through editor
+     * saves; a short window keeps listing cheap without going stale. Defaults
+     * to 5 seconds; 0 disables caching.
+     */
+    projectSnapshotTtlMs?: number;
 }
 /** A coherent discovered-and-installed view for one catalog dimension. */
 export interface CatalogSnapshot {
@@ -25,6 +34,10 @@ export declare class Catalog {
     private revision;
     private userSnapshot;
     private userSnapshotPromise;
+    /** Project-dimension snapshots keyed by project root, with TTL freshness. */
+    private readonly projectSnapshots;
+    private readonly projectSnapshotPromises;
+    private readonly projectSnapshotTtlMs;
     /** Latest MCP mount diagnostics (suiteId -> reasons), fed by host reconcile. */
     mcpDiagnostics: Array<{
         suiteId: string;
@@ -39,6 +52,16 @@ export declare class Catalog {
     subscribe(listener: () => void): () => void;
     /** Build the flat MCP service inventory for the status surface. */
     mcpStatus(): Promise<McpStatusPayload>;
+    /** One suite's persisted MCP overrides. */
+    mcpOverrides(suiteId: string): Promise<McpSuiteOverrides>;
+    /**
+     * Set or clear one server's MCP override and remount it. `override === null`
+     * clears the override (back to the source config). The serverKey must exist
+     * in the suite's parsed mcp.json.
+     */
+    setMcpOverride(sourceId: string, suiteId: string, serverKey: string, override: McpServerOverride | null): Promise<void>;
+    /** All persisted MCP overrides keyed by suite id (mount-time provider). */
+    allMcpOverrides(): Promise<Map<string, McpSuiteOverrides>>;
     /** Load persisted user state once at plugin activation. */
     load(): Promise<void>;
     get sources(): SourceRef[];
@@ -48,6 +71,7 @@ export declare class Catalog {
     readUserCatalog(): Promise<CatalogSnapshot>;
     /** Read one coherent project-dimension snapshot for a workspace cwd. */
     readProjectCatalog(cwd: string): Promise<CatalogSnapshot>;
+    private buildProjectSnapshot;
     /** One suite's full detail for the market detail modal. */
     suiteDetail(sourceId: string, suiteId: string): Promise<SuiteDetail>;
     /** One skill's full SKILL.md text for the market detail modal. */
@@ -94,12 +118,16 @@ export declare class Catalog {
     removeSource(sourceId: string): Promise<void>;
     /** Refresh one source checkout, or every source when sourceId is omitted. */
     refreshSource(sourceId?: string): Promise<void>;
-    /** Install a suite from a source and enable it. */
+    /** Install a suite from a source and enable it. The client confirms the
+     * injected surfaces (skills / MCP / hooks / commands) in a pre-install
+     * dialog before this runs; disabling afterwards is always available. */
     install(sourceId: string, suiteId: string): Promise<void>;
     /** Uninstall a suite while retaining the source checkout. */
     uninstall(sourceId: string, suiteId: string): Promise<void>;
     /** Enable or disable an installed suite. */
     setEnabled(sourceId: string, suiteId: string, enabled: boolean): Promise<void>;
+    /** Enable or disable one runtime surface of an installed suite. */
+    setSurface(sourceId: string, suiteId: string, surface: SuiteSurfaceKey, enabled: boolean): Promise<void>;
     /** Append config-seeded sources missing from user state and persist them. */
     mergeSources(sources: SourceRef[]): Promise<void>;
     private setInstalled;

package/lib/types/application/details.d.ts

@@ -1,12 +1,12 @@
 import type { SkillContent, SuiteDetail } from '../contracts/market.js';
-import type { InstalledEntry, Suite } from '../model/types.js';
+import { type InstalledEntry, type Suite } from '../model/types.js';
 interface McpDiagnostic {
     suiteId: string;
     serverKey: string;
     reason: string;
 }
 /** Build the detail response for one normalized suite. */
-export declare function buildSuiteDetail(suite: Suite, installed: InstalledEntry | undefined, diagnostics: readonly McpDiagnostic[]): Promise<SuiteDetail>;
+export declare function buildSuiteDetail(suite: Suite, installed: InstalledEntry | undefined, diagnostics: readonly McpDiagnostic[], mcpOverrides?: Record<string, Record<string, unknown>>): Promise<SuiteDetail>;
 /** Read one skill body from a normalized suite. */
 export declare function readSkillContent(suite: Suite, skillName: string): Promise<SkillContent>;
 export {};

package/lib/types/application/queries.d.ts

@@ -1,7 +1,8 @@
 /** Narrow application interfaces consumed by the HTTP transport adapter. */
 import type { McpStatusPayload } from '../contracts/mcp-status.js';
 import type { OverviewPayload, SkillContent, SourceProgress, SuiteDetail } from '../contracts/market.js';
-import type { SourceRef } from '../model/types.js';
+import type { SourceRef, SuiteSurfaceKey } from '../model/types.js';
+import type { McpServerOverride, McpSuiteOverrides } from '../runtime/mcp-overrides.js';
 /** Read-only market operations required by HTTP routes. */
 export interface MarketQueries {
     readonly sources: SourceRef[];
@@ -10,6 +11,7 @@ export interface MarketQueries {
     sourceProgress(): SourceProgress;
     suiteDetail(sourceId: string, suiteId: string): Promise<SuiteDetail>;
     skillContent(sourceId: string, suiteId: string, skillName: string): Promise<SkillContent>;
+    mcpOverrides(suiteId: string): Promise<McpSuiteOverrides>;
 }
 /** Mutating market operations required by HTTP routes. */
 export interface MarketMutations {
@@ -28,6 +30,8 @@ export interface MarketMutations {
     install(sourceId: string, suiteId: string): Promise<void>;
     uninstall(sourceId: string, suiteId: string): Promise<void>;
     setEnabled(sourceId: string, suiteId: string, enabled: boolean): Promise<void>;
+    setSurface(sourceId: string, suiteId: string, surface: SuiteSurfaceKey, enabled: boolean): Promise<void>;
+    setMcpOverride(sourceId: string, suiteId: string, serverKey: string, override: McpServerOverride | null): Promise<void>;
 }
 /** Complete application surface required by the HTTP routes. */
 export type MarketService = MarketQueries & MarketMutations;

package/lib/types/catalog/native-project.d.ts

@@ -0,0 +1,17 @@
+import type { Suite, SuiteDimension } from '../model/types.js';
+/**
+ * Project-local directory conventions, in precedence order. Each entry maps
+ * one agent convention onto the content subdirectories it owns.
+ */
+export declare const NATIVE_PROJECT_DIRS: readonly NativeProjectDir[];
+export interface NativeProjectDir {
+    dirName: string;
+    label: string;
+    subdirs: readonly string[];
+}
+/**
+ * Discover native project-layout suites under a project root. Each
+ * convention directory that carries content becomes one synthetic suite;
+ * empty or absent directories contribute nothing.
+ */
+export declare function discoverNativeProjectSuites(projectRoot: string, dimension: SuiteDimension): Promise<Suite[]>;

package/lib/types/contracts/market.d.ts

@@ -16,6 +16,9 @@ export declare const MARKET_ROUTES: {
     readonly install: "/api/agent-plugins/install";
     readonly uninstall: "/api/agent-plugins/uninstall";
     readonly setEnabled: "/api/agent-plugins/set-enabled";
+    readonly setSurface: "/api/agent-plugins/set-surface";
+    readonly mcpOverrides: "/api/agent-plugins/mcp-overrides";
+    readonly setMcpOverride: "/api/agent-plugins/set-mcp-override";
 };
 /** A configured source row returned to the market client. */
 export interface SourceOverview {
@@ -37,6 +40,24 @@ export interface SuiteSurfaceCounts {
     agents: number;
     lsp: number;
 }
+/** Effective per-surface enablement of an installed suite. */
+export interface SuiteSurfaceToggles {
+    skills: boolean;
+    mcp: boolean;
+    hooks: boolean;
+    commands: boolean;
+    agents: boolean;
+}
+/** One server's persisted MCP override (wire shape mirrors runtime types). */
+export type McpServerOverrideWire = {
+    enabled?: boolean;
+    url?: string;
+    headers?: Record<string, string>;
+    env?: Record<string, string>;
+    args?: string[];
+};
+/** Overrides for one suite keyed by mcp.json server key. */
+export type McpSuiteOverridesWire = Record<string, McpServerOverrideWire>;
 /** A normalized suite card returned by the overview route. */
 export interface SuiteOverviewCard {
     sourceId: string;
@@ -48,6 +69,8 @@ export interface SuiteOverviewCard {
     surfaces: SuiteSurfaceCounts;
     enabled: boolean;
     installed: boolean;
+    /** Per-surface toggles; present on installed suites only. */
+    surfaceToggles?: SuiteSurfaceToggles;
     dimension: string;
     layout: string;
     remoteUrl?: string;
@@ -128,6 +151,9 @@ export interface SuiteDetail {
     remoteUrl: string | null;
     installed: boolean;
     enabled: boolean;
+    surfaceToggles: SuiteSurfaceToggles | null;
+    /** Persisted per-server MCP overrides (suite's mcp.json stays source-owned). */
+    mcpOverrides?: McpSuiteOverridesWire;
     skills: SuiteSkillMeta[];
     mcpServers: McpServerDetail[];
     hooks: {

package/lib/types/index.d.ts

@@ -3,9 +3,10 @@
  *
  * Function plugin (named exports, no default export). It registers one skill
  * provider feeding enabled suites into `ctx.skills`, reconciles enabled
- * suites' `mcp.json` servers into live `dsh-mcp-client` mounts, injects the
- * enabled-suite catalog at session start, registers the `agent_plugins`
- * tool, and mounts the market page's HTTP routes on the web server.
+ * suites' `mcp.json` servers into live `dsh-mcp-client` mounts, and mounts the
+ * market page's HTTP routes on the web server. Skills and MCP tools are
+ * exposed through the host's native model surfaces; this plugin does not
+ * register a redundant suite-inventory model tool.
  *
  * Requires `ctx.skills` (the dsh skill registry). The MCP client package is
  * optional at runtime: without it, suites still load their skills and the

package/lib/types/model/state.d.ts

@@ -1,4 +1,4 @@
-import type { SuiteState } from './types.js';
+import { type SuiteState } from './types.js';
 export declare const EMPTY_STATE: SuiteState;
 /** Parse persisted state; unreadable or wrong-version files yield a contained empty state. */
 export declare function loadState(statePath: string): Promise<SuiteState>;

package/lib/types/model/types.d.ts

@@ -19,7 +19,7 @@ export interface SourceRef {
     local?: boolean;
 }
 /** The manifest layout a suite root was discovered under. */
-export type SuiteLayoutKind = 'agent-plugin-v1' | 'universal' | 'claude-code' | 'cursor' | 'kimi' | 'codex' | 'skill-collection' | 'remote';
+export type SuiteLayoutKind = 'agent-plugin-v1' | 'universal' | 'claude-code' | 'cursor' | 'kimi' | 'codex' | 'skill-collection' | 'remote' | 'project-native';
 /** Normalized suite manifest fields. */
 export interface SuiteManifest {
     layout: SuiteLayoutKind;
@@ -100,6 +100,8 @@ export interface Suite {
     surfaces: SuiteSurfaceCounts;
     dimension: SuiteDimension;
     enabled: boolean;
+    /** Effective per-surface enablement (overrides merged over enabled defaults). */
+    activeSurfaces?: Record<SuiteSurfaceKey, boolean>;
     lockCommit?: string;
     installedAt?: string;
     /** Remote marketplace reference (not cloned): the source URL plus the
@@ -111,11 +113,21 @@ export interface Suite {
      * broken manifest are still exposed when they parse, per spec §7.1. */
     errors: string[];
 }
+/** Runtime surfaces that can be selectively enabled per installed suite. */
+export type SuiteSurfaceKey = 'skills' | 'mcp' | 'hooks' | 'commands' | 'agents';
+/** Per-surface user overrides; absent keys default to enabled. */
+export type SurfaceOverrides = Partial<Record<SuiteSurfaceKey, boolean>>;
+/** The full set of toggleable surfaces, in display order. */
+export declare const SUITE_SURFACE_KEYS: readonly SuiteSurfaceKey[];
+/** Merge user overrides over the enabled default into the effective surface set. */
+export declare function effectiveSurfaces(overrides: SurfaceOverrides | undefined): Record<SuiteSurfaceKey, boolean>;
 /** Persisted install entry, keyed `${sourceId}/${suiteId}`. */
 export interface InstalledEntry {
     enabled: boolean;
     lockCommit?: string;
     installedAt: string;
+    /** Per-surface enable overrides; absent keys default to enabled. */
+    surfaces?: SurfaceOverrides;
 }
 /** The persisted suite state file (`<dimensionRoot>/state.json`). */
 export interface SuiteState {

package/lib/types/runtime/commands-mounts.d.ts

@@ -1,5 +1,6 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { Suite } from '../model/types.js';
+import { type HostTranslate } from './host-locale.js';
 export interface CommandMountDiagnostic {
     suiteId: string;
     command: string;
@@ -13,8 +14,9 @@ interface CommandSpec {
 }
 export declare class CommandMountRegistry {
     private readonly ctx;
+    private readonly t;
     private readonly live;
-    constructor(ctx: Context);
+    constructor(ctx: Context, t?: HostTranslate);
     /** Register/unregister suite commands and agent-commands to match the enabled suites exactly. */
     reconcile(enabledSuites: Suite[]): Promise<CommandMountDiagnostic[]>;
     /** Dispose every registered command; used at plugin teardown. */
@@ -25,5 +27,5 @@ export declare function readCommands(root: string): Promise<CommandSpec[]>;
 /** Parse `agents/*.md` of one suite root into `agent-<name>` commands so
  *  subagents are selectable from the slash-command menu, grouped by the
  *  `agent-` prefix (the harness command UI has no group headers). */
-export declare function readAgents(root: string): Promise<CommandSpec[]>;
+export declare function readAgents(root: string, t: HostTranslate): Promise<CommandSpec[]>;
 export {};

package/lib/types/runtime/host-locale.d.ts

@@ -0,0 +1,13 @@
+/** Host runtime dictionary keys (mirrored for zh and en). */
+export type HostLocaleKey = 'agentDefinitionTitle' | 'agentDefinitionIntro' | 'commandForwardTitle' | 'commandAcknowledged' | 'agentCommandHint';
+export type HostTranslate = (key: HostLocaleKey, params?: Record<string, string>) => string;
+interface ResolvedLocale {
+    t: HostTranslate;
+}
+/** Resolve the active host language from settings; unknown values default to zh. */
+export declare function bindHostLocale(preference: string | undefined): HostTranslate;
+/** Read `locale.preference` from `$DSH_HOME/settings.yaml` (best effort). */
+export declare function readLocalePreference(): Promise<string | undefined>;
+/** Bind a host translator against the persisted locale preference. */
+export declare function loadHostLocale(): Promise<ResolvedLocale>;
+export {};