dsh-agent-plugins-market 0.7.0 → 0.7.2

package/lib/catalog/manifests.js

@@ -23,7 +23,8 @@ import { join } from 'node:path';
 import { sanitizeId } from './paths.js';
 import { isFile } from './fs-probes.js';
 import { isRecord } from './component-files.js';
-import { isRecognizedSchema, validatePluginManifest } from './validate.js';
+import { formatSchemaErrors, isRecognizedSchema, validatePluginManifest } from './validate.js';
+import { EXTENSION_NAMESPACE, NAMESPACE_SCHEMA_VERSIONS, V1_IGNORED_MANIFEST_KEYS } from '../model/layouts.js';
 import { PLUGIN_LAYOUTS, MANIFEST_ALIASES, MARKETPLACE_PATHS } from '../model/layouts.js';
 /**
  * Every manifest file a directory carries, in selection order: highest
@@ -65,14 +66,20 @@ export function componentDeclarations(record) {
  * go to `fallbacks`, so the winner stays usable while the caller can still
  * report why the higher-priority declaration was ignored. The winner's own
  * diagnostics stay in `errors` and remain fatal.
+ *
+ * `notes` carries the winner's non-fatal diagnostics — §5.2 unknown
+ * top-level fields, §8.1 extension data problems. Callers surface them
+ * without failing the suite.
  */
