dsh-agent-plugins-market 0.5.0 → 0.5.2

package/lib/application/catalog.js

@@ -14,9 +14,11 @@ import { discoverSourceList } from '../catalog/source-catalog.js';
 import { discoverSuitesInSource } from '../catalog/suite-scanner.js';
 import { gitClone, gitHead, gitPull, gitRemove } from '../catalog/git.js';
 import { buildMcpStatus } from '../runtime/mcp-status.js';
+import { loadSuiteOverrides, saveSuiteOverrides } from '../runtime/mcp-overrides.js';
 import { buildSuiteDetail, readSkillContent } from './details.js';
 import { deriveSourceId, expandHome, isDirectory, resolveProjectRoot, sanitizeId, sourceCheckoutDir, sourcesDir, STATE_FILE_NAME } from '../catalog/paths.js';
 import { loadState, saveState, EMPTY_STATE } from '../model/state.js';
+import { effectiveSurfaces, SUITE_SURFACE_KEYS } from '../model/types.js';
 export class Catalog {
     options;
     state = EMPTY_STATE;
@@ -27,12 +29,17 @@ export class Catalog {
     revision = 0;
     userSnapshot;
     userSnapshotPromise;
+    /** Project-dimension snapshots keyed by project root, with TTL freshness. */
+    projectSnapshots = new Map();
+    projectSnapshotPromises = new Map();
+    projectSnapshotTtlMs;
     /** Latest MCP mount diagnostics (suiteId -> reasons), fed by host reconcile. */
     mcpDiagnostics = [];
     toolSnapshotProvider = () => [];
     constructor(options) {
         this.options = options;
         this.statePath = join(options.userRoot, STATE_FILE_NAME);
+        this.projectSnapshotTtlMs = options.projectSnapshotTtlMs ?? 5_000;
     }
     /** Install the host tool snapshot provider used by the MCP status surface. */
     setMcpToolSnapshotProvider(provider) {
@@ -46,7 +53,55 @@ export class Catalog {
     /** Build the flat MCP service inventory for the status surface. */
     async mcpStatus() {
         const snapshot = await this.readUserCatalog();
-        return buildMcpStatus(snapshot.suites, this.mcpDiagnostics, this.toolSnapshotProvider());
+        return buildMcpStatus(snapshot.suites, this.mcpDiagnostics, this.toolSnapshotProvider(), await this.allMcpOverrides());
+    }
+    /** One suite's persisted MCP overrides. */
+    async mcpOverrides(suiteId) {
+        const snapshot = await this.readUserCatalog();
+        if (!snapshot.suites.some(suite => suite.id === suiteId))
+            throw new Error(`suite "${suiteId}" not found`);
+        return loadSuiteOverrides(this.options.dataRoot, suiteId);
+    }
+    /**
+     * 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.
+     */
+    async setMcpOverride(sourceId, suiteId, serverKey, override) {
+        return this.enqueue(async () => {
+            const source = this.state.sources.find(entry => entry.id === sourceId);
+            if (source === undefined)
+                throw new Error(`unknown source "${sourceId}"`);
+            const checkout = this.sourceCheckoutPath(source);
+            if (!(await isDirectory(checkout)))
+                await this.ensureClone(source);
+            const suites = await discoverSuitesInSource(checkout, sourceId, 'user');
+            const suite = suites.find(entry => entry.id === suiteId);
+            if (suite === undefined)
+                throw new Error(`suite "${suiteId}" not found in source "${sourceId}"`);
+            if (suite.mcp?.servers[serverKey] === undefined)
+                throw new Error(`server "${serverKey}" is not defined by suite "${suiteId}"`);
+            const overrides = await loadSuiteOverrides(this.options.dataRoot, suiteId);
+            if (override === null) {
+                delete overrides[serverKey];
+            }
+            else {
+                overrides[serverKey] = override;
+            }
+            await saveSuiteOverrides(this.options.dataRoot, suiteId, overrides);
+            this.notifyChanged();
+        });
+    }
+    /** All persisted MCP overrides keyed by suite id (mount-time provider). */
+    async allMcpOverrides() {
+        const snapshot = await this.readUserCatalog();
+        const map = new Map();
+        for (const suite of snapshot.suites) {
+            const overrides = await loadSuiteOverrides(this.options.dataRoot, suite.id);
+            if (Object.keys(overrides).length > 0)
+                map.set(suite.id, overrides);
+        }
+        return map;
     }
     /** Load persisted user state once at plugin activation. */
     async load() {
@@ -77,6 +132,26 @@ export class Catalog {
     /** Read one coherent project-dimension snapshot for a workspace cwd. */
     async readProjectCatalog(cwd) {
         const projectRoot = await resolveProjectRoot(cwd);
+        if (this.projectSnapshotTtlMs <= 0)
+            return this.buildProjectSnapshot(projectRoot);
+        const cached = this.projectSnapshots.get(projectRoot);
+        if (cached !== undefined && cached.expiresAt > Date.now())
+            return cached.snapshot;
+        const inFlight = this.projectSnapshotPromises.get(projectRoot);
+        if (inFlight !== undefined)
+            return inFlight;
+        const promise = this.buildProjectSnapshot(projectRoot)
+            .then(snapshot => {
+            this.projectSnapshots.set(projectRoot, { snapshot, expiresAt: Date.now() + this.projectSnapshotTtlMs });
+            return snapshot;
+        })
+            .finally(() => {
+            this.projectSnapshotPromises.delete(projectRoot);
+        });
+        this.projectSnapshotPromises.set(projectRoot, promise);
+        return promise;
+    }
+    async buildProjectSnapshot(projectRoot) {
         const state = await loadState(join(projectRoot, STATE_FILE_NAME));
         return this.buildSnapshot(state, 'project', projectRoot);
     }
@@ -86,7 +161,7 @@ export class Catalog {
         const suite = snapshot.suites.find(entry => entry.sourceId === sourceId && entry.id === suiteId);
         if (suite === undefined)
             throw new Error(`suite "${suiteId}" not found in source "${sourceId}"`);
-        return buildSuiteDetail(suite, this.state.installed[installKey(sourceId, suiteId)], this.mcpDiagnostics);
+        return buildSuiteDetail(suite, this.state.installed[installKey(sourceId, suiteId)], this.mcpDiagnostics, await loadSuiteOverrides(this.options.dataRoot, suiteId));
     }
     /** One skill's full SKILL.md text for the market detail modal. */
     async skillContent(sourceId, suiteId, skillName) {
@@ -156,6 +231,7 @@ export class Catalog {
             surfaces: suite.surfaces,
             enabled: suite.enabled,
             installed: installed.has(installKey(suite.sourceId, suite.id)),
+            ...(installed.has(installKey(suite.sourceId, suite.id)) ? { surfaceToggles: suite.activeSurfaces } : {}),
             ...(suite.remote === undefined ? {} : { remoteUrl: suite.remote.url }),
             dimension: suite.dimension,
             layout: suite.manifest.layout,
@@ -327,7 +403,9 @@ export class Catalog {
             this.notifyChanged();
         });
     }
-    /** 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. */
     async install(sourceId, suiteId) {
         return this.enqueue(async () => {
             const source = this.state.sources.find(entry => entry.id === sourceId);
@@ -369,6 +447,20 @@ export class Catalog {
             this.notifyChanged();
         });
     }
+    /** Enable or disable one runtime surface of an installed suite. */
+    async setSurface(sourceId, suiteId, surface, enabled) {
+        return this.enqueue(async () => {
+            const key = installKey(sourceId, suiteId);
+            const entry = this.state.installed[key];
+            if (entry === undefined)
+                throw new Error(`suite "${suiteId}" is not installed`);
+            if (!SUITE_SURFACE_KEYS.includes(surface))
+                throw new Error(`surface "${surface}" is not toggleable`);
+            const surfaces = { ...(entry.surfaces ?? {}), [surface]: enabled };
+            await this.setInstalled(sourceId, suiteId, { ...entry, surfaces });
+            this.notifyChanged();
+        });
+    }
     /** Append config-seeded sources missing from user state and persist them. */
     async mergeSources(sources) {
         const existing = new Set(this.state.sources.map(source => source.id));
@@ -401,9 +493,13 @@ export class Catalog {
         const discovered = await discoverSourceList(state.sources, dimension, dimensionRoot);
         const suites = discovered.map(suite => {
             const installed = state.installed[installKey(suite.sourceId, suite.id)];
+            // Native project layouts (`.claude/`, `.agents/`) are the repository's
+            // own files read in place: they carry no install state and stay enabled.
+            const enabled = suite.manifest.layout === 'project-native' || installed?.enabled === true;
             return {
                 ...suite,
-                enabled: installed?.enabled === true,
+                enabled,
+                activeSurfaces: effectiveSurfaces(installed?.surfaces),
                 ...(installed?.lockCommit === undefined ? {} : { lockCommit: installed.lockCommit }),
                 ...(installed?.installedAt === undefined ? {} : { installedAt: installed.installedAt })
             };
@@ -420,6 +516,7 @@ export class Catalog {
             this.revision++;
         this.userSnapshot = undefined;
         this.userSnapshotPromise = undefined;
+        this.projectSnapshots.clear();
     }
     notifyChanged() {
         this.invalidateSnapshot(true);

package/lib/application/details.js

@@ -2,8 +2,9 @@
 import { readFile } from 'node:fs/promises';
 import { parse as parseYaml } from 'yaml';
 import { discoverLspEntries, listMdFiles } from '../catalog/surfaces.js';
+import { effectiveSurfaces } from '../model/types.js';
 /** Build the detail response for one normalized suite. */
-export async function buildSuiteDetail(suite, installed, diagnostics) {
+export async function buildSuiteDetail(suite, installed, diagnostics, mcpOverrides = {}) {
     const remoteUrl = suite.remote?.url;
     return {
         sourceId: suite.sourceId,
@@ -19,6 +20,8 @@ export async function buildSuiteDetail(suite, installed, diagnostics) {
         remoteUrl: remoteUrl ?? null,
         installed: installed !== undefined,
         enabled: installed?.enabled === true,
+        surfaceToggles: effectiveSurfaces(installed?.surfaces),
+        mcpOverrides,
         skills: suite.skills.map(skill => ({
             name: skill.name,
             description: skill.description,

package/lib/catalog/native-project.js

@@ -0,0 +1,73 @@
+/**
+ * Native project-layout discovery: read a coding agent's own project-local
+ * directories (`.claude/`, `.agents/`) in place as read-only suites.
+ *
+ * Migrating a repository from Claude Code / Codex / Cursor should not
+ * require copying files into `.dsh/agent-plugins/`. For the layouts with a
+ * project-local convention (Claude Code `.claude/`, agent-plugins
+ * `.agents/`), the project dimension discovers each content-carrying child
+ * as one synthetic suite so skills and agents reuse the ordinary injection
+ * pipeline. The directories are the repository's own: they are never
+ * installed, uninstalled, or mutated by this manager.
+ */
+import { join } from 'node:path';
+import { isDirectory, sanitizeId } from './paths.js';
+import { countSurfaces, discoverSkills } from './surfaces.js';
+/**
+ * Project-local directory conventions, in precedence order. Each entry maps
+ * one agent convention onto the content subdirectories it owns.
+ */
+export const NATIVE_PROJECT_DIRS = [
+    { dirName: '.claude', label: 'Claude Code', subdirs: ['skills', 'agents', 'commands'] },
+    { dirName: '.agents', label: 'agents', subdirs: ['skills', 'agents', 'commands'] }
+];
+/** A native project directory that carries no relevant content is skipped. */
+async function carriesContent(dir, projectRoot) {
+    for (const subdir of dir.subdirs) {
+        const path = join(projectRoot, dir.dirName, subdir);
+        if (await isDirectory(path))
+            return true;
+    }
+    return false;
+}
+/**
+ * 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 async function discoverNativeProjectSuites(projectRoot, dimension) {
+    const suites = [];
+    for (const native of NATIVE_PROJECT_DIRS) {
+        if (!(await isDirectory(join(projectRoot, native.dirName))))
+            continue;
+        if (!(await carriesContent(native, projectRoot)))
+            continue;
+        const root = join(projectRoot, native.dirName);
+        const id = sanitizeId(`${native.dirName}-native`);
+        const manifest = {
+            layout: 'project-native',
+            path: join(root, 'native'),
+            id,
+            name: `${native.label} project files`,
+            description: `Skills and agents read in place from the project's ${native.dirName}/ directory.`
+        };
+        const errors = [];
+        // Skills live in `<dir>/skills/<name>/SKILL.md` — the same shape as the
+        // ordinary skills container; agents/commands only surface as counts here
+        // and are read by the runtime providers directly from the same files.
+        const skills = await discoverSkills(root, errors, 'skills');
+        const surfaces = await countSurfaces(root, skills, undefined);
+        suites.push({
+            sourceId: 'native',
+            id,
+            root,
+            manifest,
+            skills,
+            surfaces,
+            dimension,
+            enabled: true,
+            errors
+        });
+    }
+    return suites;
+}

package/lib/catalog/source-catalog.js

@@ -3,12 +3,15 @@
  *
  * User catalogs include only configured sources. Project catalogs additionally
  * retain unmanaged checkout ids because project install state can authorize
- * them without duplicating source configuration.
+ * them without duplicating source configuration, and discover the project's
+ * native agent directories (`.claude/`, `.agents/`) in place so repositories
+ * migrating from other coding agents need no file copying.
  */
 import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { expandHome, isDirectory, sourcesDir } from './paths.js';
 import { discoverSuitesInSource } from './suite-scanner.js';
+import { discoverNativeProjectSuites } from './native-project.js';
 /** Discover suites from the selected configured or project checkouts. */
 export async function discoverSourceList(sources, dimension, dimensionRoot) {
     const checkoutRoot = sourcesDir(dimensionRoot);
@@ -34,5 +37,11 @@ export async function discoverSourceList(sources, dimension, dimensionRoot) {
             return [];
         return discoverSuitesInSource(checkout, sourceId, dimension);
     }));
-    return discovered.flat();
+    const suites = discovered.flat();
+    if (dimension === 'project') {
+        // Native project directories live two levels above the dimension root
+        // (`<projectRoot>/.dsh/agent-plugins`); read them in place.
+        suites.push(...(await discoverNativeProjectSuites(dirname(dirname(dimensionRoot)), dimension)));
+    }
+    return suites;
 }

package/lib/contracts/market.js

@@ -15,7 +15,10 @@ export const MARKET_ROUTES = {
     refreshSource: `${MARKET_API_PREFIX}sources/refresh`,
     install: `${MARKET_API_PREFIX}install`,
     uninstall: `${MARKET_API_PREFIX}uninstall`,
-    setEnabled: `${MARKET_API_PREFIX}set-enabled`
+    setEnabled: `${MARKET_API_PREFIX}set-enabled`,
+    setSurface: `${MARKET_API_PREFIX}set-surface`,
+    mcpOverrides: `${MARKET_API_PREFIX}mcp-overrides`,
+    setMcpOverride: `${MARKET_API_PREFIX}set-mcp-override`
 };
 /** Build a suite-detail URL without duplicating route or query encoding logic. */
 export function suiteRoute(sourceId, suiteId) {

package/lib/index.js

@@ -1,17 +1,25 @@
-import { mountSuiteContext } from './context.js';
 import { Catalog } from './application/catalog.js';
 import { RuntimeReconciler } from './runtime/reconciler.js';
 import { inspectToolRegistry } from './runtime/tool-registry-observer.js';
 import { resolveDataRoot, resolveUserRoot } from './catalog/paths.js';
 import { mountSuiteRoutes } from './routes.js';
 import { SuiteSkillProvider } from './runtime/skills-provider.js';
+import { bindHostLocale, loadHostLocale } from './runtime/host-locale.js';
 export const name = 'dsh-agent-plugins-market';
 export const inject = ['skills', 'commands'];
 export function apply(ctx, config = {}) {
     const userRoot = resolveUserRoot(config.userRoot);
     const dataRoot = resolveDataRoot(config.dataRoot);
     let providerControl;
-    const runtime = new RuntimeReconciler(ctx, dataRoot);
+    // Host runtime copy resolves from the harness `locale.preference` setting;
+    // the async settings read lands before the first session starts in practice.
+    const t = bindHostLocale(undefined);
+    void loadHostLocale().then(locale => {
+        hostLocale.t = locale.t;
+        providerControl?.invalidate();
+    });
+    const hostLocale = { t };
+    const runtime = new RuntimeReconciler(ctx, dataRoot, key => hostLocale.t(key));
     const reconcileMounts = () => {
         void (async () => {
             const snapshot = await catalog.readUserCatalog();
@@ -39,6 +47,7 @@ export function apply(ctx, config = {}) {
         reconcileMounts();
     };
     const catalog = new Catalog({ userRoot, dataRoot, onChanged });
+    runtime.setMcpOverridesProvider(() => catalog.allMcpOverrides());
     ctx.inject(['tools'], toolsCtx => {
         catalog.setMcpToolSnapshotProvider(() => inspectToolRegistry(toolsCtx.tools));
     });
@@ -48,14 +57,12 @@ export function apply(ctx, config = {}) {
     });
     ctx.skills.registerProvider(control => {
         providerControl = control;
-        return new SuiteSkillProvider(catalog);
+        return new SuiteSkillProvider(catalog, key => hostLocale.t(key));
     });
-    const disposeContext = mountSuiteContext(ctx, catalog);
     ctx.inject(['webServer', 'loader'], hostCtx => {
         hostCtx.effect(() => mountSuiteRoutes(hostCtx, catalog), 'dsh-agent-plugins-market: http routes');
     });
     ctx.effect(() => () => {
         void runtime.dispose();
-        disposeContext();
     }, 'dsh-agent-plugins-market: lifecycle');
 }

package/lib/model/state.js

@@ -8,6 +8,7 @@
  */
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
+import { SUITE_SURFACE_KEYS } from './types.js';
 export const EMPTY_STATE = { version: 1, sources: [], installed: {} };
 /** Parse persisted state; unreadable or wrong-version files yield a contained empty state. */
 export async function loadState(statePath) {
@@ -49,12 +50,29 @@ function normalizeState(record) {
             installed[key] = {
                 enabled: entry['enabled'] === true,
                 lockCommit: typeof entry['lockCommit'] === 'string' ? entry['lockCommit'] : undefined,
-                installedAt: typeof entry['installedAt'] === 'string' ? entry['installedAt'] : new Date(0).toISOString()
+                installedAt: typeof entry['installedAt'] === 'string' ? entry['installedAt'] : new Date(0).toISOString(),
+                ...parseSurfaceOverrides(entry['surfaces'])
             };
         }
     }
     return { version: 1, sources, installed };
 }
+/** Parse a persisted `surfaces` override record, keeping only valid boolean keys. */
+function parseSurfaceOverrides(raw) {
+    if (typeof raw !== 'object' || raw === null)
+        return {};
+    const record = raw;
+    const overrides = {};
+    let hasAny = false;
+    for (const key of SUITE_SURFACE_KEYS) {
+        const value = record[key];
+        if (typeof value === 'boolean') {
+            overrides[key] = value;
+            hasAny = true;
+        }
+    }
+    return hasAny ? { surfaces: overrides } : {};
+}
 /** Persist state atomically through a sibling-temp rename. */
 export async function saveState(statePath, state) {
     await mkdir(dirname(statePath), { recursive: true });

package/lib/model/types.js

@@ -7,4 +7,15 @@
  * Codex `.codex-plugin/plugin.json`). Discovery maps every layout onto this
  * internal shape; runtime injection consumes only the internal shape.
  */
-export {};
+/** The full set of toggleable surfaces, in display order. */
+export const SUITE_SURFACE_KEYS = ['skills', 'mcp', 'hooks', 'commands', 'agents'];
+/** Merge user overrides over the enabled default into the effective surface set. */
+export function effectiveSurfaces(overrides) {
+    return {
+        skills: overrides?.skills !== false,
+        mcp: overrides?.mcp !== false,
+        hooks: overrides?.hooks !== false,
+        commands: overrides?.commands !== false,
+        agents: overrides?.agents !== false
+    };
+}

package/lib/routes.js

@@ -9,6 +9,7 @@
 import { isAbsolute } from 'node:path';
 import { MARKET_ROUTES } from './contracts/market.js';
 import { expandHome } from './catalog/paths.js';
+import { sanitizeOverridePatch } from './runtime/mcp-overrides.js';
 const MAX_BODY_BYTES = 64 * 1024;
 /** Mount every route; returns the disposer releasing them all. */
 export function mountSuiteRoutes(hostCtx, manager) {
@@ -152,6 +153,42 @@ export function mountSuiteRoutes(hostCtx, manager) {
         await manager.setEnabled(sourceId, suiteId, enabled);
         return {};
     });
+    post(MARKET_ROUTES.setSurface, async (body) => {
+        const { sourceId, suiteId } = parseTarget(body);
+        const surface = body['surface'];
+        const enabled = body['enabled'];
+        if (typeof surface !== 'string' || surface === '')
+            throw new Error('missing surface');
+        if (typeof enabled !== 'boolean')
+            throw new Error('missing boolean enabled');
+        await manager.setSurface(sourceId, suiteId, surface, enabled);
+        return {};
+    });
+    get(MARKET_ROUTES.mcpOverrides, async (request, response) => {
+        const suiteId = queryOf(request).get('suiteId');
+        if (suiteId === null) {
+            sendJson(response, 400, { ok: false, error: 'missing suiteId' });
+            return;
+        }
+        try {
+            sendJson(response, 200, { ok: true, overrides: await manager.mcpOverrides(suiteId) });
+        }
+        catch (error) {
+            sendJson(response, 404, { ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+    });
+    post(MARKET_ROUTES.setMcpOverride, async (body) => {
+        const { sourceId, suiteId } = parseTarget(body);
+        const serverKey = body['serverKey'];
+        if (typeof serverKey !== 'string' || serverKey === '')
+            throw new Error('missing serverKey');
+        const override = body['override'];
+        const sanitized = sanitizeOverridePatch(override);
+        if (override !== null && sanitized === undefined)
+            throw new Error('invalid override payload');
+        await manager.setMcpOverride(sourceId, suiteId, serverKey, sanitized ?? null);
+        return {};
+    });
     return () => {
         for (const dispose of disposers)
             dispose();

package/lib/runtime/commands-mounts.js

@@ -14,19 +14,28 @@ import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { parseSkillFrontmatter, stripFrontmatter } from '../catalog/skills-parse.js';
+import { bindHostLocale } from './host-locale.js';
 const COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
 export class CommandMountRegistry {
     ctx;
+    t;
     live = new Map();
-    constructor(ctx) {
+    constructor(ctx, t = bindHostLocale(undefined)) {
         this.ctx = ctx;
+        this.t = t;
     }
     /** Register/unregister suite commands and agent-commands to match the enabled suites exactly. */
     async reconcile(enabledSuites) {
         const diagnostics = [];
         const wanted = new Map();
         for (const suite of enabledSuites) {
-            for (const spec of [...(await readCommands(suite.root)), ...(await readAgents(suite.root))]) {
+            const specs = suite.activeSurfaces?.commands === false && suite.activeSurfaces?.agents === false
+                ? []
+                : [
+                    ...(suite.activeSurfaces?.commands === false ? [] : await readCommands(suite.root)),
+                    ...(suite.activeSurfaces?.agents === false ? [] : await readAgents(suite.root, this.t))
+                ];
+            for (const spec of specs) {
                 const key = `${suite.id}/${spec.name}`;
                 wanted.set(key, { ...spec, suiteId: suite.id, suiteName: suite.manifest.name });
             }
@@ -53,9 +62,9 @@ export class CommandMountRegistry {
                     ...(spec.hint === undefined ? {} : { input: { hint: spec.hint } }),
                     handler: invocation => {
                         const agent = invocation.agent;
-                        const text = [`[Agent Plugins 命令 /${spec.name}（来自 ${spec.suiteId}）]`, '', spec.body.replaceAll('$ARGUMENTS', invocation.rawInput.trim())].join('\n');
+                        const text = [this.t('commandForwardTitle', { command: spec.name, suite: spec.suiteId }), '', spec.body.replaceAll('$ARGUMENTS', invocation.rawInput.trim())].join('\n');
                         agent.followup({ content: [{ type: 'text', text }], source: { kind: 'plugin', plugin: 'dsh-agent-plugins-market' } });
-                        return { kind: 'success', text: `/${spec.name} 已转交模型执行（${spec.suiteId}）` };
+                        return { kind: 'success', text: this.t('commandAcknowledged', { command: spec.name, suite: spec.suiteId }) };
                     }
                 });
                 this.live.set(key, disposer);
@@ -107,7 +116,7 @@ export async function readCommands(root) {
 /** 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 async function readAgents(root) {
+export async function readAgents(root, t) {
     let entries;
     try {
         entries = await readdir(join(root, 'agents'));
@@ -133,7 +142,7 @@ export async function readAgents(root) {
         const description = typeof parsed === 'string' ? parsed : parsed.description;
         if (description === undefined)
             continue;
-        specs.push({ name, description, hint: '子代理', body: stripFrontmatter(text) });
+        specs.push({ name, description, hint: t('agentCommandHint'), body: stripFrontmatter(text) });
     }
     return specs;
 }

package/lib/runtime/hooks-mounts.js

@@ -21,13 +21,14 @@ export class HooksMountRegistry {
     /** Mount/unmount one bridge per suite to match the enabled suites exactly. */
     async reconcile(enabledSuites) {
         const diagnostics = [];
-        const wanted = new Set(enabledSuites.map(suite => suite.id));
+        const active = enabledSuites.filter(suite => suite.activeSurfaces?.hooks !== false);
+        const wanted = new Set(active.map(suite => suite.id));
         for (const [suiteId, handle] of [...this.live]) {
             if (!wanted.has(suiteId)) {
                 await this.unmount(suiteId, handle);
             }
         }
-        for (const suite of enabledSuites) {
+        for (const suite of active) {
             if (this.live.has(suite.id))
                 continue;
             const reason = await this.mount(suite);

package/lib/runtime/host-locale.js

@@ -0,0 +1,54 @@
+/**
+ * Host-side runtime locale: bilingual copy for strings injected into agent
+ * context (agent-definition wrappers and command acknowledgements), resolved
+ * from the harness's `locale.preference` setting.
+ *
+ * The web client resolves locale through its own injected service; the host
+ * process has no such service, so this module reads `$DSH_HOME/settings.yaml`
+ * (the same file the GUI preference editor writes) and falls back to zh.
+ */
+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 工具创建子代理并将「定义正文」原样作为指令执行。',
+    commandForwardTitle: '[Agent Plugins 命令 /{command}（来自 {suite}）]',
+    commandAcknowledged: '/{command} 已转交模型执行（{suite}）',
+    agentCommandHint: '子代理'
+};
+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.',
+    commandForwardTitle: '[Agent Plugins command /{command} (from {suite})]',
+    commandAcknowledged: '/{command} forwarded to the model for execution ({suite})',
+    agentCommandHint: 'subagent'
+};
+const DICTS = { zh, en };
+/** Resolve the active host language from settings; unknown values default to zh. */
+export function bindHostLocale(preference) {
+    const dict = preference !== undefined && preference.toLowerCase().startsWith('en') ? DICTS.en : DICTS.zh;
+    return (key, params) => {
+        let text = dict[key];
+        if (params !== undefined) {
+            for (const [name, value] of Object.entries(params))
+                text = text.replaceAll(`{${name}}`, value);
+        }
+        return text;
+    };
+}
+/** Read `locale.preference` from `$DSH_HOME/settings.yaml` (best effort). */
+export async function readLocalePreference() {
+    try {
+        const text = await readFile(join(resolveDshHome(), 'settings.yaml'), 'utf8');
+        const match = /^locale:\s*\n(?:[ \t]+preference:\s*'?([^'"\s#]+)'?)/m.exec(text);
+        return match?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Bind a host translator against the persisted locale preference. */
+export async function loadHostLocale() {
+    return { t: bindHostLocale(await readLocalePreference()) };
+}

package/lib/runtime/mcp-config.js

@@ -11,23 +11,30 @@
  */
 import { createHash } from 'node:crypto';
 import { expandPlaceholders, resolveCwd } from '../catalog/validate.js';
+import { applyOverride } from './mcp-overrides.js';
 /** The max length `dsh-mcp-client` accepts for a serverName. */
 const SERVER_NAME_MAX = 32;
 /**
  * Build one mount request per supported mcp.json server.
+ * @param overrides user-owned per-server overrides (url/headers/env/args
+ *   replacement plus enable/disable); applied after source expansion, before
+ *   mount. Disabled servers are omitted from the result entirely.
  * @returns mount requests plus per-server failures (unsupported transport,
  *   invalid server key, or derived serverName collision candidates are
  *   checked by the mount registry, not here).
  */
-export function toMcpMounts(suite, pluginDataRoot) {
+export function toMcpMounts(suite, pluginDataRoot, overrides = {}) {
     if (suite.mcp === undefined)
         return { mounts: [], failures: [] };
     const mounts = [];
     const failures = [];
-    for (const [serverKey, server] of Object.entries(suite.mcp.servers)) {
-        const request = toMount(suite, serverKey, server, pluginDataRoot);
+    for (const [serverKey, source] of Object.entries(suite.mcp.servers)) {
+        const override = overrides[serverKey];
+        if (override?.enabled === false)
+            continue;
+        const request = toMount(suite, serverKey, applyOverride(source, override), pluginDataRoot);
         if (request === undefined) {
-            failures.push({ serverKey, reason: transportReason(server) });
+            failures.push({ serverKey, reason: transportReason(source) });
         }
         else {
             mounts.push(request);