dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/{application → packages/market-bundle/src/application}/details.js

@@ -1,12 +1,12 @@
 /** Suite detail and preview projections owned by the application layer. */
 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';
-import { credentialRefsInServer } from './mcp/mcp-config.js';
-import { redactMcpConfig, redactMcpOverrides } from './mcp/mcp-redaction.js';
-import { applyOverride } from './mcp/mcp-overrides.js';
-import { effectiveSurfaces } from '../model/types.js';
+import { discoverLspEntries } from '../../../market-catalog/src/index.js';
+import { defaultMarkdownResources, resourceText } from '../../../market-catalog/src/index.js';
+import { credentialRefsInServer } from '../../../market-mcp/src/index.js';
+import { redactMcpConfig, redactMcpOverrides } from '../../../market-contracts/src/redaction.js';
+import { applyOverride } from '../../../market-mcp/src/index.js';
+import { effectiveSurfaces } from '../../../market-contracts/src/model/types.js';
 /** The checkout's last modification, or null when the path cannot be read. */
 async function rootModifiedAt(root) {
     try {
@@ -60,53 +60,97 @@ export async function buildSuiteDetail(suite, installed, diagnostics, mcpOverrid
                     : { count: 0, entries: [] }
                 : normalizedHookPreviews(suite.hooks)
             : { count: 0, entries: [] },
-        commands: remoteUrl === undefined ? await markdownPreviews(suite.resources?.commands ?? (await defaultMarkdownResources(suite.root, 'commands'))) : [],
-        agents: remoteUrl === undefined ? await markdownPreviews(suite.resources?.agents ?? (await defaultMarkdownResources(suite.root, 'agents'))) : [],
+        commands: remoteUrl === undefined ? await documentMetas(suite.resources?.commands ?? (await defaultMarkdownResources(suite.root, 'commands'))) : [],
+        agents: remoteUrl === undefined ? await documentMetas(suite.resources?.agents ?? (await defaultMarkdownResources(suite.root, 'agents'))) : [],
         lsp: remoteUrl === undefined ? await lspDetail(suite) : { servers: [], raw: [] },
         errors: suite.errors,
         mcpErrors: diagnostics.filter(diagnostic => diagnostic.suiteId === suite.id).map(diagnostic => `${diagnostic.serverKey}: ${diagnostic.reason}`)
     };
 }
-/** Read one skill body from a normalized suite. */
-export async function readSkillContent(suite, skillName) {
+/**
+ * Read one skill's authored text from a normalized suite.
+ *
+ * A skill's file is resolved by the scan; commands and agents resolve theirs
+ * through the suite's own resource list ({@link readSuiteDocument}). A skill a
+ * suite does not carry is a miss, not a lookup.
+ */
+async function readSkillText(suite, skillName) {
     const skill = suite.skills.find(entry => entry.name === skillName);
     if (skill === undefined)
         throw new Error(`skill "${skillName}" not found in suite "${suite.id}"`);
-    let content;
     try {
-        content = await readFile(skill.file, 'utf8');
+        return await readFile(skill.file, 'utf8');
     }
     catch (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 };
 }
+/**
+ * Read one of a suite's document surfaces — a skill, a command, or an agent —
+ * by the identity the market detail page addresses it with.
+ *
+ * This is the only body the market ever serves. The detail payload carries a
+ * document's name and description so its row can render, and the text arrives
+ * here when a reader opens that row, whole and uncut.
+ *
+ * The suite's own scanned resource list is the only source of a path: the
+ * caller names a document, never a path, and a name the scan did not produce is
+ * a miss rather than a lookup. Commands and agents read the same resource the
+ * scan that built the detail payload found, so a document read here is the
+ * document that payload named — re-read rather than taken from the request.
+ * @param suite - the normalized suite the document belongs to.
+ * @param kind - which of the three document surfaces the name belongs to.
+ * @param name - the document's name inside that surface.
+ * @returns the document's text exactly as authored.
+ */
+export async function readSuiteDocument(suite, kind, name) {
+    if (kind === 'skills')
+        return readSkillText(suite, name);
+    const resources = suite.resources?.[kind] ?? (await defaultMarkdownResources(suite.root, kind));
+    const resource = resources.find(entry => entry.name === name);
+    if (resource === undefined)
+        throw new Error(`no ${kind} document named "${name}" in suite "${suite.id}"`);
+    return resourceText(resource);
+}
+/**
+ * A capped preview of a file whose bytes still travel inside the detail
+ * payload — the directory-style LSP definition files, and nothing else. The
+ * cap is written into the text it produces, so a reader who gets one never
+ * mistakes a cut document for a whole one.
+ */
 async function readPreview(path, capBytes = 64 * 1024) {
     const text = await readFile(path, 'utf8');
     return text.length > capBytes ? `${text.slice(0, capBytes)}\n… (truncated)` : text;
 }
-async function markdownPreviews(resources) {
-    const previews = [];
+/**
+ * One document's identity as the suite detail payload carries it: the name its
+ * row shows and the description its frontmatter declares. The body is not part
+ * of the payload — it is read on demand, by the document route, when a reader
+ * opens the row.
+ */
+async function documentMetas(resources) {
+    const metas = [];
     for (const resource of resources) {
         try {
-            const content = (await resourceText(resource)).slice(0, 64 * 1024);
-            const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content)?.[1];
-            let description;
-            if (frontmatter !== undefined) {
-                const yaml = parseYaml(frontmatter);
-                if (typeof yaml === 'object' && yaml !== null) {
-                    const desc = yaml['description'];
-                    if (typeof desc === 'string')
-                        description = desc;
-                }
-            }
-            previews.push({ name: resource.name, ...(description === undefined ? {} : { description }), content });
+            const description = frontmatterDescription(await resourceText(resource));
+            metas.push({ name: resource.name, ...(description === undefined ? {} : { description }) });
         }
         catch {
-            // Unreadable preview files are omitted from the detail response.
+            // Unreadable document files are omitted from the detail response.
         }
     }
-    return previews;
+    return metas;
+}
+/** The `description` a document's YAML frontmatter declares, when it declares one. */
+function frontmatterDescription(text) {
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text)?.[1];
+    if (frontmatter === undefined)
+        return undefined;
+    const yaml = parseYaml(frontmatter);
+    if (typeof yaml !== 'object' || yaml === null)
+        return undefined;
+    const description = yaml['description'];
+    return typeof description === 'string' ? description : undefined;
 }
 function normalizedHookPreviews(hooks) {
     const entries = Object.entries(hooks.events).flatMap(([event, groups]) => groups.flatMap(group => group.hooks.map(hook => ({ event, ...(group.matcher === undefined ? {} : { matcher: group.matcher }), command: hook.command }))));

package/lib/packages/market-bundle/src/application/extension-inventory.js

@@ -0,0 +1,408 @@
+/** Extension inventory reuses catalog/panel status queries and preserves their full-detail identities. */
+import { basename } from 'node:path';
+import { HOOK_EVENT_HOST_SUPPORT, hookResourceId } from '../../../market-contracts/src/contracts/extension-presets.js';
+import { SUITE_SURFACE_KEYS } from '../../../market-contracts/src/model/types.js';
+import { USER_MCP_SOURCE, USER_MCP_SUITE } from '../../../market-mcp/src/index.js';
+import { qualifiedSuiteId } from '../../../market-catalog/src/index.js';
+import { deriveServerName } from '../../../market-mcp/src/index.js';
+import { USER_HOOKS_SOURCE, USER_HOOKS_SUITE, exposesIndividualHooks } from '../../../market-runtime/src/index.js';
+import { DIRECT_LSP_SUITE_ID } from '../../../market-lsp/src/index.js';
+/** User-owned configuration is not a market offering. Its direct MCP servers have no suite parent. */
+const isOwnedSentinel = (sourceId, id) => (sourceId === USER_MCP_SOURCE && id === USER_MCP_SUITE) || (sourceId === USER_HOOKS_SOURCE && id === USER_HOOKS_SUITE);
+/** Classification does not change the identifiers used by existing preset and session records. */
+function localConfiguration(suite) {
+    if (suite.sourceId === USER_HOOKS_SOURCE && suite.id === USER_HOOKS_SUITE)
+        return { configuration: 'user-hooks', name: 'User Hooks' };
+    if (suite.dimension === 'project')
+        return { configuration: 'project', name: suite.sourceId === 'native' ? basename(suite.root) : suite.manifest.name };
+    return undefined;
+}
+/** Suite panel ids are JSON tuples, not display names or flattened command identifiers. */
+export function suiteResourceOwner(entry) {
+    if (entry.origin !== 'plugin' || entry.id === undefined)
+        return undefined;
+    try {
+        const value = JSON.parse(entry.id);
+        if (Array.isArray(value) && value.length === 4 && typeof value[0] === 'string' && typeof value[1] === 'string') {
+            return 'market:' + value[0] + '/' + value[1];
+        }
+    }
+    catch {
+        /* Invalid provenance remains unavailable instead of guessing its owner. */
+    }
+    return undefined;
+}
+/**
+ * The composed global switch for one panel entry.
+ *
+ * Only a candidate's validated declaration can say whether an entry the panel
+ * reports as off is an ordinary disabled consumer (selectable per session) or an
+ * invalid one (not selectable at all). Without a candidate the panel's own verdict
+ * is the whole answer, which is the legacy behaviour.
+ */
+function candidateEntryVerdict(candidate, kind, name, panelDisabled) {
+    // An ordinary disabled consumer stays selectable per session; a surface that failed
+    // validation, or an entry the declaration does not actually carry, does not.
+    const selectable = candidate.validSurfaces[kind] === true && declaresResource(candidate, kind, name);
+    // The panel's own flag cannot stand in for the parent switch: it reports one entry's
+    // combined state, so a suite that is off globally must be composed in explicitly or
+    // its entries would read as globally enabled.
+    return { available: selectable, globalEnabled: selectable && globalSurfaceEnabled(candidate, kind) && !panelDisabled };
+}
+/** The composed global switch for one surface of one candidate suite. */
+function globalSurfaceEnabled(candidate, kind) {
+    const { suite, validSurfaces } = candidate;
+    return suite.enabled && validSurfaces[kind] === true && suite.activeSurfaces?.[kind] === true;
+}
+/**
+ * A candidate is displayable while any surface or its system prompt validated; a
+ * candidate the parser rejected contributes nothing to select.
+ */
+function candidateAvailable(candidate) {
+    const { suite, validSurfaces } = candidate;
+    return SUITE_SURFACE_KEYS.some(key => validSurfaces[key] === true) || (suite.systemPrompt !== undefined && suite.systemPrompt !== '');
+}
+/** Whether the validated declaration really carries the entry the panel reported. */
+function declaresResource(candidate, kind, name) {
+    return kind === 'skills' ? candidate.suite.skills.some(skill => skill.name === name) : (candidate.suite.resources?.[kind] ?? []).some(resource => resource.name === name);
+}
+export async function readExtensionInventory(ports, options = {}) {
+    // A caller outside the type system could still name candidates without the override
+    // data. Absence there would read as "enabled", so it is refused rather than guessed.
+    if (options.candidates !== undefined && (options.mcpOverrides === undefined || options.lspDisabledIds === undefined))
+        throw new Error('extension-inventory-override-data-required');
+    const [overview, mcp, lsp, skills, commands, agents] = await Promise.all([
+        ports.catalog.overview(),
+        ports.catalog.mcpStatus(),
+        ports.catalog.lspStatus(),
+        ports.panels.skills.list(true),
+        ports.panels.commands.list(true),
+        ports.panels.agents.list(true)
+    ]);
+    const rows = [];
+    for (const suite of overview.suites) {
+        if (!suite.installed || suite.dimension !== 'user')
+            continue;
+        rows.push({
+            id: 'market:' + suite.sourceId + '/' + suite.suiteId,
+            face: 'market',
+            name: suite.name,
+            source: suite.sourceId,
+            description: suite.description,
+            ...(suite.translatedDescription === undefined ? {} : { translatedDescription: suite.translatedDescription }),
+            ...(suite.version === undefined ? {} : { version: suite.version }),
+            available: suite.enabled !== false,
+            counts: SUITE_SURFACE_KEYS.filter(key => suite.surfaces[key] > 0).map(key => ({ label: key, count: suite.surfaces[key] })),
+            detail: { kind: 'suite', sourceId: suite.sourceId, suiteId: suite.suiteId }
+        });
+    }
+    const candidates = options.candidates ?? [];
+    const candidateOwners = new Map(candidates.map(candidate => ['market:' + candidate.suite.sourceId + '/' + candidate.suite.id, candidate]));
+    const rowById = new Map(rows.map(row => [row.id, row]));
+    for (const candidate of candidates) {
+        const { suite } = candidate;
+        // Direct MCP entries have no parent, and the user hooks configuration has no
+        // card anywhere: neither publishes a market row. The hooks suite's rows stay
+        // on the Hooks face, where its grant is derived from the selected hooks
+        // themselves instead of from a parent id no preset carries.
+        if (isOwnedSentinel(suite.sourceId, suite.id))
+            continue;
+        const owner = 'market:' + suite.sourceId + '/' + suite.id;
+        const usable = candidateAvailable(candidate);
+        const globalEnabled = usable && suite.enabled && SUITE_SURFACE_KEYS.some(key => globalSurfaceEnabled(candidate, key));
+        // One suite is one row. The overview row stays the display authority — its name and
+        // description carry the panel's translation — while the validated declaration
+        // supplies availability and the switch.
+        const existing = rowById.get(owner);
+        if (existing !== undefined) {
+            existing.available = usable;
+            existing.globalEnabled = globalEnabled;
+            Object.assign(existing, localConfiguration(suite));
+            continue;
+        }
+        // A project suite the overview never listed still needs its row.
+        const row = {
+            id: owner,
+            face: 'market',
+            name: suite.manifest.name,
+            ...localConfiguration(suite),
+            source: suite.sourceId,
+            description: suite.manifest.description,
+            available: usable,
+            globalEnabled,
+            counts: SUITE_SURFACE_KEYS.filter(key => suite.surfaces[key] > 0).map(key => ({ label: key, count: suite.surfaces[key] })),
+            detail: { kind: 'suite', sourceId: suite.sourceId, suiteId: suite.id, ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId }) }
+        };
+        rows.push(row);
+        rowById.set(owner, row);
+    }
+    for (const suite of options.projectSuites ?? []) {
+        const owner = 'market:' + suite.sourceId + '/' + suite.id;
+        // Candidate validation already owns this resource; legacy discovery cannot append or override it.
+        if (rowById.has(owner))
+            continue;
+        // The user hooks configuration has no card on any face; its hook rows come
+        // from the hook loop below and its grant is derived from them.
+        if (isOwnedSentinel(suite.sourceId, suite.id))
+            continue;
+        const row = {
+            id: owner,
+            face: 'market',
+            name: suite.manifest.name,
+            ...localConfiguration(suite),
+            source: suite.sourceId,
+            available: suite.enabled,
+            description: suite.manifest.description,
+            counts: SUITE_SURFACE_KEYS.filter(key => suite.surfaces[key] > 0).map(key => ({ label: key, count: suite.surfaces[key] })),
+            detail: { kind: 'suite', sourceId: suite.sourceId, suiteId: suite.id, ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId }) }
+        };
+        rows.push(row);
+        rowById.set(owner, row);
+    }
+    const projectOwners = new Set((options.projectSuites ?? []).map(suite => 'market:' + suite.sourceId + '/' + suite.id));
+    const address = (owner) => (owner !== undefined && projectOwners.has(owner) && options.sessionId !== undefined ? { sessionId: options.sessionId } : {});
+    const parents = new Map(rows.map(row => [row.id, row.available]));
+    // The user's own hook declarations are configuration rows, not suite children:
+    // one row per declared command hook, grouped by event, carrying the host's
+    // support verdict for that event. A supported event's rows select like any
+    // other resource; a partial or registered-only event's rows stay read-only
+    // with the reason, so the Hooks tab registers the declaration without
+    // pretending the host runs it.
+    for (const suite of options.hookSuites ?? options.projectSuites ?? []) {
+        if (suite.hooks === undefined)
+            continue;
+        const provenance = suite.sourceId === USER_HOOKS_SOURCE && suite.id === USER_HOOKS_SUITE ? 'user-hooks' : suite.manifest.name;
+        // The rule is the suite's, not the caller's: an installed suite publishes no
+        // per-hook switch, so every row of its declaration follows the parent
+        // grant, while project and @user-hooks declarations stay individually
+        // addressable. Both reads carry the same verdict.
+        const followsSuite = !exposesIndividualHooks(suite);
+        const supportedEvents = suite.hooks.events;
+        for (const [event, groups] of Object.entries(supportedEvents)) {
+            const support = HOOK_EVENT_HOST_SUPPORT[event] ?? 'registered-only';
+            const selectable = support === 'supported';
+            let index = 0;
+            for (const group of groups) {
+                for (const hook of group.hooks) {
+                    // The position is the identity the row was published under, so it is
+                    // read before the counter moves rather than inside the id expression.
+                    const hookIndex = index;
+                    index += 1;
+                    rows.push({
+                        id: hookResourceId(suite.sourceId, suite.id, event, hookIndex),
+                        face: 'hooks',
+                        name: hook.command,
+                        source: group.matcher === undefined || group.matcher === '*' ? provenance : provenance + ' · ' + group.matcher,
+                        description: event,
+                        suiteResourceId: 'market:' + suite.sourceId + '/' + suite.id,
+                        ...(selectable
+                            ? { available: true, globalEnabled: true }
+                            : { available: false, control: 'global-only', unavailableReason: support === 'supported-partial' ? 'hook-event-partial' : 'hook-event-unsupported' }),
+                        ...(followsSuite ? { followsSuite: true } : {}),
+                        // The detail a row opens is the hook itself, not the suite behind it:
+                        // every field the surface shows comes from this scanned declaration.
+                        detail: {
+                            kind: 'hook',
+                            sourceId: suite.sourceId,
+                            suiteId: suite.id,
+                            event,
+                            hookIndex,
+                            command: hook.command,
+                            ...(group.matcher === undefined ? {} : { matcher: group.matcher }),
+                            ...(hook.timeout === undefined ? {} : { timeoutSec: hook.timeout }),
+                            provenance,
+                            support,
+                            ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId })
+                        }
+                    });
+                }
+            }
+        }
+        // Declarations the catalog validator rejected (Notification, SessionEnd,
+        // PreCompact and anything else the host cannot run) exist only as
+        // diagnostics on the suite. Each names its event, so one read-only row per
+        // diagnostic registers the declaration in the Hooks tab instead of letting
+        // it disappear into the suite detail's error list.
+        for (const error of suite.errors) {
+            const event = /^\S+ unsupported hook event (\S+)$/.exec(error)?.[1];
+            if (event === undefined)
+                continue;
+            const support = HOOK_EVENT_HOST_SUPPORT[event] ?? 'registered-only';
+            rows.push({
+                id: 'hooks:' + suite.sourceId + '/' + suite.id + '/' + event + '/declared',
+                face: 'hooks',
+                name: event,
+                source: provenance,
+                description: event,
+                available: false,
+                control: 'global-only',
+                unavailableReason: support === 'supported-partial' ? 'hook-event-partial' : 'hook-event-unsupported',
+                ...(followsSuite ? { followsSuite: true } : {}),
+                // A rejected declaration has no admitted hook, so the detail carries the
+                // event and the validator's own words instead of a command or position.
+                detail: {
+                    kind: 'hook',
+                    sourceId: suite.sourceId,
+                    suiteId: suite.id,
+                    event,
+                    provenance,
+                    support,
+                    diagnostic: error,
+                    ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId })
+                }
+            });
+        }
+    }
+    for (const [face, entries] of [
+        ['skills', skills],
+        ['commands', commands],
+        ['agents', agents]
+    ]) {
+        for (const entry of entries) {
+            const owner = suiteResourceOwner(entry);
+            const identity = entry.id ?? entry.name;
+            rows.push({
+                id: face + ':' + identity,
+                face,
+                name: entry.name,
+                // Both texts travel: the panel renders the translated one until the
+                // reader flips the shared view, which needs the authored text too.
+                description: entry.description,
+                ...(entry.translatedDescription === undefined ? {} : { translatedDescription: entry.translatedDescription }),
+                source: entry.suiteName ?? 'user',
+                ...(owner === undefined ? {} : { suiteResourceId: owner }),
+                ...(face === 'skills' && entry.origin === 'user'
+                    ? { globalEnabled: !entry.disabled, available: entry.metadata['validationError'] === undefined }
+                    : candidateOwners.has(owner ?? '')
+                        ? candidateEntryVerdict(candidateOwners.get(owner), face, entry.name, entry.disabled)
+                        : // A native (user-origin) entry the user switched off is an ordinary disabled
+                            // consumer: a preset may name it. A document that failed to parse is not
+                            // selectable, whatever a preset says, and `metadata.validationError` is the
+                            // panel's own evidence for that.
+                            entry.origin === 'user'
+                                ? { available: entry.metadata['validationError'] === undefined, globalEnabled: !entry.disabled && entry.metadata['validationError'] === undefined }
+                                : { available: !entry.disabled && owner !== undefined && parents.get(owner) === true }),
+                detail: { kind: 'panel', panel: face, entryId: identity, ...address(owner) }
+            });
+        }
+    }
+    for (const entry of mcp.entries) {
+        const owner = entry.suiteId === undefined || entry.suiteId === USER_MCP_SOURCE + '/' + USER_MCP_SUITE ? undefined : 'market:' + entry.suiteId;
+        const row = {
+            id: 'mcp:' + entry.id,
+            face: 'mcp',
+            name: entry.name,
+            source: entry.source ?? 'direct',
+            description: entry.transport,
+            ...((entry.kind === 'direct' && entry.managed !== true) || options.mcpSessionControl === false
+                ? { control: 'global-only', unavailableReason: entry.kind === 'direct' && entry.managed !== true ? 'direct-mcp-uncontrolled' : 'host-mcp-uncontrolled' }
+                : {}),
+            ...(owner === undefined ? {} : { suiteResourceId: owner }),
+            available: entry.state !== 'disabled' && entry.state !== 'foreign' && entry.state !== 'orphaned' && (owner === undefined || parents.get(owner) === true),
+            detail: { kind: 'mcp', entryId: entry.id, ...address(owner) }
+        };
+        rows.push(row);
+        // Registered so a candidate corrects this row in place instead of adding another.
+        rowById.set(row.id, row);
+    }
+    for (const entry of lsp.entries) {
+        const owner = entry.kind === 'direct' ? undefined : 'market:' + entry.suiteId;
+        const row = {
+            id: 'lsp:' + entry.id,
+            face: 'lsp',
+            name: entry.serverKey,
+            source: entry.kind === 'direct' ? 'direct' : entry.suiteName,
+            description: entry.command,
+            ...(owner === undefined ? {} : { suiteResourceId: owner }),
+            // Only candidate mode can say a disabled direct server is still nameable, because
+            // only then does the caller supply the disabled-id switch. Legacy mode has no such
+            // evidence, so it keeps the original rule exactly: a disabled row is unavailable.
+            available: entry.kind === 'direct'
+                ? options.candidates === undefined
+                    ? entry.state !== 'disabled'
+                    : entry.state !== 'failed' && entry.state !== 'conflict' && entry.state !== 'host-missing'
+                : entry.state !== 'disabled' && parents.get(owner) === true,
+            ...(entry.kind !== 'direct'
+                ? { globalEnabled: entry.state !== 'disabled' }
+                : options.candidates === undefined || options.lspDisabledIds === undefined
+                    ? {}
+                    : { globalEnabled: !options.lspDisabledIds.has(entry.id) }),
+            detail: { kind: 'lsp', entryId: entry.id, ...address(owner) }
+        };
+        rows.push(row);
+        rowById.set(row.id, row);
+    }
+    // Rows for declarations the status layer omits, because it only reports installed
+    // and globally enabled suites. These are exactly the entries a preset still has to
+    // be able to name, and they are synthesized from the validated declaration rather
+    // than inferred from the absence of a status row.
+    for (const candidate of candidates) {
+        const { suite } = candidate;
+        const suiteKey = qualifiedSuiteId(suite.sourceId, suite.id);
+        // A user-owned sentinel's server is a direct resource: it has no suite parent to
+        // gate it, exactly as the status layer reports the same server.
+        const owner = isOwnedSentinel(suite.sourceId, suite.id) ? undefined : 'market:' + suite.sourceId + '/' + suite.id;
+        const ownerAvailable = owner === undefined || parents.get(owner) === true;
+        // Overrides are keyed by the source-qualified suite key the MCP layer itself uses,
+        // not by the resource id a preset names.
+        const overrides = options.mcpOverrides?.get(suiteKey);
+        for (const [serverKey, server] of Object.entries(suite.mcp?.servers ?? {})) {
+            const rowId = 'plugin:' + suiteKey + '/' + serverKey;
+            const override = overrides?.[serverKey];
+            const selectable = ownerAvailable && candidate.validSurfaces.mcp === true;
+            const globalEnabled = override?.enabled === false ? false : globalSurfaceEnabled(candidate, 'mcp');
+            // The status layer reports the row for an enabled suite and updates it in place;
+            // a row it omitted (a disabled suite) is synthesized from the declaration. Either
+            // way a status row that exists is corrected, never duplicated.
+            const existing = rowById.get('mcp:' + rowId);
+            if (existing !== undefined) {
+                existing.available = selectable;
+                existing.globalEnabled = globalEnabled;
+                continue;
+            }
+            const hostBackend = options.mcpSessionControl === false;
+            rows.push({
+                id: 'mcp:' + rowId,
+                face: 'mcp',
+                name: deriveServerName(suite, serverKey),
+                source: suite.manifest.name,
+                description: server.type,
+                ...(hostBackend ? { control: 'global-only', unavailableReason: 'host-mcp-uncontrolled' } : {}),
+                suiteResourceId: owner,
+                available: selectable,
+                globalEnabled,
+                detail: { kind: 'mcp', entryId: rowId, ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId }) }
+            });
+        }
+        for (const spec of Object.values(suite.lsp?.servers ?? {})) {
+            const rowId = suiteKey + '/' + spec.key;
+            if (suiteKey === DIRECT_LSP_SUITE_ID)
+                continue;
+            // A project suite's LSP declaration is never enableable, whatever the preset says.
+            const valid = candidate.validSurfaces.lsp === true;
+            const selectable = ownerAvailable && valid;
+            const globalEnabled = valid && suite.enabled && suite.activeSurfaces?.lsp === true && options.lspDisabledIds?.has(rowId) !== true;
+            const existing = rowById.get('lsp:' + rowId);
+            if (existing !== undefined) {
+                existing.available = selectable;
+                existing.globalEnabled = globalEnabled;
+                continue;
+            }
+            const row = {
+                id: 'lsp:' + rowId,
+                face: 'lsp',
+                name: spec.key,
+                source: suite.manifest.name,
+                description: spec.command,
+                suiteResourceId: owner,
+                available: selectable,
+                globalEnabled,
+                detail: { kind: 'lsp', entryId: rowId, ...(options.sessionId === undefined ? {} : { sessionId: options.sessionId }) }
+            };
+            rows.push(row);
+            rowById.set(row.id, row);
+        }
+    }
+    return rows;
+}
+export { extensionResourceEnabled } from '../../../market-runtime/src/index.js';