-export async function readManifest(root, errors, hint, fallbacks = []) {
+export async function readManifest(root, errors, hint, fallbacks = [], notes = []) {
     const candidates = await detectManifests(root);
     for (const [index, candidate] of candidates.entries()) {
         const attempt = [];
-        const manifest = await readOneManifest(root, candidate, attempt, hint);
+        const attemptNotes = [];
+        const manifest = await readOneManifest(root, candidate, attempt, hint, attemptNotes);
         if (manifest !== undefined) {
             errors.push(...attempt);
+            notes.push(...attemptNotes);
             return manifest;
         }
         if (index === candidates.length - 1)
@@ -83,7 +90,7 @@ export async function readManifest(root, errors, hint, fallbacks = []) {
     return undefined;
 }
 /** Parse one manifest candidate; undefined when this candidate is unusable. */
-async function readOneManifest(root, candidate, errors, hint) {
+async function readOneManifest(root, candidate, errors, hint, notes = []) {
     let raw;
     try {
         raw = JSON.parse(await readFile(candidate.path, 'utf8'));
@@ -130,21 +137,47 @@ async function readOneManifest(root, candidate, errors, hint) {
             }
         }
     }
-    const problems = kind === 'agent-plugin-v1' ? await validatePluginManifest(raw) : [];
-    if (problems.length > 0) {
-        errors.push(...problems.map(problem => `${candidate.path}: ${problem}`));
+    // v1 validation verdicts split per §5.2: fatal violations reject this
+    // candidate (the next one by priority is tried), ignored violations —
+    // unknown top-level fields and the whole `extensions` subtree — are
+    // reported through `notes` and the manifest keeps loading.
+    const verdict = kind === 'agent-plugin-v1' ? await validatePluginManifest(raw) : undefined;
+    if (verdict !== undefined && verdict.fatal.length > 0) {
+        errors.push(...formatSchemaErrors(verdict.fatal).map(problem => `${candidate.path}: ${problem}`));
         return undefined;
     }
+    const ignored = verdict === undefined ? [] : formatSchemaErrors(verdict.ignored);
+    if (kind === 'agent-plugin-v1') {
+        // §5.2 / §6.1: the portable manifest carries no component configuration
+        // and no client semantics beyond `extensions`; every inline key this
+        // manager would otherwise read is an unknown top-level field here.
+        for (const key of V1_IGNORED_MANIFEST_KEYS) {
+            if (raw[key] !== undefined)
+                ignored.push(`${key}: not part of the portable manifest; ignored`);
+        }
+    }
+    notes.push(...ignored.map(problem => `${candidate.path}: ${problem}`));
+    const harness = kind === 'agent-plugin-v1' ? parseHarnessExtension(record['extensions'], notes) : undefined;
     const name = pickString(record.name) ?? hint?.name ?? syntheticManifestName(root);
     const version = pickString(record.version) ?? hint?.version;
     const description = pickString(record.description) ?? hint?.description;
     const author = record.author;
     return {
-        components: { ...componentDeclarations(hint ?? {}), ...fallbackComponents, ...componentDeclarations(raw) },
-        ...(typeof raw.skillInstructions === 'string' ? { skillInstructions: raw.skillInstructions } : {}),
-        ...(typeof raw.systemPrompt === 'string' ? { systemPrompt: raw.systemPrompt } : {}),
-        ...(typeof raw.systemPromptPath === 'string' ? { systemPromptPath: raw.systemPromptPath } : {}),
-        ...(typeof raw.sessionStart?.skill === 'string'
+        components: {
+            ...(kind === 'agent-plugin-v1' ? {} : componentDeclarations(hint ?? {})),
+            ...fallbackComponents,
+            ...(kind === 'agent-plugin-v1' ? {} : componentDeclarations(raw))
+        },
+        ...(typeof raw.skillInstructions === 'string' && kind !== 'agent-plugin-v1'
+            ? { skillInstructions: raw.skillInstructions }
+            : {}),
+        ...(typeof raw.systemPrompt === 'string' && kind !== 'agent-plugin-v1'
+            ? { systemPrompt: raw.systemPrompt }
+            : {}),
+        ...(typeof raw.systemPromptPath === 'string' && kind !== 'agent-plugin-v1'
+            ? { systemPromptPath: raw.systemPromptPath }
+            : {}),
+        ...(kind !== 'agent-plugin-v1' && typeof raw.sessionStart?.skill === 'string'
             ? { startupSkill: raw.sessionStart.skill }
             : {}),
         layout: kind,
@@ -161,9 +194,87 @@ async function readOneManifest(root, candidate, errors, hint) {
                     ? { author: pickString(record.homepage) }
                     : {}),
         keywords: Array.isArray(record.keywords) ? record.keywords.filter((entry) => typeof entry === 'string') : [],
-        ...(isRecognizedSchema(record.$schema) ? { schemaVersion: record.$schema } : {})
+        ...(isRecognizedSchema(record.$schema) ? { schemaVersion: record.$schema } : {}),
+        ...(harness === undefined ? {} : { harness })
     };
 }
+/**
+ * Read this client's §8.1 extension data from a v1 manifest's `extensions`
+ * object. Unknown namespaces are ignored without validating their contents
+ * (§8.1); our own namespace is validated against the namespace contract, and
+ * an unusable value is reported through `notes` instead of failing the
+ * plugin.
+ *
+ * @returns the parsed namespace data, or undefined when the suite declares
+ *   none; diagnostics land in `notes`.
+ */
+function parseHarnessExtension(extensions, notes) {
+    if (!isRecord(extensions) || extensions[EXTENSION_NAMESPACE] === undefined)
+        return undefined;
+    return parseHarnessNamespace(extensions[EXTENSION_NAMESPACE], notes);
+}
+/** Validate one namespace value against the namespace contract; diagnostics go to `notes`. */
+function parseHarnessNamespace(value, notes) {
+    if (!isRecord(value)) {
+        notes.push(`extensions.${EXTENSION_NAMESPACE}: value must be an object; ignored`);
+        return undefined;
+    }
+    const schemaVersion = value['schemaVersion'];
+    if (typeof schemaVersion !== 'string' || !NAMESPACE_SCHEMA_VERSIONS.has(schemaVersion)) {
+        notes.push(`extensions.${EXTENSION_NAMESPACE}: unsupported or missing schemaVersion ${JSON.stringify(schemaVersion)}; supported: ${[...NAMESPACE_SCHEMA_VERSIONS].join(', ')}; namespace extensions are ignored`);
+        return undefined;
+    }
+    const policies = Object.create(null);
+    const rawPolicies = value['mcpServers'];
+    if (rawPolicies !== undefined) {
+        if (!isRecord(rawPolicies)) {
+            notes.push(`extensions.${EXTENSION_NAMESPACE}.mcpServers: value must be an object; ignored`);
+            return { schemaVersion, mcpServers: policies };
+        }
+        for (const [name, policy] of Object.entries(rawPolicies)) {
+            if (!isRecord(policy)) {
+                notes.push(`extensions.${EXTENSION_NAMESPACE}.mcpServers.${name}: policy must be an object; ignored`);
+                continue;
+            }
+            const auth = policy['auth'];
+            if (auth !== undefined &&
+                (!isRecord(auth) || (auth['enabled'] !== undefined && typeof auth['enabled'] !== 'boolean') || (auth['scope'] !== undefined && typeof auth['scope'] !== 'string'))) {
+                notes.push(`extensions.${EXTENSION_NAMESPACE}.mcpServers.${name}.auth: invalid auth declaration; ignored`);
+                continue;
+            }
+            const enabledTools = optionalStringArray(policy['enabledTools'], `extensions.${EXTENSION_NAMESPACE}.mcpServers.${name}.enabledTools`, notes);
+            const disabledTools = optionalStringArray(policy['disabledTools'], `extensions.${EXTENSION_NAMESPACE}.mcpServers.${name}.disabledTools`, notes);
+            const startupTimeoutMs = optionalPositiveNumber(policy['startupTimeoutMs'], `extensions.${EXTENSION_NAMESPACE}.mcpServers.${name}.startupTimeoutMs`, notes);
+            const toolCallTimeoutMs = optionalPositiveNumber(policy['toolCallTimeoutMs'], `extensions.${EXTENSION_NAMESPACE}.mcpServers.${name}.toolCallTimeoutMs`, notes);
+            policies[name] = {
+                ...(enabledTools === undefined ? {} : { enabledTools }),
+                ...(disabledTools === undefined ? {} : { disabledTools }),
+                ...(startupTimeoutMs === undefined ? {} : { startupTimeoutMs }),
+                ...(toolCallTimeoutMs === undefined ? {} : { toolCallTimeoutMs }),
+                ...(auth === undefined || !isRecord(auth) ? {} : { auth: { enabled: auth['enabled'] !== false, ...(typeof auth['scope'] === 'string' ? { scope: auth['scope'] } : {}) } })
+            };
+        }
+    }
+    return { schemaVersion, mcpServers: policies };
+}
+function optionalStringArray(value, label, notes) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || !value.every(entry => typeof entry === 'string')) {
+        notes.push(`${label}: must be an array of strings; ignored`);
+        return undefined;
+    }
+    return value;
+}
+function optionalPositiveNumber(value, label, notes) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+        notes.push(`${label}: must be a positive number; ignored`);
+        return undefined;
+    }
+    return value;
+}
 function pickString(value) {
     return typeof value === 'string' && value !== '' ? value : undefined;
 }

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/scan-resolvers.js

@@ -18,14 +18,17 @@
  * 3. `FlatCollectionsStrategy` — the terminal fallback: manifest-less
  *    `<root>/<name>/SKILL.md` collections.
  */
-import { realpath } from 'node:fs/promises';
+import { realpath, readFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 import { isWithin, sanitizeId } from './paths.js';
 import { isDirectory, isFile, listChildDirs } from './fs-probes.js';
+import { EXTENSION_NAMESPACE, NAMESPACE_DIR, NAMESPACE_HOOKS_FILE, NAMESPACE_LSP_FILE } from '../model/layouts.js';
 import { componentDeclarations, hasSuiteManifest, readManifest, readMarketplaces, syntheticManifestName } from './manifests.js';
 import { countSurfaces, discoverMcp, discoverSkills, listMdFiles } from './surfaces.js';
 import { discoverMarkdownResources, isUnknownArray } from './component-files.js';
 import { discoverSuiteHooks, discoverSuiteLsp, discoverSystemPrompt } from './suite-components.js';
+import { parseLspServers } from './lsp-spec.js';
+import { normalizeHookDocuments } from './project-hooks.js';
 import { runScanChain } from './scan-pipeline.js';
 const CONTAINER_DIRS = ['plugins', 'external_plugins', 'skills'];
 /**
@@ -327,10 +330,11 @@ export async function hasSkillFiles(dir) {
 /** Read one suite root into the normalized shape, or undefined when no manifest parses. */
 export async function readSuite(root, sourceId, dimension, hint, notes = []) {
     const errors = [];
+    const manifestNotes = [];
     const fallbacks = [];
     const declaredManifest = await hasSuiteManifest(root);
-    let manifest = declaredManifest ? await readManifest(root, errors, hint, fallbacks) : await syntheticManifest(root);
-    if (declaredManifest && (manifest === undefined || errors.length > 0)) {
+    let manifest = declaredManifest ? await readManifest(root, errors, hint, fallbacks, manifestNotes) : await syntheticManifest(root);
+    if (declaredManifest && manifest === undefined) {
         notes.push(...errors, ...fallbacks, `suite ${root}: rejected declared manifest`);
         return undefined;
     }
@@ -338,6 +342,7 @@ export async function readSuite(root, sourceId, dimension, hint, notes = []) {
     // higher-priority declaration was skipped visible without failing the suite.
     if (fallbacks.length > 0)
         notes.push(`suite ${root}: a higher-priority manifest was rejected`, ...fallbacks);
+    notes.push(...manifestNotes);
     // A declaration-only suite (official CC lsp plugins ship just a README):
     // the marketplace entry's inline lspServers are its manifest.
     if (manifest === undefined && hint !== undefined && Object.keys(componentDeclarations(hint)).length > 0) {
@@ -354,24 +359,41 @@ export async function readSuite(root, sourceId, dimension, hint, notes = []) {
     }
     if (manifest === undefined)
         return undefined;
+    // The portable v1 dialect reads only the spec's fixed locations plus this
+    // client's extension namespace (§6.1, §8.2): skills and MCP from their
+    // fixed locations, extension surfaces from `com.deepseek.harness/`.
+    // Marketplace-entry and hint declarations carry no inline components for
+    // this dialect, so `components` stays empty and every discovery call below
+    // takes its namespace path.
+    const portable = manifest.layout === 'agent-plugin-v1';
+    // The namespace seats (manifest data and directory) open only when the
+    // suite declares our namespace with a supported contract version; an
+    // unsupported or missing declaration reads the portable core alone.
+    const namespaceOpen = portable && (manifest.harness !== undefined || manifest.schemaVersion !== undefined) && namespaceReadable(manifest);
     let declared = manifest.components?.skills;
     if (declared !== undefined && (manifest.layout === 'claude-code' || manifest.layout === 'codex') && (await isDirectory(join(root, 'skills')))) {
         declared = ['skills', ...(isUnknownArray(declared) ? declared : [declared])];
     }
-    const skills = await discoverSkills(root, errors, declared);
+    if (portable)
+        await noteUnreadRootComponents(root, notes);
+    const skills = await discoverSkills(root, errors, declared, portable);
     if (manifest.layout === 'skill-collection' && skills.length === 0) {
         notes.push(...errors);
         return undefined;
     }
-    const mcp = await discoverMcp(root, errors, manifest);
+    const mcp = await discoverMcp(root, errors, manifest, portable);
     // Effective component declarations include marketplace fallbacks and manifest overrides.
-    const lsp = await discoverSuiteLsp(root, manifest, errors);
-    const hooks = await discoverSuiteHooks(root, manifest, errors);
-    const resources = {
-        commands: await discoverMarkdownResources(root, 'commands', manifest.components?.commands, manifest.path, errors, manifest.layout === 'cursor' ? ['.md', '.mdc', '.markdown', '.txt'] : ['.md']),
-        agents: await discoverMarkdownResources(root, 'agents', manifest.components?.agents, manifest.path, errors)
-    };
-    const systemPrompt = await discoverSystemPrompt(root, manifest, errors);
+    const lsp = namespaceOpen ? await discoverNamespaceLsp(root, manifest, errors, notes) : await discoverSuiteLsp(root, manifest, errors);
+    const hooks = namespaceOpen ? await discoverNamespaceHooks(root, manifest, errors, notes) : await discoverSuiteHooks(root, manifest, errors);
+    const resources = namespaceOpen
+        ? await discoverNamespaceMarkdown(root, notes)
+        : portable
+            ? { commands: [], agents: [] }
+            : {
+                commands: await discoverMarkdownResources(root, 'commands', manifest.components?.commands, manifest.path, errors, manifest.layout === 'cursor' ? ['.md', '.mdc', '.markdown', '.txt'] : ['.md']),
+                agents: await discoverMarkdownResources(root, 'agents', manifest.components?.agents, manifest.path, errors)
+            };
+    const systemPrompt = portable ? undefined : await discoverSystemPrompt(root, manifest, errors);
     const surfaces = await countSurfaces(root, skills, mcp, lsp);
     surfaces.commands = resources.commands.length;
     surfaces.agents = resources.agents.length;
@@ -428,3 +450,86 @@ async function syntheticManifest(root) {
         name
     };
 }
+// ---------------------------------------------------------------------------
+// Extension namespace surfaces (Agent Plugins §8.2)
+//
+// A portable v1 suite carries this client's extension surfaces in the
+// top-level directory named after the namespace. Contents outside it — the
+// dialect root directories other layouts read — are package files this
+// manager does not mount for the portable dialect, and their presence is
+// reported through scan notes rather than read silently.
+// ---------------------------------------------------------------------------
+/** Root component locations other dialects read; under v1 their presence is reported, never read. */
+const ROOT_COMPONENT_DIRS = ['commands', 'agents', 'hooks'];
+/** `.mcp.json` is an alternative MCP path the portable format forbids; `mcp.json` itself is the fixed location. */
+const ROOT_COMPONENT_FILES = ['hooks.json', 'lsp.json', '.lsp.json', '.mcp.json'];
+/**
+ * Whether the namespace contract allows reading the extension seats: the
+ * manifest must carry our namespace with a supported `schemaVersion`. A
+ * directory without manifest data stays closed until the suite declares the
+ * contract, so a name collision on the filesystem cannot silently activate
+ * extension reading.
+ */
+function namespaceReadable(manifest) {
+    return manifest.harness !== undefined;
+}
+/** Report portable-suite content this manager does not mount, so nothing fails silently. */
+async function noteUnreadRootComponents(root, notes) {
+    for (const dir of ROOT_COMPONENT_DIRS) {
+        if (await isDirectory(join(root, dir)))
+            notes.push(`suite ${root}: "${dir}/" is outside the portable layout and the ${EXTENSION_NAMESPACE} namespace; not read for this dialect`);
+    }
+    for (const file of ROOT_COMPONENT_FILES) {
+        if (await isFile(join(root, file)))
+            notes.push(`suite ${root}: "${file}" is outside the portable layout; not read for this dialect`);
+    }
+}
+/** Commands and agents from `<namespace>/commands/` and `<namespace>/agents/`. */
+async function discoverNamespaceMarkdown(root, notes) {
+    const namespaceRoot = join(root, NAMESPACE_DIR);
+    if (!(await isDirectory(namespaceRoot)))
+        return { commands: [], agents: [] };
+    const errors = [];
+    const commands = await discoverMarkdownResources(namespaceRoot, 'commands', undefined, join(namespaceRoot, 'plugin.json'), errors);
+    const agents = await discoverMarkdownResources(namespaceRoot, 'agents', undefined, join(namespaceRoot, 'plugin.json'), errors);
+    notes.push(...errors.map(error => `${EXTENSION_NAMESPACE}: ${error}`));
+    return { commands, agents };
+}
+/** Hooks from `<namespace>/hooks/hooks.json`, normalized through the command-hook bridge. */
+async function discoverNamespaceHooks(root, manifest, errors, notes) {
+    const file = join(root, NAMESPACE_HOOKS_FILE);
+    if (!(await isFile(file)))
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch (error) {
+        notes.push(`${NAMESPACE_HOOKS_FILE}: unparsable (${error instanceof Error ? error.message : String(error)})`);
+        return undefined;
+    }
+    const events = value?.hooks ?? value;
+    if (typeof events !== 'object' || events === null) {
+        notes.push(`${NAMESPACE_HOOKS_FILE}: must contain an event table`);
+        return undefined;
+    }
+    return normalizeHookDocuments(root, [{ file: NAMESPACE_HOOKS_FILE, settings: { hooks: events } }], errors);
+}
+/** LSP servers from `<namespace>/lsp.json`. */
+async function discoverNamespaceLsp(root, manifest, errors, notes) {
+    const file = join(root, NAMESPACE_LSP_FILE);
+    if (!(await isFile(file)))
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch (error) {
+        notes.push(`${NAMESPACE_LSP_FILE}: unparsable (${error instanceof Error ? error.message : String(error)})`);
+        return undefined;
+    }
+    const servers = Object.create(null);
+    const document = value.lspServers ?? value;
+    Object.assign(servers, parseLspServers(document, notes));
+    return Object.keys(servers).length > 0 ? { servers } : undefined;
+}

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',