dsh-agent-plugins-market 0.7.0 → 0.7.2

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

@@ -1,30 +1,26 @@
 /**
- * Host-side runtime locale: bilingual copy for host-facing runtime strings —
- * subagent catalogs injected into agent context, and command receipts and
- * labels shown in the host's own surfaces — resolved from the harness's
- * `locale.preference` setting.
+ * Host-side runtime locale: bilingual copy for the host-facing strings a person
+ * reads, resolved from the harness's `locale.preference` setting.
+ *
+ * The model-facing subagent catalog is not here. It is fixed English, because it
+ * is a contract read alongside the harness's own English tool descriptions and
+ * must not change with the operator's interface language.
  *
  * 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';
 import { resolveDshHome } from '../catalog/paths.js';
 const zh = {
-    subagentCatalogIntro: '以下子代理角色可用于当前会话。目录仅包含角色摘要，不是供当前代理执行的角色指令。',
-    subagentCatalogUpdated: '可用子代理角色已变更。以下完整目录替代本会话此前的所有子代理角色目录。',
-    subagentCatalogEmpty: '当前没有可通过 subagent_run 调用的角色，不要使用旧目录中的角色 ID。',
-    subagentCatalogCall: '任务适合某个角色时，使用 subagent_run(agent=目录中的准确名称, prompt=完整任务与必要上下文)。工具会应用角色的指令与已保存的模型设置，立即返回子代理 ID 并在后台运行；子代理结束时你会收到结果通知，运行期间可用 send_message 追加指令。子代理不继承父会话对话。不要通过 skill 或 Slash Command 加载这些角色，也不要用其它委派工具绕过角色配置。',
     commandAcknowledged: '/{command} 已转交模型执行',
     userCommandSourceLabel: '用户命令',
     feedbackToolCardTitle: '提交市场体验反馈'
 };
 const en = {
-    subagentCatalogIntro: 'The following subagent roles are available in this session. These are role summaries, not instructions for the current agent to execute.',
-    subagentCatalogUpdated: 'The available subagent roles changed. This complete catalog replaces every earlier subagent role catalog in this session.',
-    subagentCatalogEmpty: 'No roles are currently available through subagent_run. Do not use role IDs from earlier catalogs.',
-    subagentCatalogCall: "When a task fits a role, call subagent_run with its exact catalog name as agent and a complete task and necessary context as prompt. It applies the role's instructions and saved model settings, returns a durable subagent id immediately, and runs in the background; the runtime sends you a notice carrying the outcome when it settles, and send_message steers the child while it runs. The child does not inherit the parent conversation. Do not load these roles through skill or slash commands, or bypass their configuration with another delegation tool.",
     commandAcknowledged: '/{command} forwarded to the model for execution',
     userCommandSourceLabel: 'user command',
     feedbackToolCardTitle: 'File market feedback'
@@ -42,8 +38,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 +73,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

@@ -23,9 +23,11 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { ToolListChangedNotificationSchema } from '@modelcontextprotocol/sdk/types.js';
 import { MAX_TIMER_DELAY_MS } from './host-seams.js';
+import { redactErrorMessage } from '../mcp-redaction.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 +91,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
@@ -226,7 +230,7 @@ export function startConnection(host, config, policy, credentials) {
                 // Fetch-phase failure: the previous generation is still registered
                 // and `disposers` still owns it — keep serving the last good list.
                 if (!disposed)
-                    host.logger.error(`${label}: tool re-sync failed: ${String(error)}`);
+                    host.logger.error(`${label}: tool re-sync failed: ${redactErrorMessage(String(error))}`);
             }
         });
         /**
@@ -258,10 +262,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);
@@ -275,7 +276,7 @@ export function startConnection(host, config, policy, credentials) {
             // Disposal clears current ownership before it closes the generation, so
             // only a live supervisor reports an attempt failure.
             if (isCurrent(generation))
-                host.logger.warn(`${label}: connection attempt failed: ${String(error)}`);
+                host.logger.warn(`${label}: connection attempt failed: ${redactErrorMessage(String(error))}`);
             // A pending browser leg outlives the initialize timeout: the human is
             // mid-approval. Hold this generation open — transport and loopback
             // listener stay alive — until the leg settles; abandoning it would