dsh-agent-plugins-market 0.6.2 → 0.7.1

package/lib/runtime/mcp-status.js

@@ -1,5 +1,4 @@
-import { applyOverride } from './mcp-overrides.js';
-import { credentialRefsInServer, deriveServerName } from './mcp-config.js';
+import { credentialRefsInServer, effectiveMcpServers, deriveServerName } from './mcp-config.js';
 import { inspectToolRegistry } from './tool-registry-observer.js';
 import { redactMcpConfig, redactUrl } from './mcp-redaction.js';
 import { qualifiedSuiteId } from '../catalog/paths.js';
@@ -29,16 +28,15 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
         if (suite.mcp === undefined || suite.installedAt === undefined || !suite.enabled)
             continue;
         const suiteKey = qualifiedSuiteId(suite.sourceId, suite.id);
-        const suiteOverrides = overrides.get(suiteKey);
-        for (const [serverKey, server] of Object.entries(suite.mcp.servers)) {
-            const override = suiteOverrides?.[serverKey];
+        for (const { serverKey, server: effective, override, enabled, credentialRefs: refs } of effectiveMcpServers(suite, overrides.get(suiteKey))) {
             const serverName = deriveServerName(suite.id, serverKey);
             const tools = observedByServer.get(serverName) ?? [];
             claimedServers.add(serverName);
             const diagnostic = diagnosticsByKey.get(`${suiteKey}\u0000${serverKey}`);
-            const effective = applyOverride(server, override);
-            const credentialRefs = [...new Set([...credentialRefsInServer(effective), ...(diagnostic?.credentialRefs ?? [])])].sort();
-            const disabled = override?.enabled === false || suite.activeSurfaces?.mcp === false;
+            const credentialRefs = [...new Set([...refs, ...(diagnostic?.credentialRefs ?? [])])].sort();
+            // The declaration stays on the inventory when an override disables it:
+            // the panel shows what the suite ships and how the user changed it.
+            const disabled = !enabled || suite.activeSurfaces.mcp === false;
             const orphaned = disabled && tools.length > 0;
             // A duplicate copy shares the live serverName, so observed tools land
             // on it too — that does not make it connected: its own diagnostic says
@@ -74,6 +72,7 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
                 tools: disabled && !orphaned ? [] : tools.map(tool => ({ name: tool.name, ...(tool.description === undefined ? {} : { description: tool.description }) })),
                 advertisedTools: tools.length > 0,
                 retryable: diagnostic?.code === 'mount-failed' || diagnostic?.code === 'unmount-failed',
+                ...(effective.type === 'stdio' || effective.auth !== undefined ? {} : { oauthDefault: true }),
                 ...(diagnostic?.code === undefined ? {} : { code: diagnostic.code }),
                 ...(reason === undefined ? {} : { reason }),
                 ...(credentialRefs.length === 0 ? {} : { credentialRefs })

package/lib/runtime/mount-lifecycle.js

@@ -0,0 +1,73 @@
+/**
+ * Shared mount lifecycle: the pass queue and the bounded retry schedule that
+ * every surface registry runs on top of its own mount/unmount semantics. Which
+ * failures are worth retrying stays the surface's own decision; only the timing
+ * and the bookkeeping live here.
+ */
+/** A pass failure reaches the caller's promise, so the queue tail stays usable. */
+const swallow = () => undefined;
+/** Serializes reconcile passes: each pass starts after the previous one settles. */
+export class SerialPassQueue {
+    tail = Promise.resolve();
+    /** Queue one pass behind the in-flight one, so a disable cannot race an in-flight spawn. */
+    run(pass) {
+        const run = this.tail.then(pass);
+        this.tail = run.then(swallow, swallow);
+        return run;
+    }
+}
+/**
+ * Bounded retry schedule for a failed mount/unmount. The cap keeps a
+ * crash-looping or permanently broken server from consuming attempt budget
+ * forever, and the count resets with every reconcile pass.
+ */
+const RETRY_SCHEDULE_MS = [1_500, 5_000, 15_000, 45_000, 120_000];
+const MAX_RETRY_ATTEMPTS = RETRY_SCHEDULE_MS.length;
+/** Delayed re-attempts for a mount that is not live yet, keyed by mount key. */
+export class RetryScheduler {
+    options;
+    /** Pending retry timers keyed by mount key, so a teardown can cancel them. */
+    timers = new Map();
+    /** Attempt count per mount key, dropped when its target stops being retryable. */
+    attempts = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Arm the retry for one failed mount, replacing any timer already pending for
+     * its key. A target carrying no reason is a deterministic skip rather than a
+     * transient failure: it drops that key's budget and cancels its timer.
+     */
+    schedule(target) {
+        const pending = this.timers.get(target.key);
+        if (pending !== undefined)
+            clearTimeout(pending);
+        this.timers.delete(target.key);
+        if (target.reason === undefined) {
+            this.attempts.delete(target.key);
+            return;
+        }
+        const attempt = (this.attempts.get(target.key) ?? 0) + 1;
+        this.attempts.set(target.key, attempt);
+        if (attempt > MAX_RETRY_ATTEMPTS) {
+            this.options.log(`${target.label}: giving up after ${MAX_RETRY_ATTEMPTS} attempts — ${target.reason}`);
+            return;
+        }
+        const delay = RETRY_SCHEDULE_MS[attempt - 1] ?? RETRY_SCHEDULE_MS[RETRY_SCHEDULE_MS.length - 1];
+        const timer = setTimeout(() => {
+            this.timers.delete(target.key);
+            // Replay the surface's last known input: a retry must not resurrect a
+            // server that has since been disabled or uninstalled.
+            void this.options.replay().catch(() => { });
+        }, delay);
+        timer.unref?.();
+        this.timers.set(target.key, timer);
+    }
+    /** Cancel every pending retry and drop all attempt budgets. */
+    clear() {
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+        this.attempts.clear();
+    }
+}

package/lib/runtime/profile-seam.js

@@ -0,0 +1,321 @@
+/**
+ * Legacy profile LSP layer: detection and one-action removal.
+ *
+ * Releases before the plugin provisioned LSP itself told users to expose the
+ * capability from their profile — a `cordis.patch.yml` `insert` row for
+ * `@deepseek-ai/dsh-lsp` and `@deepseek-ai/dsh-tool-lsp`, anchored by profile
+ * dependencies on the packages. `LspMountRegistry` now mounts both seams from
+ * this plugin's own aligned copies, so that layer registers a second `lsp`
+ * service and the mount fails with `seam-conflict`.
+ *
+ * The plugin cannot drop the layer by patching: a profile's own patch file is
+ * applied *after* every bundle layer, so this package's patch can never
+ * disable the row. The user has to remove it, and that is the whole job here:
+ * find the profile, and edit out exactly those rows.
+ *
+ * Editing happens on a file the user wrote by hand, so the rules are
+ * conservative: the YAML document model preserves comments and unknown keys,
+ * the rewrite is verified against an independently computed result before it
+ * lands, and the previous content is kept beside it. Nothing else is touched —
+ * a profile's `dependencies` stay as they are, because dropping a dependency
+ * means running pnpm and this module never spawns anything.
+ *
+ * All paths come from `node:path` and all file work from `node:fs/promises`
+ * plus the harness atomic-write helper, so the same code runs on macOS, Linux
+ * and Windows; no shell, no path-separator assumption.
+ */
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isMap, isNode, isScalar, isSeq, parseDocument } from 'yaml';
+import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
+import { resolveDshHome } from '../catalog/paths.js';
+/** Every package the plugin provisions for LSP, in declaration order. */
+export const LSP_PACKAGE_SPECIFIERS = ['@deepseek-ai/dsh-lsp', '@deepseek-ai/dsh-lsp-stdio', '@deepseek-ai/dsh-tool-lsp'];
+/**
+ * The specifiers whose `insert` row registers a seam this plugin now owns.
+ * The stdio provider is excluded: it publishes no service, so a row for it
+ * cannot conflict.
+ */
+const SEAM_SPECIFIERS = new Set(['@deepseek-ai/dsh-lsp', '@deepseek-ai/dsh-tool-lsp']);
+/** The profile patch filename the harness reads; part of the profile contract. */
+const PROFILE_PATCH_FILENAME = 'cordis.patch.yml';
+/** Default patch-file lifecycle when a profile manifest omits `dsh.profile.patchReload`. */
+const DEFAULT_PATCH_RELOAD = 'live';
+/**
+ * Find every profile that still registers a legacy LSP seam.
+ *
+ * Best effort by design: profile files are the user's, so a directory that
+ * cannot be read or a patch file that does not parse is skipped rather than
+ * failing the status surface that calls this.
+ * @param home - the Harness home; defaults to `$DSH_HOME` or `~/.dsh`.
+ * @returns each matching profile, ordered by profile name.
+ */
+export async function findLegacyLspSeams(home = resolveDshHome()) {
+    const profilesDir = join(home, 'profiles');
+    let entries;
+    try {
+        entries = await readdir(profilesDir);
+    }
+    catch {
+        return [];
+    }
+    const found = [];
+    for (const name of entries.sort()) {
+        // `node_modules` is the installation fallback sibling, not a profile, and
+        // dot-directories hold launcher bookkeeping or the user's own backups.
+        if (name === 'node_modules' || name.startsWith('.'))
+            continue;
+        const dir = join(profilesDir, name);
+        try {
+            if (!(await stat(dir)).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const seam = await inspectProfile(name, dir);
+        if (seam !== undefined)
+            found.push(seam);
+    }
+    return found;
+}
+/** Read one profile directory and report its legacy layer, or undefined when it has none. */
+async function inspectProfile(profile, dir) {
+    const patchPath = join(dir, PROFILE_PATCH_FILENAME);
+    let text;
+    try {
+        text = await readFile(patchPath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    const document = parseDocument(text);
+    if (document.errors.length > 0)
+        return undefined;
+    const rows = seamRows(document);
+    const manifest = await readManifest(join(dir, 'package.json'));
+    // Only a row (or a bundle layer) claims a seam. A bare dependency cannot
+    // register anything, so a profile that lists the packages but inserts no row
+    // is not the cause of a conflict and stays out of the report.
+    if (rows.length === 0 && manifest.bundles.length === 0)
+        return undefined;
+    return { profile, dir, patchPath, rows, bundles: manifest.bundles, dependencies: manifest.dependencies, patchReload: manifest.patchReload };
+}
+/**
+ * Remove one profile's legacy LSP rows.
+ *
+ * The file is re-read here rather than trusting the caller's snapshot, so a
+ * migration always edits the current on-disk content. The rewrite is verified
+ * before it lands and the pre-edit content is written beside it first, so a
+ * failure leaves the profile exactly as it was.
+ * @param seam - a profile previously returned by {@link findLegacyLspSeams}.
+ * @param now - timestamp used in the backup filename; injectable for tests.
+ * @returns what was removed and where the backup went.
+ * @throws Error when the profile no longer carries a removable row, or the rewrite does not verify.
+ */
+export async function migrateLegacyLspSeam(seam, now = new Date()) {
+    let original;
+    try {
+        original = await readFile(seam.patchPath, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`cannot read the profile patch file ${seam.patchPath}: ${messageOf(error)}`, { cause: error });
+    }
+    const document = parseDocument(original);
+    if (document.errors.length > 0) {
+        throw new Error(`the profile patch file ${seam.patchPath} does not parse: ${document.errors[0]?.message ?? 'unknown error'}`);
+    }
+    const removed = stripSeamRows(document);
+    if (removed.length === 0)
+        throw new Error(`the profile ${seam.profile} no longer registers an LSP layer; reload the panel and try again`);
+    const next = document.toString();
+    assertStripped(original, next);
+    const mode = await fileMode(seam.patchPath);
+    const backupPath = `${seam.patchPath}.bak-lsp-seam-${stamp(now)}`;
+    await writeFileAtomic(backupPath, original, { mode });
+    await writeFileAtomic(seam.patchPath, next, { mode });
+    return { profile: seam.profile, patchPath: seam.patchPath, backupPath, removed, restartRequired: seam.patchReload !== 'live' };
+}
+/**
+ * Drop every `insert` entry naming a seam package, in place.
+ * A patch entry whose whole `insert` list is consumed leaves the document when
+ * nothing else remains — the entry existed only to insert.
+ * @returns the removed rows, in file order.
+ */
+function stripSeamRows(document) {
+    const removed = [];
+    for (const item of rootItems(document)) {
+        const container = mapNode(item, 'insert');
+        if (!isSeq(container))
+            continue;
+        const entries = container.items;
+        const keep = [];
+        for (const entry of entries) {
+            const name = mapText(entry, 'name');
+            if (name !== undefined && SEAM_SPECIFIERS.has(name)) {
+                removed.push({ id: mapText(entry, 'id') ?? '', name });
+                continue;
+            }
+            keep.push(entry);
+        }
+        if (keep.length === entries.length)
+            continue;
+        if (keep.length > 0) {
+            container.items = keep;
+            continue;
+        }
+        // The `- insert:` form carries no other key, so the entry goes with its
+        // list; the `- id: <group>` form configures a group and stays.
+        if (isMap(item) && item.items.length > 1) {
+            item.delete('insert');
+            continue;
+        }
+        const root = document.contents;
+        if (isSeq(root))
+            root.items = root.items.filter(candidate => candidate !== item);
+    }
+    return removed;
+}
+/**
+ * Prove the rewrite removed exactly the seam rows and nothing else.
+ *
+ * The expected result is computed independently from the plain parsed data, so
+ * this compares two derivations rather than trusting the edit that produced
+ * one of them. A mismatch aborts before anything is written.
+ */
+function assertStripped(original, next) {
+    if (seamRows(parseDocument(next)).length !== 0)
+        throw new Error('the rewritten profile patch file still registers an LSP layer');
+    const before = parseDocument(original).toJS();
+    const after = parseDocument(next).toJS();
+    const expected = stripSeamEntriesFromData(before);
+    if (JSON.stringify(expected) !== JSON.stringify(after)) {
+        throw new Error('the rewritten profile patch file would change unrelated patch entries; remove the LSP rows by hand instead');
+    }
+}
+/** The same removal applied to plain parsed data, as the independent expectation. */
+function stripSeamEntriesFromData(data) {
+    if (!Array.isArray(data))
+        return data;
+    const result = [];
+    for (const entry of data) {
+        if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+            result.push(entry);
+            continue;
+        }
+        const record = entry;
+        if (!Array.isArray(record['insert'])) {
+            result.push(entry);
+            continue;
+        }
+        const keep = record['insert'].filter(item => {
+            if (typeof item !== 'object' || item === null || Array.isArray(item))
+                return true;
+            const name = item['name'];
+            return !(typeof name === 'string' && SEAM_SPECIFIERS.has(name));
+        });
+        if (keep.length === record['insert'].length) {
+            result.push(entry);
+            continue;
+        }
+        if (keep.length > 0) {
+            result.push({ ...record, insert: keep });
+            continue;
+        }
+        const rest = Object.entries(record).filter(([key]) => key !== 'insert');
+        if (rest.length > 0)
+            result.push(Object.fromEntries(rest));
+    }
+    return result;
+}
+/** Collect the `insert` rows that name one of {@link SEAM_SPECIFIERS}. */
+function seamRows(document) {
+    const found = [];
+    for (const item of rootItems(document)) {
+        const entries = sequenceItems(mapNode(item, 'insert'));
+        if (entries === undefined)
+            continue;
+        for (const entry of entries) {
+            const name = mapText(entry, 'name');
+            if (name === undefined || !SEAM_SPECIFIERS.has(name))
+                continue;
+            found.push({ id: mapText(entry, 'id') ?? '', name });
+        }
+    }
+    return found;
+}
+/** The root sequence of a patch document; empty when the file holds something else. */
+function rootItems(document) {
+    return sequenceItems(document.contents) ?? [];
+}
+/** Read a mapping key as a child node, or undefined when the node is not a mapping. */
+function mapNode(node, key) {
+    if (!isMap(node))
+        return undefined;
+    const value = node.get(key, true);
+    return isNode(value) ? value : undefined;
+}
+/** Read a mapping key that holds a string scalar. */
+function mapText(node, key) {
+    const value = mapNode(node, key);
+    return isScalar(value) && typeof value.value === 'string' ? value.value : undefined;
+}
+/** The items of a sequence node, or undefined when the node is not one. */
+function sequenceItems(node) {
+    return isSeq(node) ? node.items : undefined;
+}
+/** Read the manifest facts, treating an absent or malformed file as an empty profile. */
+async function readManifest(path) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return { bundles: [], dependencies: [], patchReload: DEFAULT_PATCH_RELOAD };
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        return { bundles: [], dependencies: [], patchReload: DEFAULT_PATCH_RELOAD };
+    }
+    const record = parsed;
+    const known = new Set(LSP_PACKAGE_SPECIFIERS);
+    const dependencies = [];
+    for (const field of ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']) {
+        const table = record[field];
+        if (typeof table !== 'object' || table === null || Array.isArray(table))
+            continue;
+        for (const name of Object.keys(table))
+            if (known.has(name) && !dependencies.includes(name))
+                dependencies.push(name);
+    }
+    const scope = objectAt(objectAt(record['dsh'], 'profile'));
+    const rawBundles = scope['bundles'];
+    const bundles = Array.isArray(rawBundles) ? rawBundles.filter((value) => typeof value === 'string' && known.has(value)) : [];
+    return { bundles, dependencies, patchReload: scope['patchReload'] === 'startup' ? 'startup' : DEFAULT_PATCH_RELOAD };
+}
+/** Read one nested object field, or an empty record when the value is not an object. */
+function objectAt(value, key) {
+    const target = key === undefined ? value : typeof value === 'object' && value !== null && !Array.isArray(value) ? value[key] : undefined;
+    return typeof target === 'object' && target !== null && !Array.isArray(target) ? target : {};
+}
+/** Preserve the patch file's permission bits; Windows reports a synthetic mode. */
+async function fileMode(path) {
+    try {
+        return (await stat(path)).mode & 0o777 || 0o644;
+    }
+    catch {
+        return 0o644;
+    }
+}
+/** A filename-safe local timestamp: no colons, so Windows accepts it. */
+function stamp(now) {
+    const pad = (value, width = 2) => String(value).padStart(width, '0');
+    return `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** One-line remediation shared by the mount diagnostic and the status payload. */
+export function describeLegacySeam(seam) {
+    const rows = seam.rows.map(row => (row.id === '' ? row.name : `${row.id} (${row.name})`)).join(', ');
+    return `profile "${seam.profile}" still inserts the LSP layer (${rows}) from ${seam.patchPath}`;
+}

package/lib/runtime/project-runtime.js

@@ -1,18 +1,19 @@
 import { CommandMountRegistry } from './commands-mounts.js';
+import { expandPluginPaths, pluginRootOf } from '../catalog/plugin-variables.js';
+import { suiteDataDir } from '../catalog/paths.js';
 import { McpMountRegistry } from './mcp-mounts.js';
 import { HooksMountRegistry } from './hooks-mounts.js';
-import { randomUUID } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { stripFrontmatter } from '../catalog/skills-parse.js';
 import { parseFrontmatterRecord } from './user-store.js';
 /** Mount under existing and newly created agents; the caller owns refresh and teardown. */
-export function mountProjectCommands(ctx, catalog, t) {
-    return mountProjectSurface(ctx, catalog, 'commands', scope => new CommandMountRegistry(scope, t));
+export function mountProjectCommands(ctx, catalog, t, dataRoot) {
+    return mountProjectSurface(ctx, catalog, 'commands', scope => new CommandMountRegistry(scope, t, dataRoot));
 }
 /** MCP uses a separate injected child so network startup cannot delay local commands. */
 export function mountProjectMcp(ctx, catalog, dataRoot) {
-    return mountProjectSurface(ctx, catalog, 'tools', (scope, agent) => {
-        const registry = new McpMountRegistry(scope, dataRoot, agent.session.id ?? randomUUID());
+    return mountProjectSurface(ctx, catalog, 'tools', scope => {
+        const registry = new McpMountRegistry(scope, dataRoot);
         registry.setBackendProvider(() => catalog.mcpBackend());
         return registry;
     });
@@ -22,14 +23,18 @@ export function mountProjectHooks(ctx, catalog) {
     return mountProjectSurface(ctx, catalog, ['shell', 'sessionProjections'], scope => new HooksMountRegistry(scope));
 }
 /** Kimi's startup skill and system-prompt declarations use the existing scoped prompt service. */
-export function mountSuiteInstructions(ctx, catalog) {
-    return mountProjectSurface(ctx, catalog, 'systemPrompt', scope => {
+export function mountSuiteInstructions(ctx, catalog, dataRoot) {
+    return mountProjectSurface(ctx, catalog, 'systemPrompt', (scope, agent) => {
         let text = '';
         const host = scope;
         const dispose = host.systemPrompt.section({ name: 'agent-plugins:instructions', order: 500, text: () => text });
         return {
             async reconcile(projectSuites) {
-                const result = await suiteInstructions([...(await catalog.enabledUserSuites()), ...projectSuites]);
+                const projectDir = agent.session.header.cwd;
+                const result = await suiteInstructions([...(await catalog.enabledUserSuites()), ...projectSuites], {
+                    ...(dataRoot === undefined ? {} : { dataRoot }),
+                    ...(projectDir === undefined ? {} : { projectDir })
+                });
                 text = result.text;
                 return result.errors;
             },
@@ -40,14 +45,22 @@ export function mountSuiteInstructions(ctx, catalog) {
         };
     }, true);
 }
-export async function suiteInstructions(suites) {
+export async function suiteInstructions(suites, paths = {}) {
     const chunks = [];
     const errors = [];
     for (const suite of suites) {
-        if (!suite.enabled || suite.activeSurfaces?.skills === false)
+        if (!suite.enabled || suite.activeSurfaces.skills === false)
             continue;
+        // Startup instructions are author-written suite text like any other
+        // surface: the paths they name have to resolve before the model reads them.
+        const root = pluginRootOf(suite);
+        const context = {
+            ...(root === undefined ? {} : { root, ...(paths.dataRoot === undefined ? {} : { data: suiteDataDir(paths.dataRoot, suite.sourceId, suite.id) }) }),
+            ...(paths.projectDir === undefined ? {} : { projectDir: paths.projectDir })
+        };
+        const expand = (text) => expandPluginPaths(text, context);
         if (suite.systemPrompt !== undefined)
-            chunks.push(suite.systemPrompt);
+            chunks.push(expand(suite.systemPrompt));
         if (suite.manifest.startupSkill === undefined)
             continue;
         const skill = suite.skills.find(skill => skill.name === suite.manifest.startupSkill);
@@ -59,9 +72,9 @@ export async function suiteInstructions(suites) {
             const content = await readFile(skill.file, 'utf8');
             if (parseFrontmatterRecord(content).disabled === true)
                 continue;
-            chunks.push(stripFrontmatter(content));
+            chunks.push(expand(stripFrontmatter(content)));
             if (suite.manifest.skillInstructions !== undefined)
-                chunks.push(suite.manifest.skillInstructions);
+                chunks.push(expand(suite.manifest.skillInstructions));
         }
         catch {
             errors.push({ suiteId: `${suite.sourceId}/${suite.id}`, reason: `startup skill ${skill.name} is unreadable` });
@@ -72,8 +85,9 @@ export async function suiteInstructions(suites) {
 function mountProjectSurface(ctx, catalog, service, create, withoutProject = false) {
     const host = ctx;
     const mounts = new Map();
+    const serviceLabel = typeof service === 'string' ? service : service.join(',');
     let disposed = false;
-    const warn = (error) => ctx.logger?.warn(`[dsh-agent-plugins-market] project ${service}: ${String(error)}`);
+    const warn = (error) => ctx.logger?.warn(`[dsh-agent-plugins-market] project ${serviceLabel}: ${String(error)}`);
     const attach = (agent) => {
         const cwd = agent.session.header.cwd;
         if (disposed || (cwd === undefined && !withoutProject) || mounts.has(agent))
@@ -101,7 +115,7 @@ function mountProjectSurface(ctx, catalog, service, create, withoutProject = fal
             scope.effect(() => async () => {
                 active = false;
                 await registry.disposeAll();
-            }, `dsh-agent-plugins-market: project ${service}`);
+            }, `dsh-agent-plugins-market: project ${serviceLabel}`);
             void refresh().catch(warn);
         });
         mounts.set(agent, { fiber, refresh: () => refresh() });
@@ -115,9 +129,12 @@ function mountProjectSurface(ctx, catalog, service, create, withoutProject = fal
     const unwatchDisposed = ctx.on('agent/disposed', ({ agent }) => {
         void detach(agent).catch(warn);
     });
-    const unwatchStart = ctx.on('agent/session-start', async ({ agent }) => {
+    const unwatchStart = ctx.on('agent/session-start', ({ agent }) => {
         attach(agent);
-        await mounts.get(agent)?.refresh();
+        // The refresh chain can reject — its queue body re-reads the project
+        // catalog — and the host emits this event without awaiting the listener,
+        // so an unhandled rejection here would surface at every session start.
+        void mounts.get(agent)?.refresh().catch(warn);
     });
     for (const agent of host.agents.list())
         attach(agent);

package/lib/runtime/reconcile-scheduler.js

@@ -0,0 +1,97 @@
+import { coalesce } from './timer-seat.js';
+/** Credential updates are batched for this long before one reconcile runs. */
+const CREDENTIAL_DEBOUNCE_MS = 150;
+export class ReconcileScheduler {
+    ctx;
+    runtime;
+    host;
+    disposed = false;
+    requested = false;
+    pass;
+    pendingCredentialRefs = new Set();
+    credentialFlush;
+    releaseCredentialUpdates;
+    constructor(ctx, runtime, host) {
+        this.ctx = ctx;
+        this.runtime = runtime;
+        this.host = host;
+        const eventHost = ctx;
+        // One reconcile per burst of credential updates: the host fires one event
+        // per reference, and every mount that reads them must see the whole set.
+        this.credentialFlush = coalesce(ctx, () => this.flushCredentialUpdates(), CREDENTIAL_DEBOUNCE_MS);
+        this.releaseCredentialUpdates =
+            eventHost.on?.('credentials/reference-updated', ref => {
+                this.pendingCredentialRefs.add(ref);
+                this.credentialFlush();
+            }) ?? (() => { });
+    }
+    /** Reconcile now, joining the pass in flight and remembering one follow-up for it. */
+    request() {
+        if (this.disposed)
+            return Promise.resolve();
+        this.requested = true;
+        this.pass ??= (async () => {
+            try {
+                do {
+                    this.requested = false;
+                    await this.reconcileOnce();
+                } while (this.requested && !this.disposed);
+            }
+            finally {
+                this.pass = undefined;
+            }
+        })();
+        return this.pass;
+    }
+    /** Stop scheduling; later events are dropped. */
+    dispose() {
+        this.disposed = true;
+        this.releaseCredentialUpdates();
+        this.credentialFlush.dispose();
+        this.pendingCredentialRefs.clear();
+    }
+    async reconcileOnce() {
+        try {
+            const suites = await this.host.enabledSuites();
+            if (this.disposed)
+                return;
+            const diagnostics = await this.runtime.reconcile(suites);
+            this.host.publishMcpDiagnostics(diagnostics.mcp);
+            for (const diagnostic of diagnostics.mcp) {
+                this.ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" mcp server "${diagnostic.serverKey}": ${diagnostic.reason}`);
+            }
+            for (const diagnostic of diagnostics.lsp) {
+                this.ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" lsp server "${diagnostic.serverKey}": ${diagnostic.reason}`);
+            }
+            for (const diagnostic of diagnostics.commands) {
+                if (diagnostic.reason !== '')
+                    this.ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" command "${diagnostic.command}": ${diagnostic.reason}`);
+            }
+            for (const diagnostic of diagnostics.hooks) {
+                this.ctx.logger?.warn(`[dsh-agent-plugins-market] suite "${diagnostic.suiteId}" hooks: ${diagnostic.reason}`);
+            }
+            for (const error of diagnostics.errors) {
+                this.ctx.logger?.warn(`[dsh-agent-plugins-market] ${error.surface} reconcile failed: ${error.reason}`);
+            }
+        }
+        catch (error) {
+            this.ctx.logger?.warn(`[dsh-agent-plugins-market] runtime reconcile failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw error;
+        }
+    }
+    /**
+     * Coalesce credential updates: the debounce collapses a burst into one pass,
+     * and the pending refs are kept until that pass runs, so an update arriving
+     * mid-reconcile is never dropped.
+     */
+    flushCredentialUpdates() {
+        const refs = [...this.pendingCredentialRefs];
+        this.pendingCredentialRefs.clear();
+        // Re-read the catalog first: an unknown ref means the snapshot predates
+        // this change, so reconcile anyway to refresh the known reference set.
+        void this.request().catch(() => { });
+        if (refs.length > 0) {
+            this.ctx.logger?.info?.(`[dsh-agent-plugins-market] reconciling after credential update: ${refs.join(', ')}`);
+        }
+    }
+}

package/lib/runtime/reconciler.js

@@ -12,9 +12,10 @@ export class RuntimeReconciler {
     disposed = false;
     constructor(ctx, dataRoot, t = bindHostLocale(undefined)) {
         this.mcp = new McpMountRegistry(ctx, dataRoot);
-        this.commands = new CommandMountRegistry(ctx, t);
+        this.commands = new CommandMountRegistry(ctx, t, dataRoot);
         this.hooks = new HooksMountRegistry(ctx);
         this.lspRegistry = new LspMountRegistry(ctx);
+        this.lspRegistry.setPluginDataRoot(dataRoot);
     }
     /** The LSP mount registry, consumed by the LSP status surface. */
     get lsp() {
@@ -40,6 +41,10 @@ export class RuntimeReconciler {
     forceMcpRemount(suiteId, serverKey) {
         this.mcp.forceRemount(suiteId, serverKey);
     }
+    /** Flag every live MCP mount for a rebuild on the next reconcile. */
+    forceMcpRemountAll() {
+        this.mcp.forceRemountAll();
+    }
     /** The mount key owning one derived serverName; undefined when not mounted here. */
     mcpServerOwner(serverName) {
         return this.mcp.serverOwner(serverName);