@theia/ai-ide 1.75.0-next.8 → 1.75.0

package/src/browser/ai-configuration/categories/prompt-snippets-configuration-category.tsx

@@ -0,0 +1,438 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Agent, AgentService } from '@theia/ai-core';
+import { CAPABILITY_TYPE_PROMPT_MAP, parseCapabilitiesFromTemplate } from '@theia/ai-core/lib/common';
+import { isCustomizedPromptFragment, PromptFragment, PromptService } from '@theia/ai-core/lib/common/prompt-service';
+import { Emitter, Event, nls } from '@theia/core';
+import { codicon, ConfirmDialog } from '@theia/core/lib/browser';
+import { DisposableCollection } from '@theia/core/lib/common';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import * as React from '@theia/core/shared/react';
+import {
+    AiConfigurationCategory,
+    AiConfigurationCategoryId,
+    AiConfigurationCategoryOrder,
+    AiConfigurationRenderContext,
+    AiConfigurationSearchItem,
+    AiConfigurationSearchProvider,
+    AiConfigurationSelection
+} from '@theia/ai-core-ui/lib/browser/ai-configuration/ai-configuration-category';
+import { SinglePageCategoryRenderer } from '@theia/ai-core-ui/lib/browser/ai-configuration/renderers/single-page-category-renderer';
+import {
+    CollapsibleGroup,
+    CollapsibleList,
+    CollapsibleRow,
+    CollapsibleRowAction
+} from '@theia/ai-core-ui/lib/browser/ai-configuration/components/collapsible-list';
+import { PromptCustomizationDialogs } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/prompt-customization-dialogs';
+import { AiConfigurationCallout } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/ai-configuration-primitives';
+import { AgentChips } from './agent-chips';
+
+/**
+ * Fragments generated per running MCP server, named after `McpFrontendService.getPromptTemplateId`.
+ * Excluded from this page: they are rebuilt from the live tool list whenever a server starts, so a
+ * customization would silently diverge from the tools the server actually offers. The generated tool
+ * list is visible on the MCP Servers page instead.
+ */
+const MCP_TOOL_LIST_FRAGMENT_PATTERN = /^mcp_.+_tools$/;
+
+/** Which group a fragment belongs to, in the order the page renders them. */
+export type PromptSnippetKind = 'snippet' | 'capability' | 'generic-capability';
+
+/** One prompt fragment as this page shows it, resolved from the prompt service on load. */
+export interface PromptSnippetEntry {
+    readonly id: string;
+    readonly kind: PromptSnippetKind;
+    /** Frontmatter `name`, when the fragment declares one. */
+    readonly name?: string;
+    /** Frontmatter `description`, when the fragment declares one. */
+    readonly description?: string;
+    /** A customization currently overrides (or, without a built-in, provides) the text. */
+    readonly customized: boolean;
+    /** `false` for a fragment that exists only as a user/workspace file, where reset has nothing to fall back to. */
+    readonly hasBuiltIn: boolean;
+    /** Agents whose selected prompt references this fragment as a capability; empty for plain snippets. */
+    readonly agentIds: string[];
+}
+
+export namespace PromptSnippetsConfiguration {
+    /**
+     * Prefix of the `data-ai-config-row-id` of every row on this page, regardless of its group, so that
+     * a deep link only needs the fragment id (an agent's capability list, for instance, does not know
+     * whether a fragment ends up under Capabilities or Generic Capabilities).
+     */
+    export const ROW_ID_PREFIX = 'fragment:';
+
+    /** Navigation target that scrolls to and flashes `fragmentId`'s row on this page. */
+    export function selectionFor(fragmentId: string): AiConfigurationSelection {
+        return {
+            categoryId: AiConfigurationCategoryId.PROMPT_SNIPPETS,
+            highlight: { rowId: ROW_ID_PREFIX + fragmentId }
+        };
+    }
+}
+
+/**
+ * The "Prompt Snippets" category: every prompt fragment that has no other home in this view, as a
+ * filterable list of expandable rows in three groups — user-authored snippets, agent capabilities and
+ * generic capabilities. Prompt variant sets live in the agent detail, skills and slash commands on the
+ * Skills page, so those are filtered out here; what remains would otherwise be uneditable, which is
+ * what this page fixes.
+ *
+ * Capability fragments are global: editing one affects every agent that references it, which is why
+ * each row lists the agents using it rather than pretending the text belongs to one of them.
+ */
+@injectable()
+export class PromptSnippetsConfigurationCategory extends SinglePageCategoryRenderer implements AiConfigurationCategory, AiConfigurationSearchProvider {
+
+    readonly id = AiConfigurationCategoryId.PROMPT_SNIPPETS;
+    readonly label = nls.localize('theia/ai/ide/promptSnippetsConfiguration/label', 'Prompt Snippets');
+    readonly description = nls.localize('theia/ai/ide/promptSnippetsConfiguration/description',
+        'Reusable prompt text: your own snippets plus the capability snippets agents pull in. Editing a snippet affects every agent that uses it.');
+    readonly iconClass = codicon('file-code');
+    readonly order = AiConfigurationCategoryOrder.PROMPT_SNIPPETS;
+    readonly kind = 'single-page' as const;
+
+    @inject(PromptService)
+    protected readonly promptService: PromptService;
+
+    @inject(AgentService)
+    protected readonly agentService: AgentService;
+
+    protected readonly onDidChangeEmitter = new Emitter<void>();
+    readonly onDidChange: Event<void> = this.onDidChangeEmitter.event;
+    protected readonly toDispose = new DisposableCollection(this.onDidChangeEmitter);
+
+    protected entries: PromptSnippetEntry[] = [];
+    protected availableAgents: Agent[] = [];
+
+    get renderer(): this {
+        return this;
+    }
+
+    get search(): AiConfigurationSearchProvider {
+        return this;
+    }
+
+    @postConstruct()
+    protected init(): void {
+        this.reload();
+        this.toDispose.pushAll([
+            this.promptService.onPromptsChange(() => {
+                this.reload();
+                this.onDidChangeEmitter.fire();
+            }),
+            this.agentService.onDidChangeAgents(() => {
+                this.reload();
+                this.onDidChangeEmitter.fire();
+            })
+        ]);
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    protected reload(): void {
+        this.availableAgents = this.agentService.getAllAgents();
+        this.entries = this.loadEntries();
+    }
+
+    /**
+     * Classifies every registered fragment, dropping those another part of the view already owns.
+     * Grouped by {@link PromptSnippetKind} and sorted by display name within each group.
+     */
+    protected loadEntries(): PromptSnippetEntry[] {
+        const capabilityAgents = this.collectCapabilityReferences();
+        const genericCapabilityIds = new Set(CAPABILITY_TYPE_PROMPT_MAP.map(({ promptId }) => promptId));
+        const ownedElsewhere = this.collectFragmentIdsOwnedElsewhere();
+        const entries: PromptSnippetEntry[] = [];
+        for (const [id, fragments] of this.promptService.getAllPromptFragments()) {
+            if (ownedElsewhere.has(id) || MCP_TOOL_LIST_FRAGMENT_PATTERN.test(id)) {
+                continue;
+            }
+            const effective = this.promptService.getRawPromptFragment(id) ?? fragments[0];
+            // Slash commands (including the synthetic ones backing a skill) belong to the Skills page. Checking
+            // every fragment, not just the effective one, keeps a command hidden here even if a customization
+            // drops the `isCommand` frontmatter.
+            if (!effective || fragments.some(fragment => fragment.isCommand)) {
+                continue;
+            }
+            const agentIds = capabilityAgents.get(id) ?? [];
+            entries.push({
+                id,
+                kind: this.classify(id, effective, genericCapabilityIds, agentIds.length > 0),
+                name: effective.name,
+                description: effective.description,
+                customized: fragments.some(fragment => isCustomizedPromptFragment(fragment)),
+                hasBuiltIn: fragments.some(fragment => !isCustomizedPromptFragment(fragment)),
+                agentIds
+            });
+        }
+        return entries.sort((left, right) => this.displayName(left).localeCompare(this.displayName(right)));
+    }
+
+    /**
+     * A fragment is a *generic* capability when it is one of the fixed set the chat dropdowns inject
+     * (`CAPABILITY_TYPE_PROMPT_MAP` is that single source of truth), and a *capability* when an agent
+     * references it as `{{capability:id}}`. Declared frontmatter is accepted as a fallback so that a
+     * capability shipped by an extension still groups correctly before any agent template pulls it in.
+     */
+    protected classify(id: string, fragment: PromptFragment, genericCapabilityIds: Set<string>, referencedByAgent: boolean): PromptSnippetKind {
+        if (genericCapabilityIds.has(id)) {
+            return 'generic-capability';
+        }
+        if (referencedByAgent || fragment.name !== undefined || fragment.description !== undefined) {
+            return 'capability';
+        }
+        return 'snippet';
+    }
+
+    /**
+     * Maps capability fragment id -> ids of the agents referencing it. Mirrors the agent detail page,
+     * which parses `{{capability:...}}` out of each agent's selected prompt, so both agree on what
+     * counts as a capability. Uses the globally effective variant to stay synchronous; the agent detail
+     * additionally honours that agent's own variant selection.
+     */
+    protected collectCapabilityReferences(): Map<string, string[]> {
+        const references = new Map<string, string[]>();
+        for (const agent of this.availableAgents) {
+            for (const prompt of agent.prompts) {
+                const variantId = this.promptService.getEffectiveVariantId(prompt.id) ?? prompt.id;
+                const template = this.promptService.getRawPromptFragment(variantId)?.template;
+                if (!template) {
+                    continue;
+                }
+                for (const capability of parseCapabilitiesFromTemplate(template)) {
+                    const agents = references.get(capability.fragmentId) ?? [];
+                    if (!agents.includes(agent.id)) {
+                        agents.push(agent.id);
+                    }
+                    references.set(capability.fragmentId, agents);
+                }
+            }
+        }
+        return references;
+    }
+
+    /**
+     * Fragment ids another part of the view is responsible for: the prompt variant sets and their
+     * variants, which the agent detail owns as the single source of truth.
+     */
+    protected collectFragmentIdsOwnedElsewhere(): Set<string> {
+        const owned = new Set<string>();
+        for (const [variantSetId, variantIds] of this.promptService.getPromptVariantSets()) {
+            owned.add(variantSetId);
+            variantIds.forEach(variantId => owned.add(variantId));
+        }
+        return owned;
+    }
+
+    protected displayName(entry: PromptSnippetEntry): string {
+        return entry.name ?? entry.id;
+    }
+
+    protected renderSections(ctx: AiConfigurationRenderContext): React.ReactNode {
+        const onOpenAgent = (agentId: string): void => ctx.navigate({ categoryId: AiConfigurationCategoryId.AGENTS, itemId: agentId });
+        const groups: CollapsibleGroup[] = [
+            {
+                id: 'snippets',
+                title: nls.localizeByDefault('Snippets'),
+                description: nls.localize('theia/ai/ide/promptSnippetsConfiguration/snippetsGroupDescription',
+                    'Prompt text you maintain yourself, referenced from other prompts with {{prompt:id}}.'),
+                rows: this.buildRows('snippet', ctx, onOpenAgent)
+            },
+            {
+                id: 'capabilities',
+                title: nls.localizeByDefault('Capabilities'),
+                description: nls.localize('theia/ai/ide/promptSnippetsConfiguration/capabilitiesGroupDescription',
+                    'Instructions an agent adds to its prompt when enabled. They are shared, so an edit affects every agent using them.'),
+                rows: this.buildRows('capability', ctx, onOpenAgent)
+            },
+            {
+                id: 'generic-capabilities',
+                title: nls.localize('theia/ai/ide/promptSnippetsConfiguration/genericCapabilitiesGroup', 'Generic Capabilities'),
+                description: nls.localize('theia/ai/ide/promptSnippetsConfiguration/genericCapabilitiesGroupDescription',
+                    'Basic instructions to integrate the selected capabilities into the agent\'s prompt.  They are shared, so an edit affects every agent using them.'),
+                rows: this.buildRows('generic-capability', ctx, onOpenAgent)
+            }
+        ];
+        return <>
+            {this.renderResetAllCallout(ctx)}
+            <CollapsibleList
+                groups={groups}
+                filterPlaceholder={nls.localize('theia/ai/ide/promptSnippetsConfiguration/filterPlaceholder', 'Filter prompt snippets by name, id or description')}
+                emptyMessage={nls.localize('theia/ai/ide/promptSnippetsConfiguration/empty', 'No prompt snippets are available.')}
+                filterEmptyMessage={query => nls.localize('theia/ai/ide/promptSnippetsConfiguration/noMatches', 'No prompt snippets match "{0}".', query)}
+            />
+        </>;
+    }
+
+    /**
+     * Page-level reset, as the prompt fragments page it replaces had. Shown only while something is
+     * customized, and explicit that it reverts *every* customization — including the agents' prompt
+     * variants, which live on their own pages.
+     */
+    protected renderResetAllCallout(ctx: AiConfigurationRenderContext): React.ReactNode {
+        if (!this.hasResettableCustomizations()) {
+            return undefined;
+        }
+        return <AiConfigurationCallout
+            message={nls.localize('theia/ai/ide/promptSnippetsConfiguration/resetAllMessage',
+                'Some prompt fragments are customized. Resetting reverts every one of them to its built-in version, '
+                + 'including the agents\' prompt templates. Snippets that have no built-in version are kept.')}
+            action={<button className='theia-button secondary' onClick={() => this.resetAllCustomizations(ctx)}>
+                {nls.localize('theia/ai/ide/promptSnippetsConfiguration/resetAll', 'Reset All Customizations')}
+            </button>}
+        />;
+    }
+
+    /**
+     * Whether anything would actually be reset. Deliberately not limited to this page's entries: the action
+     * reverts every customized fragment that has a built-in, which includes the agents' prompt templates
+     * (listed on their own pages), so gating on the rows here would hide it exactly when it is needed.
+     */
+    protected hasResettableCustomizations(): boolean {
+        for (const fragments of this.promptService.getAllPromptFragments().values()) {
+            if (fragments.some(fragment => isCustomizedPromptFragment(fragment)) && fragments.some(fragment => !isCustomizedPromptFragment(fragment))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    protected async resetAllCustomizations(ctx: AiConfigurationRenderContext): Promise<void> {
+        const dialog = new ConfirmDialog({
+            title: nls.localize('theia/ai/ide/promptSnippetsConfiguration/resetAllDialogTitle', 'Reset All Customizations'),
+            msg: nls.localize('theia/ai/ide/promptSnippetsConfiguration/resetAllDialogMsg',
+                'Are you sure you want to reset every customized prompt fragment to its built-in version? '
+                + 'This includes the agents\' prompt templates, not only the snippets listed here. '
+                + 'Snippets that have no built-in version are kept.'),
+            ok: nls.localizeByDefault('Reset'),
+            cancel: nls.localizeByDefault('Cancel')
+        });
+        if (await dialog.open()) {
+            await this.promptService.resetAllToBuiltIn();
+            ctx.update();
+        }
+    }
+
+    protected buildRows(kind: PromptSnippetKind, ctx: AiConfigurationRenderContext, onOpenAgent: (agentId: string) => void): CollapsibleRow[] {
+        return this.entries.filter(entry => entry.kind === kind).map(entry => this.buildRow(entry, ctx, onOpenAgent));
+    }
+
+    protected buildRow(entry: PromptSnippetEntry, ctx: AiConfigurationRenderContext, onOpenAgent: (agentId: string) => void): CollapsibleRow {
+        const agents = this.availableAgents.filter(agent => entry.agentIds.includes(agent.id));
+        const pills: string[] = [];
+        if (entry.customized) {
+            pills.push(nls.localize('theia/ai/ide/promptSnippetsConfiguration/customized', 'Customized'));
+        }
+        if (agents.length > 0) {
+            pills.push(agents.length === 1 ? nls.localizeByDefault('1 agent') : nls.localizeByDefault('{0} agents', agents.length));
+        }
+        return {
+            id: PromptSnippetsConfiguration.ROW_ID_PREFIX + entry.id,
+            title: this.displayName(entry),
+            description: entry.description,
+            pills,
+            filterText: `${entry.id} ${entry.name ?? ''} ${entry.description ?? ''}`.toLocaleLowerCase(),
+            actions: <>
+                <CollapsibleRowAction
+                    iconClass={codicon('edit')}
+                    label={nls.localize('theia/ai/ide/promptSnippetsConfiguration/editSnippet', 'Edit snippet')}
+                    onActivate={() => this.editEntry(entry)}
+                />
+                {/* A customization of a built-in can be reverted; a snippet that only exists as a file has
+                    nothing to revert to, so it offers deletion instead. */}
+                {entry.customized && entry.hasBuiltIn && <CollapsibleRowAction
+                    iconClass={codicon('discard')}
+                    label={nls.localize('theia/ai/ide/promptSnippetsConfiguration/resetSnippet', 'Reset snippet to built-in')}
+                    onActivate={() => this.resetEntry(entry, ctx)}
+                />}
+                {entry.customized && !entry.hasBuiltIn && <CollapsibleRowAction
+                    iconClass={codicon('trash')}
+                    label={nls.localize('theia/ai/ide/promptSnippetsConfiguration/removeSnippet', 'Remove snippet')}
+                    onActivate={() => this.removeEntry(entry, ctx)}
+                />}
+            </>,
+            body: <>
+                <div className='ai-variable-id-row'>
+                    <span className='ai-variable-id-label'>{nls.localizeByDefault('ID')}</span>
+                    <code className='ai-variable-id-value'>{entry.id}</code>
+                </div>
+                {agents.length > 0 && <div className='ai-variable-section'>
+                    <div className='ai-variable-section-label'>
+                        {nls.localize('theia/ai/ide/promptSnippetsConfiguration/usedByAgents', 'Used by Agents')}
+                    </div>
+                    <AgentChips agents={agents} onOpenAgent={onOpenAgent} />
+                </div>}
+            </>
+        };
+    }
+
+    /** Opens the effective text: the customization if there is one, otherwise a fresh copy of the built-in. */
+    protected editEntry(entry: PromptSnippetEntry): void {
+        const fragment = this.promptService.getRawPromptFragment(entry.id);
+        if (fragment && isCustomizedPromptFragment(fragment)) {
+            this.promptService.editCustomization(fragment.id, fragment.customizationId);
+        } else {
+            this.promptService.editBuiltInCustomization(entry.id);
+        }
+    }
+
+    /** Drops all customizations so the built-in text applies again. */
+    protected async resetEntry(entry: PromptSnippetEntry, ctx: AiConfigurationRenderContext): Promise<void> {
+        await PromptCustomizationDialogs.confirmAndReset(
+            this.promptService,
+            entry.id,
+            nls.localize('theia/ai/ide/promptSnippetsConfiguration/resetDialogTitle', 'Reset Snippet to Built-in'),
+            nls.localize('theia/ai/ide/promptSnippetsConfiguration/resetDialogMsg',
+                'Are you sure you want to reset the snippet "{0}" to its built-in version? This will remove all customizations.', entry.id)
+        );
+        ctx.update();
+    }
+
+    /** Deletes a snippet that has no built-in behind it, naming the file, since it is gone afterwards. */
+    protected async removeEntry(entry: PromptSnippetEntry, ctx: AiConfigurationRenderContext): Promise<void> {
+        await PromptCustomizationDialogs.confirmAndRemove(this.promptService, entry.id, {
+            title: nls.localize('theia/ai/ide/promptSnippetsConfiguration/removeDialogTitle', 'Remove Snippet'),
+            message: ({ type, description }) => description
+                ? nls.localize('theia/ai/ide/promptSnippetsConfiguration/removeWithDescDialogMsg',
+                    'Are you sure you want to remove the {0} customization for snippet "{1}" ({2})? It has no built-in version, so it will be gone entirely.',
+                    type ?? '', entry.id, description)
+                : nls.localize('theia/ai/ide/promptSnippetsConfiguration/removeDialogMsg',
+                    'Are you sure you want to remove the {0} customization for snippet "{1}"? It has no built-in version, so it will be gone entirely.',
+                    type ?? '', entry.id)
+        });
+        ctx.update();
+    }
+
+    getSearchItems(): AiConfigurationSearchItem[] {
+        const typeLabels: Record<PromptSnippetKind, string> = {
+            'snippet': nls.localizeByDefault('Snippet'),
+            'capability': nls.localize('theia/ai/ide/promptSnippetsConfiguration/capabilityTypeLabel', 'Capability'),
+            'generic-capability': nls.localize('theia/ai/ide/promptSnippetsConfiguration/genericCapabilityTypeLabel', 'Generic capability')
+        };
+        return this.entries.map(entry => ({
+            label: this.displayName(entry),
+            typeLabel: typeLabels[entry.kind],
+            categoryId: this.id,
+            target: PromptSnippetsConfiguration.selectionFor(entry.id),
+            keywords: `${entry.id} ${entry.description ?? ''}`
+        }));
+    }
+}

package/src/browser/ai-configuration/categories/prompts-and-skills-configuration-category.spec.ts

@@ -0,0 +1,226 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { Event } from '@theia/core';
+import { PromptFragment } from '@theia/ai-core/lib/common/prompt-service';
+import { Skill } from '@theia/ai-core/lib/common/skill';
+import { AgentPluginUiBridge, InstalledAgentPluginInfo } from '@theia/ai-core/lib/browser/agent-plugin-ui-bridge';
+import { SkillRegistryUiBridge } from '@theia/ai-core/lib/browser/skill-registry-ui-bridge';
+import { AiConfigurationCategoryId } from '@theia/ai-core-ui/lib/browser/ai-configuration/ai-configuration-category';
+import { CollapsibleRow } from '@theia/ai-core-ui/lib/browser/ai-configuration/components/collapsible-list';
+import { PromptsAndSkillsConfigurationCategory } from './prompts-and-skills-configuration-category';
+
+disableJSDOM();
+
+/** A plugin as the bridge knows it, plus the qualifier its contributed skill root carries. */
+type InstalledPlugin = InstalledAgentPluginInfo & { qualifier: string };
+
+describe('PromptsAndSkillsConfigurationCategory', () => {
+
+    before(() => disableJSDOM = enableJSDOM());
+    after(() => disableJSDOM());
+
+    function categoryWith(skills: Skill[], slashCommands: PromptFragment[]): PromptsAndSkillsConfigurationCategory {
+        const category = new PromptsAndSkillsConfigurationCategory();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).skills = skills;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).slashCommands = slashCommands;
+        return category;
+    }
+
+    /** Leaves the bridge unbound when `installedPlugins` is omitted, i.e. a product without `@theia/ai-registry`. */
+    function categoryWithPlugins(skills: Skill[], installedPlugins: InstalledPlugin[] | undefined, revealed: string[] = []): PromptsAndSkillsConfigurationCategory {
+        const category = categoryWith(skills, []);
+        if (installedPlugins) {
+            const bridge: AgentPluginUiBridge = {
+                getPlugin: pluginId => installedPlugins.find(plugin => plugin.pluginId === pluginId),
+                getPluginByQualifier: qualifier => installedPlugins.find(plugin => plugin.qualifier === qualifier),
+                revealPlugin: pluginId => { revealed.push(pluginId); },
+                onDidChange: Event.None
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (category as any).agentPluginUiBridge = bridge;
+        }
+        return category;
+    }
+
+    /**
+     * Leaves the bridge unbound when `managed` is omitted. `managed` maps a skill location to the
+     * registry entry it was installed from, which is how the real bridge keys them.
+     */
+    function categoryWithRegistrySkills(
+        skills: Skill[], managed: Record<string, string> | undefined, revealed: string[] = []
+    ): PromptsAndSkillsConfigurationCategory {
+        const category = categoryWith(skills, []);
+        if (managed) {
+            const bridge: SkillRegistryUiBridge = {
+                getRegistryEntryId: forSkill => managed[forSkill.location],
+                revealSkill: skillId => { revealed.push(skillId); },
+                onDidChange: Event.None
+            };
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (category as any).skillRegistryUiBridge = bridge;
+        }
+        return category;
+    }
+
+    function skillRow(category: PromptsAndSkillsConfigurationCategory, forSkill: Skill): CollapsibleRow {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return (category as any).buildSkillRow(forSkill) as CollapsibleRow;
+    }
+
+    function skill(overrides: Partial<Skill>): Skill {
+        return { name: 'query-builder', qualifiedName: 'query-builder', description: 'Build SQL', location: '/skills/query-builder/SKILL.md', ...overrides } as Skill;
+    }
+
+    it('declares the skills and slash commands single-page metadata', () => {
+        const category = new PromptsAndSkillsConfigurationCategory();
+        expect(category.id).to.equal(AiConfigurationCategoryId.PROMPTS_AND_SKILLS);
+        expect(category.kind).to.equal('single-page');
+    });
+
+    it('indexes skills and slash commands for search, highlighting their rows', () => {
+        const category = categoryWith(
+            [{ name: 'refactor', qualifiedName: 'refactor', description: 'do it', location: '/s' } as unknown as Skill],
+            [{ id: 'cmd', commandName: 'go', commandDescription: 'run' } as unknown as PromptFragment]
+        );
+        const items = category.getSearchItems();
+        const byType = (typeIncludes: string) => items.filter(i => i.typeLabel.toLowerCase().includes(typeIncludes));
+
+        expect(byType('skill')).to.have.lengthOf(1);
+        expect(byType('slash')).to.have.lengthOf(1);
+        expect(items.find(i => i.label === 'refactor')?.target.highlight?.rowId).to.equal('skill:refactor');
+        expect(items.find(i => i.label === '/go')?.target.highlight?.rowId).to.equal('cmd:cmd');
+        expect(items.every(i => i.target.categoryId === AiConfigurationCategoryId.PROMPTS_AND_SKILLS)).to.equal(true);
+    });
+
+    it('does not list skill-backed synthetic commands as slash commands', () => {
+        const category = new PromptsAndSkillsConfigurationCategory();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).promptService = {
+            getCommands: () => [
+                { id: 'skill-command-refactor', commandName: 'refactor', isCommand: true },
+                { id: 'remember', commandName: 'remember', isCommand: true }
+            ] as unknown as PromptFragment[]
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (category as any).loadSlashCommands();
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const commands = (category as any).slashCommands as PromptFragment[];
+        expect(commands.map(command => command.id)).to.deep.equal(['remember']);
+    });
+
+    describe('Agent Plugin provenance', () => {
+
+        const bigquery: InstalledPlugin = { pluginId: 'io.example/bq', name: 'BigQuery Data Analytics', qualifier: 'bigquery' };
+        const contributed = skill({ qualifiedName: 'bigquery:query-builder', location: '/plugins/bigquery/skills/query-builder/SKILL.md' });
+
+        it('keys and titles a skill row by its qualified name, which is what the model addresses', () => {
+            const row = skillRow(categoryWithPlugins([contributed], [bigquery]), contributed);
+            expect(row.id).to.equal('skill:bigquery:query-builder');
+            expect(row.title).to.equal('bigquery:query-builder');
+        });
+
+        it('labels a contributed skill with the shared origin badge naming the plugin that supplied it', () => {
+            const row = skillRow(categoryWithPlugins([contributed], [bigquery]), contributed);
+            // The same descriptor the MCP page builds, so both pages render one badge rather than two designs.
+            expect(row.origins?.map(origin => origin.label)).to.deep.equal(['via BigQuery Data Analytics']);
+            // Filterable by the plugin name too, so a plugin's skills can be listed together.
+            expect(row.filterText).to.contain('bigquery data analytics');
+        });
+
+        it('reveals the owning plugin when the origin badge is activated', () => {
+            const revealed: string[] = [];
+            const row = skillRow(categoryWithPlugins([contributed], [bigquery], revealed), contributed);
+            // Activated directly: rendering the badge as a button is `AiConfigurationOriginBadge`'s
+            // contract, tested where it lives; what belongs here is where this page's badge leads.
+            row.origins![0].activate!();
+            expect(revealed).to.deep.equal([bigquery.pluginId]);
+        });
+
+        it('keeps the provenance out of the pills, which state what the skill is rather than where it came from', () => {
+            const row = skillRow(categoryWithPlugins([contributed], [bigquery]), contributed);
+            expect(row.pills?.some(pill => pill.startsWith('via '))).to.not.equal(true);
+        });
+
+        it('labels nothing for a skill from a built-in root, which is the common case', () => {
+            const own = skill({});
+            expect(skillRow(categoryWithPlugins([own], [bigquery]), own).origins).to.equal(undefined);
+        });
+
+        it('labels nothing rather than a bare qualifier when the qualifier belongs to no installed plugin', () => {
+            const row = skillRow(categoryWithPlugins([contributed], []), contributed);
+            expect(row.origins).to.equal(undefined);
+            expect(row.title).to.equal('bigquery:query-builder');
+        });
+
+        it('labels nothing when no bridge is bound, i.e. without `@theia/ai-registry`', () => {
+            expect(skillRow(categoryWithPlugins([contributed], undefined), contributed).origins).to.equal(undefined);
+        });
+    });
+
+    describe('AI registry provenance', () => {
+
+        const installed = skill({ location: '/home/alex/.agents/skills/query-builder/SKILL.md' });
+        const entryId = 'io.github.acme/query-builder';
+
+        it('labels a registry-installed skill with the shared "From registry" badge', () => {
+            const row = skillRow(categoryWithRegistrySkills([installed], { [installed.location]: entryId }), installed);
+            expect(row.origins?.map(origin => origin.label)).to.deep.equal(['From registry']);
+            expect(row.origins![0].tooltip).to.contain(entryId);
+        });
+
+        it('reveals the registry entry when the badge is activated', () => {
+            const revealed: string[] = [];
+            const row = skillRow(categoryWithRegistrySkills([installed], { [installed.location]: entryId }, revealed), installed);
+            row.origins![0].activate!();
+            expect(revealed).to.deep.equal([entryId]);
+        });
+
+        it('labels nothing for a skill in a directory the user controls', () => {
+            const own = skill({ location: '/workspace/.agents/skills/query-builder/SKILL.md' });
+            expect(skillRow(categoryWithRegistrySkills([own], { [installed.location]: entryId }), own).origins).to.equal(undefined);
+        });
+
+        it('labels nothing when no bridge is bound, i.e. without `@theia/ai-registry`', () => {
+            expect(skillRow(categoryWithRegistrySkills([installed], undefined), installed).origins).to.equal(undefined);
+        });
+
+        it('credits the plugin, not the registry, for a skill a plugin contributed', () => {
+            // A plugin ships its skills inside the plugin, so the two origins cannot both apply; were the
+            // registry consulted anyway, a stale name collision would show a skill as coming from both.
+            const bigquery: InstalledPlugin = { pluginId: 'io.example/bq', name: 'BigQuery', qualifier: 'bigquery' };
+            const contributed = skill({ qualifiedName: 'bigquery:query-builder', location: '/plugins/bigquery/skills/query-builder/SKILL.md' });
+            const category = categoryWithPlugins([contributed], [bigquery]);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (category as any).skillRegistryUiBridge = {
+                getRegistryEntryId: () => entryId,
+                revealSkill: () => { },
+                onDidChange: Event.None
+            } satisfies SkillRegistryUiBridge;
+
+            expect(skillRow(category, contributed).origins?.map(origin => origin.label)).to.deep.equal(['via BigQuery']);
+        });
+    });
+});