dsh-agent-plugins-market 0.7.0 → 0.7.1

package/lib/application/catalog-context.js

@@ -8,6 +8,7 @@
  * notification path — have a single owner.
  */
 import { join } from 'node:path';
+import { MARKET_SETTINGS_DEFAULTS } from '../contracts/settings.js';
 import { STATE_FILE_NAME } from '../catalog/paths.js';
 import { settlesWithin } from '../runtime/deadline.js';
 import { EMPTY_STATE, loadState, saveState } from '../runtime/state-store.js';
@@ -27,7 +28,13 @@ export class CatalogContext {
     mutationQueue = Promise.resolve();
     currentRevision = 0;
     currentScanGeneration = 0;
-    scanProjectLayoutsEnabled = false;
+    /**
+     * The project-layout switch in effect. The host settings document owns the
+     * value and pushes it here on registration and on every change; the initial
+     * value is the contract's declared default, which is what the catalog would
+     * read from the document before the settings service resolves.
+     */
+    scanProjectLayoutsEnabled = MARKET_SETTINGS_DEFAULTS.scanProjectLayouts;
     /** The derived refresh in flight, shared by every change that lands while it runs. */
     refreshPass;
     /** Whether a change landed after the running pass started; it earns one more pass. */

package/lib/application/catalog.js

@@ -48,6 +48,10 @@ export class Catalog {
     get userRoot() {
         return this.context.userRoot;
     }
+    /** The plugin storage root holding per-suite `${PLUGIN_DATA}` directories and overrides. */
+    get dataRoot() {
+        return this.context.dataRoot;
+    }
     get sources() {
         return this.context.state.sources;
     }
@@ -238,6 +242,15 @@ export class Catalog {
     async setMcpOverride(sourceId, suiteId, serverKey, override) {
         await this.mcp.setOverride(sourceId, suiteId, serverKey, override);
     }
+    /**
+     * Enable or disable one declared MCP server, addressed by the same
+     * source-qualified suite id its status row carries. Disabling writes an
+     * override rather than editing the suite's `mcp.json`, so a refresh cannot
+     * clobber the user's choice.
+     */
+    async setMcpServerEnabled(suiteKey, serverKey, enabled) {
+        await this.mcp.setServerEnabled(suiteKey, serverKey, enabled);
+    }
     /** Re-run the MCP reconcile pass without changing any catalog state. */
     async retryMounts() {
         await this.mcp.retryMounts();

package/lib/application/details.js

@@ -1,5 +1,5 @@
 /** Suite detail and preview projections owned by the application layer. */
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import { parse as parseYaml } from 'yaml';
 import { discoverLspEntries } from '../catalog/surfaces.js';
 import { defaultMarkdownResources, resourceText } from '../catalog/component-files.js';
@@ -7,6 +7,16 @@ import { credentialRefsInServer } from '../runtime/mcp-config.js';
 import { redactMcpConfig, redactMcpOverrides } from '../runtime/mcp-redaction.js';
 import { applyOverride } from '../runtime/mcp-overrides.js';
 import { effectiveSurfaces } from '../model/types.js';
+/** The checkout's last modification, or null when the path cannot be read. */
+async function rootModifiedAt(root) {
+    try {
+        const stats = await stat(root);
+        return new Date(stats.mtimeMs).toISOString();
+    }
+    catch {
+        return null;
+    }
+}
 /** Build the detail response for one normalized suite. */
 export async function buildSuiteDetail(suite, installed, diagnostics, mcpOverrides = {}) {
     const remoteUrl = suite.remote?.url;
@@ -18,6 +28,7 @@ export async function buildSuiteDetail(suite, installed, diagnostics, mcpOverrid
         description: suite.manifest.description ?? null,
         author: suite.manifest.author ?? null,
         keywords: suite.manifest.keywords ?? [],
+        updatedAt: await rootModifiedAt(suite.root),
         layout: suite.manifest.layout,
         dimension: suite.dimension,
         root: remoteUrl ?? suite.root,
@@ -66,7 +77,7 @@ export async function readSkillContent(suite, skillName) {
         content = await readFile(skill.file, 'utf8');
     }
     catch (error) {
-        throw new Error(`skill file unreadable: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`skill file unreadable: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
     }
     return { name: skill.name, description: skill.description, content, path: skill.file };
 }

package/lib/application/mcp-service.js

@@ -139,8 +139,25 @@ export class McpService {
             }
             await saveSuiteOverrides(this.context.dataRoot, suiteKey, overrides);
             await this.context.notifyChanged(true);
+            // The status surface reads the live tool registry, so an immediate read
+            // races the reconciler's teardown: a just-disabled server still carries
+            // its observed tools and reports the orphaned state with its switch on
+            // until the pass finishes. Joining the pass here is bounded — one stuck
+            // mount costs the request its deadline, never the plugin.
+            await this.context.refreshSettled();
         });
     }
+    /**
+     * Enable or disable one declared server, addressed by the source-qualified
+     * suite id the status rows carry. The qualified id is split here rather than
+     * by callers so the separator stays a server-side detail.
+     */
+    async setServerEnabled(suiteKey, serverKey, enabled) {
+        const separator = suiteKey.indexOf('/');
+        if (separator <= 0)
+            throw new Error(`invalid suite id "${suiteKey}"`);
+        await this.setOverride(suiteKey.slice(0, separator), suiteKey.slice(separator + 1), serverKey, { enabled });
+    }
     /**
      * Re-run the MCP reconcile pass: retries failed mounts and clears residual
      * tools, without changing any catalog state.

package/lib/application/panel-resources.js

@@ -1,8 +1,9 @@
 /** Installed suite and user resources share one inventory; paths never come from HTTP callers. */
-import { realpath, unlink } from 'node:fs/promises';
+import { realpath, stat, unlink } from 'node:fs/promises';
 import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
 import { defaultMarkdownResources, resourceText } from '../catalog/component-files.js';
-import { isWithin } from '../catalog/paths.js';
+import { pluginRootOf } from '../catalog/plugin-variables.js';
+import { isWithin, suiteDataDir } from '../catalog/paths.js';
 import { stripFrontmatter } from '../catalog/skills-parse.js';
 import { parseFrontmatterRecord } from '../runtime/user-store.js';
 /**
@@ -68,11 +69,22 @@ class PanelResources {
                     rawText,
                     content: stripFrontmatter(rawText),
                     path: file,
-                    description: typeof metadata.description === 'string' ? metadata.description : ''
+                    description: typeof metadata.description === 'string' ? metadata.description : '',
+                    ...(pluginRootOf(suite) === undefined ? {} : { suiteRoot: suite.root, suiteData: suiteDataDir(this.catalog.dataRoot, suite.sourceId, suite.id) })
                 });
             }
         }
-        return entries;
+        // One pass stamps each entry's own last modification: the panel reads every
+        // file's text anyway, and both origins get the same treatment here.
+        return await Promise.all(entries.map(async (entry) => {
+            try {
+                const stats = await stat(entry.path);
+                return { ...entry, updatedAt: new Date(stats.mtimeMs).toISOString() };
+            }
+            catch {
+                return entry;
+            }
+        }));
     }
     async get(id) {
         return (await this.list()).find(entry => (entry.id ?? entry.name) === id);

package/lib/application/project-agent-roles.js

@@ -1,5 +1,7 @@
 /** Resolve read-only project roles from the calling session, never from tool-supplied paths. */
 import { defaultMarkdownResources, resourceText } from '../catalog/component-files.js';
+import { pluginRootOf } from '../catalog/plugin-variables.js';
+import { suiteDataDir } from '../catalog/paths.js';
 import { parseAgentRole } from '../runtime/agent-role-router.js';
 export async function projectAgentRoles(catalog, parent) {
     const cwd = parent?.session?.header?.cwd;
@@ -10,6 +12,8 @@ export async function projectAgentRoles(catalog, parent) {
     for (const suite of snapshot.enabledSuites) {
         if (suite.activeSurfaces.agents === false)
             continue;
+        const suiteRoot = pluginRootOf(suite);
+        const suiteData = suiteRoot === undefined ? undefined : suiteDataDir(catalog.dataRoot, suite.sourceId, suite.id);
         for (const resource of suite.resources?.agents ?? (await defaultMarkdownResources(suite.root, 'agents'))) {
             const path = resource.file;
             const rawText = await resourceText(resource).catch(error => {
@@ -27,7 +31,9 @@ export async function projectAgentRoles(catalog, parent) {
                     rawText,
                     title: policy.title ?? resource.name.replace(/\.agent$/, ''),
                     description: policy.description ?? `${suite.manifest.name}: ${resource.name}`,
-                    disabled: policy.disabled
+                    disabled: policy.disabled,
+                    ...(suiteRoot === undefined ? {} : { suiteRoot }),
+                    ...(suiteData === undefined ? {} : { suiteData })
                 });
             }
             catch {

package/lib/catalog/archive.js

@@ -269,7 +269,7 @@ async function assertBoundedTree(root) {
                 stack.push(path);
                 continue;
             }
-            let size = 0;
+            let size;
             try {
                 size = (await stat(path)).size;
             }

package/lib/catalog/paths.js

@@ -93,6 +93,14 @@ export function sourceCheckoutDir(dimensionRoot, sourceId) {
 export function qualifiedSuiteId(sourceId, suiteId) {
     return `${sourceId}/${suiteId}`;
 }
+/**
+ * The data directory `${PLUGIN_DATA}` resolves to for one suite: a
+ * source-qualified directory under the plugin storage root, shared by every
+ * surface of that suite so MCP servers, skills and commands see one location.
+ */
+export function suiteDataDir(dataRoot, sourceId, suiteId) {
+    return `${dataRoot.replace(/[\\/]$/, '')}/${qualifiedSuiteId(sourceId, suiteId)}`;
+}
 /**
  * Whether `candidate` is `root` itself or a path below it, compared on whole
  * path segments by `flavor`'s rules so a sibling whose name merely starts with

package/lib/catalog/plugin-variables.js

@@ -0,0 +1,38 @@
+/**
+ * Path-variable expansion for author-written suite text.
+ *
+ * A suite authored for Claude Code or its dialects writes `${CLAUDE_PLUGIN_ROOT}`
+ * (or the dialect's own spelling) into command bodies, agent personas, hook
+ * commands, LSP declarations, startup instructions and skill prose, and uses
+ * `${CLAUDE_PLUGIN_DATA}`, `${CLAUDE_PROJECT_DIR}` and `${CLAUDE_SKILL_DIR}` the
+ * same way. Its home ecosystem replaces those variables before the text reaches
+ * the model or a process; every surface here has to do the same, or the command
+ * runs with an empty path. One implementation keeps the surfaces agreeing on
+ * what each spelling means.
+ *
+ * A variable whose value the calling layer does not hold is left exactly as
+ * written: an author's `${NAME:-default}`-style intent is never silently
+ * emptied, and a surface that cannot supply a session directory does not
+ * invent one.
+ */
+import { PLUGIN_DATA_VARIABLES, PLUGIN_ROOT_VARIABLES, PROJECT_DIR_VARIABLES, SKILL_DIR_VARIABLE } from '../model/layouts.js';
+/** The suite root `${PLUGIN_ROOT}` and its dialect aliases resolve to. */
+export function pluginRootOf(suite) {
+    // Project-native directories are the repository's own files, read in place;
+    // no plugin root exists for them, so the variable stays as the author wrote it.
+    return suite.manifest.layout === 'project-native' ? undefined : suite.root;
+}
+/** Replace every path variable the context can resolve; other text stays exactly as written. */
+export function expandPluginPaths(text, context) {
+    return text.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (match, name) => {
+        if (PLUGIN_ROOT_VARIABLES.has(name))
+            return context.root ?? match;
+        if (PLUGIN_DATA_VARIABLES.has(name))
+            return context.data ?? match;
+        if (name === SKILL_DIR_VARIABLE)
+            return context.skillDir ?? match;
+        if (PROJECT_DIR_VARIABLES.has(name))
+            return context.projectDir ?? match;
+        return match;
+    });
+}

package/lib/catalog/project-hooks.js

@@ -11,6 +11,19 @@ function object(value) {
 function declarationText(value) {
     return String(value);
 }
+/**
+ * Present one read document as the settings shape the shared validator reads:
+ * a standalone hook file may carry the bare event table instead of a `hooks`
+ * key. A recognized top-level event name is the marker — a document with no
+ * event name at the top stays verbatim, so an ordinary settings file missing
+ * `hooks` is still not accepted as a bare event table.
+ */
+function settingsDocument(settings, format) {
+    if (format !== 'claude' || settings.hooks !== undefined)
+        return settings;
+    const isEventTable = Object.keys(settings).some(key => EVENTS.has(key));
+    return isEventTable ? { ...settings, hooks: settings } : settings;
+}
 /** Merge settings layers additively, deduplicating identical event/matcher/command triples. */
 export async function discoverProjectHooks(projectRoot, files, errors, format = 'claude') {
     const documents = [];
@@ -19,7 +32,7 @@ export async function discoverProjectHooks(projectRoot, files, errors, format =
         if (settings === null)
             return undefined;
         if (settings !== undefined)
-            documents.push({ file, settings });
+            documents.push({ file, settings: settingsDocument(settings, format) });
     }
     return normalizeHookDocuments(projectRoot, documents, errors, format);
 }

package/lib/catalog/skills-parse.js

@@ -99,6 +99,53 @@ export function parseSkillFrontmatter(text, expectedName) {
         }
     };
 }
+/** Frontmatter record for the panel's host-parity check, or the reason the YAML is unusable. */
+function strictSkillRecord(text) {
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text)?.[1];
+    if (frontmatter === undefined)
+        return 'missing YAML frontmatter';
+    let raw;
+    try {
+        raw = parseYaml(frontmatter);
+    }
+    catch {
+        return 'invalid YAML frontmatter';
+    }
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        return 'frontmatter is not an object';
+    return raw;
+}
+/**
+ * Rejection for a user skill document the harness's own `dsh-skill-filesystem`
+ * reader would drop from `~/.agents/skills`, or `undefined` when that reader
+ * accepts it.
+ *
+ * The two readers share the directory, so the panel publishes only documents
+ * both accept: a listed entry never becomes a skill that loads in a
+ * market-equipped session alone. The checks mirror the shipped reader rather
+ * than the lenient suite scan — strict YAML, no display-name normalization,
+ * and a `name` the reader compares only against its kebab grammar.
+ * @returns the drop reason, phrased as the reader's own diagnostic.
+ */
+export function skillEntryRejection(text) {
+    const record = strictSkillRecord(text);
+    if (typeof record === 'string')
+        return record;
+    const name = record['name'];
+    const description = record['description'];
+    if (typeof name !== 'string' || name === '' || typeof description !== 'string' || description.trim() === '') {
+        return 'frontmatter requires name and description';
+    }
+    if (!isSkillName(name))
+        return `invalid skill name "${name}"`;
+    const disableModel = parseBoolean(record['disable-model-invocation']);
+    if (disableModel === undefined && record['disable-model-invocation'] !== undefined)
+        return 'invalid disable-model-invocation value';
+    const userInvocable = parseBoolean(record['user-invocable']);
+    if (userInvocable === undefined && record['user-invocable'] !== undefined)
+        return 'invalid user-invocable value';
+    return undefined;
+}
 /** Lenient frontmatter recovery for prose fields with embedded `: `. */
 function lenientFrontmatter(body) {
     const record = {};

package/lib/catalog/source-catalog.js

@@ -15,10 +15,15 @@ import { scanSource as scanSourceWithNotes } from './suite-scanner.js';
 import { discoverNativeProjectSuites } from './native-project.js';
 /** Discover suites from the selected configured or project checkouts. */
 export async function discoverSourceList(sources, dimension, dimensionRoot) {
-    return (await discoverSourceListWithNotes(sources, dimension, dimensionRoot)).suites;
+    return (await discoverSourceListWithNotes(sources, dimension, dimensionRoot, true)).suites;
 }
-/** Discover suites plus per-source scan diagnostics for one dimension. */
-export async function discoverSourceListWithNotes(sources, dimension, dimensionRoot, scanProjectLayouts = false) {
+/**
+ * Discover suites plus per-source scan diagnostics for one dimension.
+ * @param scanProjectLayouts - whether the project's own native Agent directories
+ *   join the scan. Required on purpose: the switch has one owner (the host
+ *   settings document), so a default here would be a second copy of it.
+ */
+export async function discoverSourceListWithNotes(sources, dimension, dimensionRoot, scanProjectLayouts) {
     const checkoutRoot = sourcesDir(dimensionRoot);
     const listed = new Set(sources.map(source => source.id));
     const checkouts = sources.map(source => ({

package/lib/catalog/suite-components.js

@@ -4,7 +4,7 @@ import { relative } from 'node:path';
 import { componentDocuments, componentPath, firstComponentFile, isRecord, isStringArray, isUnknownArray } from './component-files.js';
 import { parseLspServers } from './lsp-spec.js';
 import { normalizeHookDocuments } from './project-hooks.js';
-import { PLUGIN_ROOT_VARIABLES } from '../model/layouts.js';
+import { expandPluginPaths } from './plugin-variables.js';
 export async function discoverSuiteLsp(root, manifest, errors) {
     const declaration = manifest.components?.lspServers;
     const fallback = await firstComponentFile(root, manifest.layout === 'github-copilot' || manifest.layout === 'universal' ? ['lsp.json', '.github/lsp.json', 'lsp-config/servers.json', '.lsp.json'] : ['.lsp.json', 'lsp.json']);
@@ -22,7 +22,7 @@ function quote(argument) {
     return `'${argument.replaceAll("'", "'\\''")}'`;
 }
 function rootVariables(text, root) {
-    return text.replace(/\$\{([A-Z_]+)\}/g, (match, name) => (PLUGIN_ROOT_VARIABLES.has(name) ? root : match));
+    return expandPluginPaths(text, { root });
 }
 const EVENT_ALIASES = {
     sessionStart: 'SessionStart',

package/lib/contracts/market.js

@@ -28,6 +28,7 @@ export const MARKET_ROUTES = {
     setSurface: `${MARKET_API_PREFIX}set-surface`,
     mcpOverrides: `${MARKET_API_PREFIX}mcp-overrides`,
     setMcpOverride: `${MARKET_API_PREFIX}set-mcp-override`,
+    setMcpServerEnabled: `${MARKET_API_PREFIX}set-mcp-server-enabled`,
     mcpRetry: `${MARKET_API_PREFIX}mcp-retry`,
     mcpReauthorize: `${MARKET_API_PREFIX}mcp-reauthorize`,
     mcpBackend: `${MARKET_API_PREFIX}mcp-backend`,

package/lib/contracts/settings.js

@@ -0,0 +1,63 @@
+/**
+ * Browser-safe settings contract of the market's host settings namespace: the
+ * namespace key, the fields with their defaults, and the one reader that turns
+ * a stored section into resolved values.
+ *
+ * The defaults live here and nowhere else. The namespace schema declares them
+ * to the host, the node half reads them back through {@link resolveMarketSettings},
+ * and the browser half — which cannot import `src/runtime` — reads the same
+ * resolved values off the settings snapshot it is handed. Changing a default is
+ * therefore a one-line edit in this module.
+ *
+ * @module contracts/settings
+ */
+/** Settings namespace this plugin registers; the key the plugin-config tab pairs our card by. */
+export const MARKET_SETTINGS_NAMESPACE = 'dsh-agent-plugins-market';
+/**
+ * The default of every market setting — the single place one is written.
+ *
+ * These are user-visible behavior: a flip here is a behavior change that ships
+ * with its documentation, not a private implementation detail.
+ */
+export const MARKET_SETTINGS_DEFAULTS = {
+    mcpEnhanced: true,
+    scanProjectLayouts: false,
+    downloadRegion: 'auto',
+    feedbackEnabled: true,
+    autoUpdateSources: false
+};
+/**
+ * Narrow an untrusted stored region to a setting; anything else reads as the
+ * declared default.
+ * @param value - the stored `downloadRegion` value.
+ * @param fallback - the value an unrecognized input reads as.
+ */
+export function narrowDownloadRegion(value, fallback = MARKET_SETTINGS_DEFAULTS.downloadRegion) {
+    return value === 'auto' || value === 'global' || value === 'china' ? value : fallback;
+}
+/** One boolean field: a stored boolean, else the field's default. */
+function narrowBoolean(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+/**
+ * Resolve a stored settings section the way the host resolves it: each field
+ * takes its stored value when it is one this field accepts, and its declared
+ * default otherwise.
+ *
+ * The host hands the resolved section back on its own, but not every caller has
+ * one — the plugin's own halves read a section they may not have received yet,
+ * and a test hands in a bare literal. Funnelling all of them through this
+ * function is what keeps a second reading of "what does missing mean" from
+ * growing somewhere else.
+ * @param section - the stored (or absent) namespace section, untrusted.
+ */
+export function resolveMarketSettings(section) {
+    const stored = (typeof section === 'object' && section !== null ? section : {});
+    return {
+        mcpEnhanced: narrowBoolean(stored['mcpEnhanced'], MARKET_SETTINGS_DEFAULTS.mcpEnhanced),
+        scanProjectLayouts: narrowBoolean(stored['scanProjectLayouts'], MARKET_SETTINGS_DEFAULTS.scanProjectLayouts),
+        downloadRegion: narrowDownloadRegion(stored['downloadRegion']),
+        feedbackEnabled: narrowBoolean(stored['feedbackEnabled'], MARKET_SETTINGS_DEFAULTS.feedbackEnabled),
+        autoUpdateSources: narrowBoolean(stored['autoUpdateSources'], MARKET_SETTINGS_DEFAULTS.autoUpdateSources)
+    };
+}

package/lib/index.js

@@ -4,7 +4,7 @@ import { RuntimeReconciler } from './runtime/reconciler.js';
 import { ReconcileScheduler } from './runtime/reconcile-scheduler.js';
 import { MarketSettingsNamespace } from './runtime/settings-namespace.js';
 import { deleteMcpAuthGrant } from './runtime/mcp-auth-record.js';
-import { inspectToolRegistry } from './runtime/tool-registry-observer.js';
+import { inspectToolRegistry, toolsServiceOf } from './runtime/tool-registry-observer.js';
 import { migratePluginStorage } from './runtime/storage-migration.js';
 import { mountAgentRoleTool } from './runtime/agent-role-router.js';
 import { projectAgentRoles } from './application/project-agent-roles.js';
@@ -13,9 +13,10 @@ import { createPanelResources } from './application/panel-resources.js';
 import { resolveAgentsRoot, resolveDataRoot, resolveUserRoot } from './catalog/paths.js';
 import { mountSuiteRoutes } from './routes.js';
 import { SuiteSkillProvider } from './runtime/skills-provider.js';
+import { shellSeamOf } from './runtime/dynamic-context.js';
 import { loadLspServers } from './runtime/lsp-direct-config.js';
 import { loadDisabledLspServers } from './runtime/lsp-server-state.js';
-import { bindHostLocale, loadHostLocale } from './runtime/host-locale.js';
+import { bindHostLocale, loadHostLocale, readHostLocalePreference, setHostLocaleSource } from './runtime/host-locale.js';
 import { createUserPanelStores } from './runtime/user-panels.js';
 import { SourceAutoUpdater } from './runtime/source-auto-update.js';
 import { UserPanelSkillProvider } from './runtime/user-panels.js';
@@ -34,10 +35,20 @@ export async function apply(ctx, config = {}) {
     // Host runtime copy resolves from the harness `locale.preference` setting;
     // the async settings read lands before the first session starts in practice.
     const hostLocale = { t: bindHostLocale(undefined) };
-    void loadHostLocale().then(locale => {
-        hostLocale.t = locale.t;
-        providerControl?.invalidate();
-        userPanelControl?.invalidate();
+    const refreshHostLocale = () => {
+        void loadHostLocale().then(locale => {
+            hostLocale.t = locale.t;
+            providerControl?.invalidate();
+            userPanelControl?.invalidate();
+        });
+    };
+    void refreshHostLocale();
+    // The locale preference the GUI writes is owned by the host settings service:
+    // read it there rather than re-parsing the document, and re-bind once the
+    // service lands (the locale namespace may register after this plugin).
+    ctx.inject(['settings'], settingsCtx => {
+        setHostLocaleSource(() => readHostLocalePreference(settingsCtx));
+        refreshHostLocale();
     });
     const runtime = new RuntimeReconciler(ctx, dataRoot, key => hostLocale.t(key));
     // User panel stores (skills / commands / agent personas) and their runtime
@@ -110,9 +121,10 @@ export async function apply(ctx, config = {}) {
     // port below is read at call time: this plugin's apply may run before the
     // credentials, tools and settings services provision, and a snapshot taken
     // here would be permanently undefined even after the service is live.
-    let toolsRegistry;
+    // Read at call time: the tools service provisions after apply() returns.
+    let toolsRegistry = toolsServiceOf(ctx);
     const ports = {
-        mcpToolSnapshot: () => (toolsRegistry === undefined ? [] : inspectToolRegistry(toolsRegistry)),
+        mcpToolSnapshot: () => inspectToolRegistry(toolsRegistry),
         credentialsStore: {
             deleteGrantRecord: async (serverName) => {
                 const store = ctx.get?.('credentials');
@@ -155,9 +167,12 @@ export async function apply(ctx, config = {}) {
         await scheduler.request();
     })
         .catch(() => { });
+    // The shell seam resolves lazily: the service may land after this plugin, and
+    // a profile without one keeps dynamic-context placeholders literal.
+    const shellSeam = () => shellSeamOf(ctx);
     ctx.skills.registerProvider(control => {
         providerControl = control;
-        return new SuiteSkillProvider(catalog);
+        return new SuiteSkillProvider(catalog, { dataRoot, shell: shellSeam });
     });
     // User panel skills ride a second provider so a panel
     // edit invalidates only its own catalog contribution.
@@ -173,10 +188,10 @@ export async function apply(ctx, config = {}) {
     });
     ctx.inject(['agents'], hostCtx => {
         hostCtx.effect(() => {
-            const mounted = mountProjectCommands(hostCtx, catalog, key => hostLocale.t(key));
+            const mounted = mountProjectCommands(hostCtx, catalog, key => hostLocale.t(key), dataRoot);
             const mcp = mountProjectMcp(hostCtx, catalog, dataRoot);
             const hooks = mountProjectHooks(hostCtx, catalog);
-            const prompts = mountSuiteInstructions(hostCtx, catalog);
+            const prompts = mountSuiteInstructions(hostCtx, catalog, dataRoot);
             projectCommands = mounted;
             projectMcp = mcp;
             projectHooks = hooks;

package/lib/model/layouts.js

@@ -15,6 +15,10 @@ export const MANIFEST_ALIASES = { kimi: ['kimi.plugin.json'] };
 /** Equivalent plugin-owned path variables; these never resolve as credentials. */
 export const PLUGIN_ROOT_VARIABLES = new Set(['PLUGIN_ROOT', 'CLAUDE_PLUGIN_ROOT', 'CODEX_PLUGIN_ROOT', 'ZCODE_PLUGIN_ROOT', 'QODER_PLUGIN_ROOT']);
 export const PLUGIN_DATA_VARIABLES = new Set(['PLUGIN_DATA', 'CLAUDE_PLUGIN_DATA', 'ZCODE_PLUGIN_DATA', 'QODER_PLUGIN_DATA']);
+/** Equivalent session project-directory variables; only a calling session supplies the directory. */
+export const PROJECT_DIR_VARIABLES = new Set(['CLAUDE_PROJECT_DIR', 'ZCODE_PROJECT_DIR', 'QODER_PROJECT_DIR']);
+/** Claude Code names the directory holding the skill's own file; no dialect alias exists. */
+export const SKILL_DIR_VARIABLE = 'CLAUDE_SKILL_DIR';
 export const PROJECT_LAYOUTS = [
     {
         dirName: '.claude',
@@ -23,7 +27,12 @@ export const PROJECT_LAYOUTS = [
         mcpFiles: ['.mcp.json'],
         hookFiles: ['.claude/settings.json', '.claude/settings.local.json']
     },
-    { dirName: '.agents', label: 'agents', subdirs: ['skills', 'agents', 'commands'] },
+    {
+        dirName: '.agents',
+        label: 'agents',
+        subdirs: ['skills', 'agents', 'commands'],
+        hookFiles: ['.agents/hooks/hooks.json', '.agents/hooks.json']
+    },
     { dirName: '.codex', label: 'Codex', subdirs: ['skills'], mcpFiles: ['.codex/config.toml'], mcpFormat: 'codex' },
     { dirName: '.cursor', label: 'Cursor', subdirs: ['skills', 'agents', 'commands'], mcpFiles: ['.cursor/mcp.json'] },
     { dirName: '.kimi', label: 'Kimi', subdirs: ['skills'] },

package/lib/routes.js

@@ -257,6 +257,18 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
         await manager.setMcpOverride(sourceId, suiteId, serverKey, sanitized ?? null);
         return {};
     });
+    // Enable or disable one declared MCP server. Addressed by the same
+    // source-qualified suite id the status rows carry, so the card can toggle a
+    // server without holding the source and suite ids apart.
+    post(MARKET_ROUTES.setMcpServerEnabled, async (body) => {
+        const suiteKey = textField(body['suiteId'] ?? '', 'MCP suite id');
+        const serverKey = textField(body['serverKey'] ?? '', 'MCP server key');
+        const enabled = body['enabled'];
+        if (typeof enabled !== 'boolean')
+            throw new Error('missing boolean enabled');
+        await manager.setMcpServerEnabled(suiteKey, serverKey, enabled);
+        return {};
+    });
     // Manual MCP reconcile: retries failed mounts and clears residual tools
     // without touching any catalog state.
     post(MARKET_ROUTES.mcpRetry, async () => {