dsh-agent-plugins-market 0.7.0 → 0.7.1

package/lib/runtime/agent-role-router.js

@@ -5,6 +5,7 @@ import { parse as parseYaml } from 'yaml';
 import { mountSubagentCatalog } from './subagent-catalog.js';
 import { bindHostLocale } from './host-locale.js';
 import { namedAgentRoles } from './agent-role-names.js';
+import { expandPluginPaths } from '../catalog/plugin-variables.js';
 export const AGENT_ROLE_TOOL_NAME = 'subagent_run';
 /**
  * Absolute delegation-depth cap applied to every role child. The host default is
@@ -113,7 +114,7 @@ export async function resolveAgentOptions(policy, parent, llm, signal, subject,
     };
 }
 /** Stable summaries; invalid declarations are excluded and transient read failures abort publication. */
-export async function agentRoleCatalog(entries, signal, diagnose = () => { }) {
+export async function agentRoleCatalog(entries, signal, diagnose = () => { }, projectDir) {
     const summaries = [];
     const counts = new Map();
     for (const entry of entries)
@@ -137,7 +138,7 @@ export async function agentRoleCatalog(entries, signal, diagnose = () => { }) {
         }
         let policy;
         try {
-            policy = parseAgentRole(text);
+            policy = expandPolicyPaths(parseAgentRole(text), entry, projectDir);
         }
         catch (error) {
             diagnose(`${entry.path}: ${String(error)}`);
@@ -160,9 +161,30 @@ export async function agentRoleCatalog(entries, signal, diagnose = () => { }) {
     signal.throwIfAborted();
     return summaries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
 }
+/** A suite card carries the same path variables as every other surface its author wrote for. */
+function expandPolicyPaths(policy, entry, projectDir) {
+    if (entry.suiteRoot === undefined && entry.suiteData === undefined && projectDir === undefined)
+        return policy;
+    const context = {
+        ...(entry.suiteRoot === undefined ? {} : { root: entry.suiteRoot }),
+        ...(entry.suiteData === undefined ? {} : { data: entry.suiteData }),
+        ...(projectDir === undefined ? {} : { projectDir })
+    };
+    return {
+        ...policy,
+        content: expandPluginPaths(policy.content, context),
+        ...(policy.title === undefined ? {} : { title: expandPluginPaths(policy.title, context) }),
+        ...(policy.description === undefined ? {} : { description: expandPluginPaths(policy.description, context) })
+    };
+}
 /** Read the same declaration for catalog summaries and execution, including inline resources. */
-export async function readAgentRole(entry) {
-    return parseAgentRole(entry.rawText ?? (await readFile(entry.path, 'utf8')));
+export async function readAgentRole(entry, projectDir) {
+    return expandPolicyPaths(parseAgentRole(entry.rawText ?? (await readFile(entry.path, 'utf8'))), entry, projectDir);
+}
+/** The calling session's directory, which is what a card's `${CLAUDE_PROJECT_DIR}` names. */
+function sessionCwd(agent) {
+    const cwd = agent?.session?.header?.cwd;
+    return typeof cwd === 'string' && cwd !== '' ? cwd : undefined;
 }
 /**
  * Start one role child and return its durable id without waiting for the result.
@@ -180,7 +202,7 @@ export async function executeAgentRole(host, listRoles, agentName, prompt, paren
         throw new Error(`agent "${agentName}" is unavailable or ambiguous`);
     if (entry.disabled)
         throw new Error(`agent "${agentName}" is disabled`);
-    const policy = await readAgentRole(entry);
+    const policy = await readAgentRole(entry, sessionCwd(parent));
     if (policy.disabled)
         throw new Error(`agent "${agentName}" is disabled`);
     const agentOptions = await resolveAgentOptions(policy, parent, host.llm, signal, agentName, diagnose);
@@ -227,7 +249,7 @@ export function mountAgentRoleTool(ctx, listRoles, t = bindHostLocale(undefined)
     const disposeTool = host.tools.register(tool);
     let disposeCatalog;
     try {
-        disposeCatalog = mountSubagentCatalog(ctx, tool, async (agent, signal) => agentRoleCatalog(await listRoles(agent), signal, message => ctx.logger?.warn(message)), t);
+        disposeCatalog = mountSubagentCatalog(ctx, tool, async (agent, signal) => agentRoleCatalog(await listRoles(agent), signal, message => ctx.logger?.warn(message), sessionCwd(agent)), t);
     }
     catch (error) {
         disposeTool();

package/lib/runtime/commands-mounts.js

@@ -1,18 +1,27 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { parse as parseYaml } from 'yaml';
 import { stripFrontmatter } from '../catalog/skills-parse.js';
 import { parseFrontmatterRecord } from './user-store.js';
-import { qualifiedSuiteId } from '../catalog/paths.js';
+import { qualifiedSuiteId, suiteDataDir } from '../catalog/paths.js';
+import { expandPluginPaths, pluginRootOf } from '../catalog/plugin-variables.js';
 import { defaultMarkdownResources, resourceText, resourceCommandName } from '../catalog/component-files.js';
 import { bindHostLocale } from './host-locale.js';
+import { injectDynamicContext, shellSeamOf } from './dynamic-context.js';
 const COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
 export class CommandMountRegistry {
     ctx;
     t;
+    dataRoot;
     fingerprints = new Map();
     live = new Map();
-    constructor(ctx, t = bindHostLocale(undefined)) {
+    constructor(ctx, t = bindHostLocale(undefined), dataRoot) {
         this.ctx = ctx;
         this.t = t;
+        this.dataRoot = dataRoot;
+    }
+    /** The live shell seam, when the profile has one; dynamic context stays literal without it. */
+    shell() {
+        return shellSeamOf(this.ctx);
     }
     /** Register/unregister suite commands to match the enabled suites exactly. */
     async reconcile(enabledSuites) {
@@ -20,6 +29,8 @@ export class CommandMountRegistry {
         const wanted = new Map();
         for (const suite of enabledSuites) {
             const specs = suite.activeSurfaces.commands === false ? [] : await readCommands(suite.root, suite.resources?.commands);
+            const suiteRoot = pluginRootOf(suite);
+            const suiteData = suiteRoot === undefined || this.dataRoot === undefined ? undefined : suiteDataDir(this.dataRoot, suite.sourceId, suite.id);
             for (const spec of specs) {
                 // The registry key is source-qualified: bare suite ids are unique per
                 // source only, so two sources' same-named suites would collide.
@@ -29,7 +40,13 @@ export class CommandMountRegistry {
                     diagnostics.push({ suiteId: suiteKey, command: spec.name, reason: 'duplicate normalized command name' });
                     continue;
                 }
-                wanted.set(key, { ...spec, suiteId: suiteKey, suiteName: suite.manifest.name });
+                wanted.set(key, {
+                    ...spec,
+                    suiteId: suiteKey,
+                    suiteName: suite.manifest.name,
+                    ...(suiteRoot === undefined ? {} : { suiteRoot }),
+                    ...(suiteData === undefined ? {} : { suiteData })
+                });
             }
         }
         for (const [key, disposer] of [...this.live]) {
@@ -56,13 +73,37 @@ export class CommandMountRegistry {
                     name: spec.name,
                     description: `[${spec.suiteName}] ${spec.description}`,
                     ...(spec.hint === undefined ? {} : { input: { hint: spec.hint } }),
-                    handler: invocation => {
+                    handler: async (invocation) => {
                         const agent = invocation.agent;
-                        // The template rides the agent verbatim: a decorator line naming
-                        // this plugin or the suite would be text the command author never
-                        // wrote, and the follow-up's `source` already records provenance.
-                        const text = spec.body.replaceAll('$ARGUMENTS', invocation.rawInput.trim());
-                        agent.followup({ content: [{ type: 'text', text }], source: { kind: 'plugin', plugin: 'dsh-agent-plugins-market' } });
+                        const workdir = agent.session?.header?.cwd;
+                        // The template rides the agent verbatim apart from the placeholders
+                        // its author wrote: a decorator line naming this plugin or the
+                        // suite would be text the command author never wrote, and the
+                        // follow-up's `source` already records provenance.
+                        const body = expandPluginPaths(spec.body, {
+                            ...(spec.suiteRoot === undefined ? {} : { root: spec.suiteRoot }),
+                            ...(spec.suiteData === undefined ? {} : { data: spec.suiteData }),
+                            ...(workdir === undefined ? {} : { projectDir: workdir })
+                        }).replaceAll('$ARGUMENTS', invocation.rawInput.trim());
+                        const shell = this.shell();
+                        if (shell === undefined) {
+                            agent.followup(createUserMessage({
+                                content: [{ type: 'text', text: body }],
+                                source: { kind: 'plugin', plugin: 'dsh-agent-plugins-market' }
+                            }));
+                            return { kind: 'success', text: this.t('commandAcknowledged', { command: spec.name }) };
+                        }
+                        let text;
+                        try {
+                            text = await injectDynamicContext(body, { shell, ...(workdir === undefined ? {} : { workdir }) });
+                        }
+                        catch (error) {
+                            return { kind: 'error', text: error instanceof Error ? error.message : String(error) };
+                        }
+                        agent.followup(createUserMessage({
+                            content: [{ type: 'text', text }],
+                            source: { kind: 'plugin', plugin: 'dsh-agent-plugins-market' }
+                        }));
                         return { kind: 'success', text: this.t('commandAcknowledged', { command: spec.name }) };
                     }
                 });

package/lib/runtime/deadline.js

@@ -7,22 +7,48 @@
  * browser authorization the user is completing must not be abandoned just
  * because nobody is waiting for it any more.
  *
+ * The timer and its reason come from the host's own deadline primitive, which
+ * only notifies. This module adds the one thing that primitive does not answer
+ * and these callers need: whether the work settled at all.
+ *
  * @module runtime/deadline
  */
+import { deadline } from '@deepseek-ai/dsh-timeout';
+/** Identifies this plugin's bounded waits inside a timeout reason. */
+export const MARKET_DEADLINE_CODE = 'MARKET_DEADLINE';
 /**
  * Resolve `true` once `work` settles, or `false` when `deadlineMs` elapses.
  *
  * A rejection counts as settled: this helper only reports timing, so callers
  * that need the failure attach their own handler to `work`.
+ *
+ * A non-positive wait means "do not wait": the answer is simply whether the
+ * work had already settled. That is deliberately not the host primitive's own
+ * reading of a non-positive timeout, which is "arm no timer at all" — the floor
+ * below keeps the two from collapsing into opposite behaviors.
+ * @param work - the work to wait for; it is never cancelled, only stopped being awaited.
+ * @param deadlineMs - how long to wait, in milliseconds.
+ * @returns whether the work settled before the deadline.
  */
 export function settlesWithin(work, deadlineMs) {
+    const bound = deadline(undefined, Math.max(1, deadlineMs), MARKET_DEADLINE_CODE);
+    let settled = false;
     return new Promise(resolve => {
-        const timer = setTimeout(() => resolve(false), deadlineMs);
-        timer.unref?.();
-        const settle = () => {
-            clearTimeout(timer);
-            resolve(true);
+        const settle = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(value);
         };
-        void work.then(settle, settle);
+        bound.signal.addEventListener('abort', () => {
+            settle(false);
+        }, { once: true });
+        void work.then(() => {
+            settle(true);
+        }, () => {
+            settle(true);
+        });
+    }).finally(() => {
+        bound[Symbol.dispose]();
     });
 }

package/lib/runtime/dynamic-context.js

@@ -0,0 +1,140 @@
+/** How long one injected command may run; the executor caps a larger request. */
+export const DYNAMIC_CONTEXT_TIMEOUT_MS = 120_000;
+/** The requested forward cap for one injected command's stdout, in bytes. */
+export const DYNAMIC_CONTEXT_MAX_OUTPUT_BYTES = 32 * 1024;
+/**
+ * Resolve the host shell service from any context, whether or not the reading
+ * fiber injects `shell`.
+ *
+ * Cordis resolves `ctx.shell` by walking the reading fiber's ancestors, so a
+ * scope that does not inject the service throws `cannot get property "shell"
+ * without inject` even when a sibling fiber provides it. `ctx.get` reads the
+ * global service store instead and answers `undefined` in a profile that has
+ * no shell, which is what keeps the seam optional.
+ *
+ * @param ctx - the context the dynamic-context pass runs under.
+ * @returns the shell seam, or `undefined` when the profile provides none.
+ */
+export function shellSeamOf(ctx) {
+    return ctx.get('shell');
+}
+/**
+ * Commands whose exit code 1 is a result rather than a failure, mirroring the
+ * shell consumers the harness already treats this way.
+ */
+const BENIGN_EXIT_ONE = new Set(['grep', 'rg', 'egrep', 'fgrep', 'find', 'diff', 'test', '[']);
+const BENIGN_EXIT_ONE_SUBCOMMANDS = new Set(['git diff', 'git grep']);
+const INJECTION = /(^|[ \t])!`([^`\n]+)`|^```!\r?\n([\s\S]*?)^```[ \t]*$/gm;
+/**
+ * Run every placeholder's command and return the text the model receives.
+ *
+ * @param text - author text whose `${...}` variables and arguments are already resolved.
+ * @param options - the resolved shell seam, session directory and cancellation signal.
+ * @returns the text with each placeholder replaced by its command's output.
+ * @throws when a command fails, times out or is aborted, carrying the command and its output.
+ */
+export async function injectDynamicContext(text, options) {
+    const injections = findInjections(text);
+    if (injections.length === 0)
+        return text;
+    const parts = [];
+    let cursor = 0;
+    for (const injection of injections) {
+        parts.push(text.slice(cursor, injection.start), await runInjection(injection.command, options));
+        cursor = injection.end;
+    }
+    parts.push(text.slice(cursor));
+    return parts.join('');
+}
+/** Locate every placeholder in one pass so an inserted output is never re-scanned. */
+function findInjections(text) {
+    const found = [];
+    for (const match of text.matchAll(INJECTION)) {
+        const index = match.index ?? 0;
+        const script = match[3];
+        if (script !== undefined) {
+            // The capture runs to the closing fence line; the block's own framing
+            // whitespace is not part of the script.
+            found.push({ start: index, end: index + match[0].length, command: script.trim() });
+            continue;
+        }
+        const command = match[2];
+        if (command === undefined)
+            continue;
+        // The captured prefix stays in the text, so the replacement keeps the
+        // author's own leading whitespace.
+        const prefix = match[1] ?? '';
+        found.push({ start: index + prefix.length, end: index + match[0].length, command });
+    }
+    return found;
+}
+/** Run one placeholder's command and return its output, or throw with the command's own words. */
+async function runInjection(command, options) {
+    const spec = options.shell.resolve({
+        command,
+        ...(options.workdir === undefined ? {} : { workdir: options.workdir }),
+        timeoutMs: DYNAMIC_CONTEXT_TIMEOUT_MS,
+        stdoutMaxBytes: DYNAMIC_CONTEXT_MAX_OUTPUT_BYTES,
+        ...(options.signal === undefined ? {} : { signal: options.signal })
+    });
+    const result = await options.shell.run(spec);
+    if (!benignExit(result.exitCode, command))
+        throw injectionFailure(command, result);
+    const body = stripTrailingNewline(mergeOutputs(result.stdout.text, result.stderr.text));
+    if (!result.stdout.truncated && !result.stderr.truncated)
+        return body;
+    const notice = truncationNotice(result);
+    return body === '' ? notice : `${body}\n${notice}`;
+}
+/** Whether this command's exit status is a result rather than a failure. */
+export function benignExit(exitCode, command) {
+    if (exitCode === 0)
+        return true;
+    if (exitCode !== 1)
+        return false;
+    const [program = '', subcommand = ''] = stripEnvironmentPrefix(command.trim().replace(/\s+/g, ' ')).split(' ');
+    // A path-qualified invocation names the same command as its bare spelling.
+    if (BENIGN_EXIT_ONE.has(program.split('/').pop() ?? program))
+        return true;
+    return program === 'git' && BENIGN_EXIT_ONE_SUBCOMMANDS.has(`git ${subcommand}`);
+}
+/** Skip leading `NAME=value` assignments so `FOO=1 grep x` keeps its benign status. */
+function stripEnvironmentPrefix(command) {
+    let rest = command;
+    for (;;) {
+        const match = /^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/.exec(rest);
+        if (match === null)
+            return rest;
+        rest = rest.slice(match[0].length);
+    }
+}
+/** Merge the two captured streams the way the default shell surfaces them. */
+function mergeOutputs(stdout, stderr) {
+    if (stderr === '')
+        return stdout;
+    if (stdout === '')
+        return stderr;
+    return stdout.endsWith('\n') ? stdout + stderr : `${stdout}\n${stderr}`;
+}
+/** One trailing newline is dropped so the output joins the surrounding text. */
+function stripTrailingNewline(value) {
+    return value.endsWith('\n') ? value.slice(0, -1) : value;
+}
+/** What the caller reports when a placeholder's command does not produce a result. */
+function injectionFailure(command, result) {
+    const cause = result.timedOut
+        ? `timed out after ${DYNAMIC_CONTEXT_TIMEOUT_MS}ms`
+        : result.aborted
+            ? 'was aborted'
+            : `exited with ${result.exitCode === null ? 'a signal' : `code ${result.exitCode}`}`;
+    return new Error([
+        `Shell command failed for pattern "!\`${command}\`" (${cause})`,
+        ...(result.stdout.text === '' ? [] : ['[stdout]', result.stdout.text.trimEnd()]),
+        ...(result.stderr.text === '' ? [] : ['[stderr]', result.stderr.text.trimEnd()])
+    ].join('\n'));
+}
+/** Tell the model the injected text is only part of the command's output. */
+function truncationNotice(result) {
+    const spill = result.stdout.spillPath ?? result.stderr.spillPath;
+    return `[output truncated${spill === undefined ? '' : `; full output: ${spill}`}]`;
+}

package/lib/runtime/feedback-tool.js

@@ -24,6 +24,7 @@ import { promisify } from 'node:util';
 import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { platformBrowserOpener } from './mcp-client/oauth.js';
+import { toolsServiceOf } from './tool-registry-observer.js';
 const execFileAsync = promisify(execFile);
 /** The GitHub repository experience feedback files issues against. */
 export const FEEDBACK_REPO_OWNER = 'Sivan757';
@@ -180,10 +181,13 @@ const FEEDBACK_DESCRIPTION = 'File an experience-feedback issue for dsh-agent-pl
  * on this host.
  */
 export function mountFeedbackTool(hostCtx, dataRoot, t) {
-    const host = hostCtx;
-    if (typeof host.tools?.register !== 'function')
+    // Read the service store rather than the context property: this plugin's own
+    // fiber injects `skills` and `commands` only, and the host provides `tools`
+    // from a sibling fiber, so a property read throws on every profile.
+    const tools = toolsServiceOf(hostCtx);
+    if (typeof tools?.register !== 'function')
         return undefined;
-    return host.tools.register(defineTool({
+    return tools.register(defineTool({
         name: FEEDBACK_TOOL_NAME,
         description: FEEDBACK_DESCRIPTION,
         parameters: {

package/lib/runtime/host-locale.js

@@ -5,8 +5,10 @@
  * `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.
+ * process reads the same setting through the host settings service once the
+ * plugin wires it, and falls back to parsing `$DSH_HOME/settings.yaml` (the
+ * document that service serves, and which exists even when the service is not
+ * composed). Neither source means zh.
  */
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -42,8 +44,28 @@ export function bindHostLocale(preference) {
         return text;
     };
 }
-/** Read `locale.preference` from `$DSH_HOME/settings.yaml` (best effort). */
+/**
+ * The active language, read from the host settings service when the plugin has
+ * wired one. The service owns the resolved document in memory, so it answers
+ * without a file read and without racing a pending write.
+ */
+let hostPreference;
+/**
+ * Wire the host settings service as the primary locale source, replacing the
+ * `settings.yaml` fallback.
+ * @param read - reads `locale.preference` from the settings service.
+ */
+export function setHostLocaleSource(read) {
+    hostPreference = read;
+}
+/**
+ * The persisted locale preference: the host settings document when the service
+ * is composed, else `$DSH_HOME/settings.yaml` (best effort).
+ */
 export async function readLocalePreference() {
+    const fromHost = hostPreference?.();
+    if (fromHost !== undefined)
+        return fromHost;
     try {
         const text = await readFile(join(resolveDshHome(), 'settings.yaml'), 'utf8');
         const match = /^locale:\s*\n(?:[ \t]+preference:\s*'?([^'"\s#]+)'?)/m.exec(text);
@@ -57,3 +79,17 @@ export async function readLocalePreference() {
 export async function loadHostLocale() {
     return { t: bindHostLocale(await readLocalePreference()) };
 }
+/**
+ * Read `locale.preference` from the host settings service.
+ *
+ * The locale namespace is registered by the host's own client-locale plugin, so
+ * this reads `undefined` until that plugin mounts — which is why the caller
+ * re-binds when the service arrives rather than capturing the value once.
+ * @param settingsCtx - a context carrying the `settings` service.
+ */
+export function readHostLocalePreference(settingsCtx) {
+    const settings = settingsCtx.settings;
+    const section = settings?.get?.('locale');
+    const preference = section?.preference;
+    return typeof preference === 'string' ? preference : undefined;
+}

package/lib/runtime/lsp-mounts.js

@@ -1,7 +1,8 @@
 import { DIRECT_LSP_SUITE_ID } from './lsp-status.js';
 import { SerialPassQueue, RetryScheduler } from './mount-lifecycle.js';
 import { describeLegacySeam, findLegacyLspSeams } from './profile-seam.js';
-import { qualifiedSuiteId } from '../catalog/paths.js';
+import { qualifiedSuiteId, suiteDataDir } from '../catalog/paths.js';
+import { expandPluginPaths, pluginRootOf } from '../catalog/plugin-variables.js';
 import { effectiveSurfaces } from '../model/types.js';
 /** Build one dsh-lsp-stdio Config.servers entry from a normalized spec. */
 export function toLspServerConfig(spec) {
@@ -14,6 +15,15 @@ export function toLspServerConfig(spec) {
         ...(spec.configuration === undefined ? {} : { configuration: spec.configuration })
     };
 }
+/** Resolve author-written paths in one declaration before the host spawns the server. */
+export function expandLspServerConfig(config, context) {
+    return {
+        ...config,
+        command: expandPluginPaths(config.command, context),
+        args: config.args.map(argument => expandPluginPaths(argument, context)),
+        ...(config.env === undefined ? {} : { env: Object.fromEntries(Object.entries(config.env).map(([key, value]) => [key, expandPluginPaths(value, context)])) })
+    };
+}
 /** Import specifiers kept as string literals so the host packages stay dynamically loaded. */
 const LSP_STDIO_IMPORT = '@deepseek-ai/dsh-lsp-stdio';
 const LSP_SERVICE_IMPORT = '@deepseek-ai/dsh-lsp';
@@ -62,6 +72,8 @@ export class LspMountRegistry {
     capabilityFailure;
     /** Latest diagnostic per suite id; cleared when its suite mounts or leaves the wanted set. */
     lastDiagnostics = new Map();
+    /** Plugin storage root holding each suite's `${PLUGIN_DATA}` directory; unset leaves the variable verbatim. */
+    pluginDataRoot;
     /** Direct (user-configured) server provider; defaults to none. */
     directProvider = async () => ({});
     disabledProvider = async () => new Set();
@@ -98,9 +110,14 @@ export class LspMountRegistry {
             // otherwise shadow each other's mount and diagnostics.
             const key = qualifiedSuiteId(suite.sourceId, suite.id);
             const config = {};
+            const root = pluginRootOf(suite);
+            const context = {
+                ...(root === undefined ? {} : { root }),
+                ...(root === undefined || this.pluginDataRoot === undefined ? {} : { data: suiteDataDir(this.pluginDataRoot, suite.sourceId, suite.id) })
+            };
             for (const spec of servers)
                 if (!disabled.has(`${key}/${spec.key}`))
-                    config[`${key}/${spec.key}`] = toLspServerConfig(spec);
+                    config[`${key}/${spec.key}`] = expandLspServerConfig(toLspServerConfig(spec), context);
             if (Object.keys(config).length > 0)
                 wanted.set(key, { suite, config });
         }
@@ -257,6 +274,10 @@ export class LspMountRegistry {
             }
         }
     }
+    /** Install the plugin storage root per-suite data directories resolve against. */
+    setPluginDataRoot(root) {
+        this.pluginDataRoot = root;
+    }
     /** Install the direct (user-configured) server provider used at reconcile time. */
     setDirectProvider(provider) {
         this.directProvider = provider;

package/lib/runtime/mcp-backend.js

@@ -4,8 +4,8 @@
  * and legacy SSE) or through the host's `@deepseek-ai/dsh-mcp-client`
  * (compatibility mode: no OAuth, no SSE, but the host-native implementation).
  *
- * The choice is a host settings namespace (`dsh-agent-plugins-market`,
- * `mcpEnhanced: boolean`, default true) registered by the plugin's node half:
+ * The choice is the `mcpEnhanced` field of the market's host settings
+ * namespace (see `contracts/settings.ts`) registered by the plugin's node half:
  * the registration is what makes the host 插件配置 tab serve our card, the
  * client card binds it for state, and the node half watches it to remount
  * servers when the switch flips. `readMcpBackend` remains only as the
@@ -17,20 +17,19 @@ import { readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import z from '@deepseek-ai/schemastery';
-/** 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 switches this plugin's config card serves. */
+import { MARKET_SETTINGS_DEFAULTS } from '../contracts/settings.js';
+/**
+ * Schema of the market settings namespace: the switches this plugin's config
+ * card serves, with the defaults declared to the host. The values themselves
+ * belong to {@link MARKET_SETTINGS_DEFAULTS}; this schema states them, it does
+ * not own them.
+ */
 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; OFF (default) scans configured sources only. */
-    scanProjectLayouts: z.boolean().default(false),
-    /** Download region for GitHub acquisition; `auto` follows the interface language. */
-    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),
-    /** ON = refresh every configured source in the background; OFF (default) = never. */
-    autoUpdateSources: z.boolean().default(false)
+    mcpEnhanced: z.boolean().default(MARKET_SETTINGS_DEFAULTS.mcpEnhanced),
+    scanProjectLayouts: z.boolean().default(MARKET_SETTINGS_DEFAULTS.scanProjectLayouts),
+    downloadRegion: z.union([z.const('auto'), z.const('global'), z.const('china')]).default(MARKET_SETTINGS_DEFAULTS.downloadRegion),
+    feedbackEnabled: z.boolean().default(MARKET_SETTINGS_DEFAULTS.feedbackEnabled),
+    autoUpdateSources: z.boolean().default(MARKET_SETTINGS_DEFAULTS.autoUpdateSources)
 });
 /** Path of the legacy persisted settings file under the plugin data root. */
 export function marketSettingsPath(dataRoot) {

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

@@ -10,6 +10,14 @@
  */
 /** Default timeout for individual MCP tool calls (ms). */
 export const DEFAULT_TOOL_CALL_TIMEOUT_MS = 60_000;
+/**
+ * How long one connection attempt may spend initializing (ms). A server that
+ * never answers would otherwise hold its process, transport and browser leg
+ * until the SDK's own 60-second request default expired; a working server
+ * handshakes well under a second, and a genuinely slow one can declare its own
+ * `startupTimeoutMs`.
+ */
+export const DEFAULT_STARTUP_TIMEOUT_MS = 10_000;
 /** Valid `serverName`, kept below the public tool-name budget. */
 export const SERVER_NAME_PATTERN = /^[A-Za-z0-9_-]{1,32}$/;
 /**

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

@@ -26,6 +26,7 @@ import { MAX_TIMER_DELAY_MS } from './host-seams.js';
 import { PLUGIN_NAME, PLUGIN_VERSION } from './plugin-identity.js';
 import { createTransport } from './transport.js';
 import { syncTools } from './tools.js';
+import { DEFAULT_STARTUP_TIMEOUT_MS } from './config.js';
 /** Defaults shared by the config and {@link resolveReconnectPolicy}. */
 export const RECONNECT_DEFAULTS = Object.freeze({
     enabled: true,
@@ -89,9 +90,11 @@ export function startConnection(host, config, policy, credentials) {
         registrationFailure: 'contain',
         serverName: config.serverName,
         toolCallTimeoutMs: config.toolCallTimeoutMs,
+        // Every attempt is bounded: an unreachable server must not hold its
+        // process, transport and browser leg while nothing can arrive.
+        startupTimeoutMs: config.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
         ...(config.enabledTools === undefined ? {} : { enabledTools: config.enabledTools }),
-        ...(config.disabledTools === undefined ? {} : { disabledTools: config.disabledTools }),
-        ...(config.startupTimeoutMs === undefined ? {} : { startupTimeoutMs: config.startupTimeoutMs })
+        ...(config.disabledTools === undefined ? {} : { disabledTools: config.disabledTools })
     };
     // The initial sync uses 'throw' when failOnStartupError is configured, so
     // a registration conflict propagates to the startup-await path. Re-syncs
@@ -258,10 +261,7 @@ export function startConnection(host, config, policy, credentials) {
             host.logger.info(message);
         });
         try {
-            if (config.startupTimeoutMs === undefined)
-                await generation.connect(transport);
-            else
-                await generation.connect(transport, { timeout: config.startupTimeoutMs });
+            await generation.connect(transport, { timeout: opts.startupTimeoutMs });
             if (hasClosed()) {
                 attemptSettled = true;
                 generationDown(generation);