package/lib/packages/market-bundle/src/application/extension-project.js

@@ -0,0 +1,64 @@
+import { createPanelResources } from '../../../market-runtime/src/index.js';
+import { buildMcpStatus } from '../../../market-mcp/src/index.js';
+import { buildLspStatus } from '../../../market-lsp/src/index.js';
+import { buildSuiteDetail } from './details.js';
+import { USER_HOOKS_SOURCE, USER_HOOKS_SUITE, loadUserHooksSuite } from '../../../market-runtime/src/index.js';
+export function createProjectExtensionResources(catalog, users, cwd) {
+    const panels = createPanelResources(catalog, users, cwd);
+    const suites = async () => (await catalog.readProjectCatalog(cwd)).suites;
+    return {
+        panels,
+        suites,
+        async suiteDetail(sourceId, suiteId) {
+            // The user-hooks synthetic suite is a configuration row, not an install:
+            // `enabledUserSuites` carries it only while it declares events, so the
+            // detail reads the always-built suite and shows its diagnostics when the
+            // configuration is empty or malformed instead of a 404.
+            if (sourceId === USER_HOOKS_SOURCE && suiteId === USER_HOOKS_SUITE) {
+                const hooks = await loadUserHooksSuite(catalog.agentsRoot);
+                // The suite declares hooks only; an explicit empty resource list keeps the
+                // detail from discovering the shared Agent layout root's commands and
+                // agents directories as if they were this configuration's surfaces.
+                return buildSuiteDetail({ ...hooks, resources: { commands: [], agents: [] } }, undefined, [], undefined);
+            }
+            const suite = (await suites()).find(row => row.sourceId === sourceId && row.id === suiteId) ??
+                (await catalog.enabledUserSuites()).find(row => row.sourceId === sourceId && row.id === suiteId && row.sourceId === '@user-hooks');
+            if (!suite)
+                throw new Error('project suite not found');
+            return buildSuiteDetail(suite, undefined, [], undefined);
+        },
+        /**
+         * One document of this workspace's suite, on any of the three surfaces.
+         *
+         * The lookup stays in Catalog — one reader for skills, commands and agents — and
+         * the project cwd only selects which snapshot answers. Re-scanning here would
+         * duplicate the catalog's own identity handling.
+         */
+        async suiteDocument(sourceId, suiteId, kind, name) {
+            return catalog.suiteDocument(sourceId, suiteId, kind, name, cwd);
+        },
+        /** The same document's translation, answered from this workspace's snapshot. */
+        async suiteDocumentTranslation(sourceId, suiteId, kind, name, retry = false) {
+            return catalog.suiteDocumentTranslation(sourceId, suiteId, kind, name, retry, cwd);
+        },
+        async mcpStatus(diagnostics = [], observed = []) {
+            const declared = (await suites()).map(suite => ({ ...suite, installedAt: suite.installedAt ?? 'project' }));
+            return buildMcpStatus(declared, diagnostics, observed, await catalog.allMcpOverrides(declared));
+        },
+        async lspStatus() {
+            const declared = (await suites()).map(suite => ({ ...suite, installedAt: suite.installedAt ?? 'project' }));
+            return buildLspStatus(declared, {
+                hasLiveMounts: () => false,
+                // Same shape the mount registry records: one row per suite, keyed by suite id,
+                // with the suite's declared server keys joined as the registry joins them.
+                diagnosticsSnapshot: () => new Map(declared.flatMap(suite => {
+                    const servers = suite.lsp?.servers;
+                    if (servers === undefined)
+                        return [];
+                    const suiteId = suite.sourceId + '/' + suite.id;
+                    return [[suiteId, { suiteId, serverKey: Object.keys(servers).join(','), code: 'mount-failed', reason: 'project-lsp-unsupported' }]];
+                }))
+            });
+        }
+    };
+}