@theia/ai-core 1.72.0-next.5 → 1.72.0-next.52

package/src/browser/file-variable-contribution.ts

@@ -71,9 +71,10 @@ export class FileVariableContribution implements AIVariableContribution, AIVaria
 
         try {
             const content = await this.fileService.readFile(uri);
+            const relativePath = this.wsService.getRootPrefixedPath(uri);
             return {
                 variable: request.variable,
-                value: await this.wsService.getWorkspaceRelativePath(uri),
+                value: relativePath,
                 contextValue: content.value.toString(),
             };
         } catch (error) {
@@ -103,9 +104,26 @@ export class FileVariableContribution implements AIVariableContribution, AIVaria
     }
 
     protected async makeAbsolute(pathStr: string): Promise<URI | undefined> {
-        const path = new Path(Path.normalizePathSeparator(pathStr));
+        const normalizedPath = Path.normalizePathSeparator(pathStr);
+        const path = new Path(normalizedPath);
+
         if (!path.isAbsolute) {
             const workspaceRoots = this.wsService.tryGetRoots();
+
+            const segments = normalizedPath.split('/');
+            if (segments.length > 0) {
+                const potentialRootName = segments[0];
+                for (const root of workspaceRoots) {
+                    if (root.resource.path.base === potentialRootName) {
+                        const restOfPath = segments.slice(1).join('/');
+                        const uri = restOfPath ? root.resource.resolve(restOfPath) : root.resource;
+                        if (await this.fileService.exists(uri)) {
+                            return uri;
+                        }
+                    }
+                }
+            }
+
             const wsUris = workspaceRoots.map(root => root.resource.resolve(path));
             for (const uri of wsUris) {
                 if (await this.fileService.exists(uri)) {
@@ -113,6 +131,7 @@ export class FileVariableContribution implements AIVariableContribution, AIVaria
                 }
             }
         }
+
         const argUri = new URI(pathStr);
         if (await this.fileService.exists(argUri)) {
             return argUri;

package/src/browser/frontend-prompt-customization-service.spec.ts

@@ -14,8 +14,20 @@
 // 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 'reflect-metadata';
+
 import { expect } from 'chai';
+import URI from '@theia/core/lib/common/uri';
 import { parseTemplateWithMetadata, ParsedTemplate } from './prompttemplate-parser';
+import { CustomizationSource, DefaultPromptFragmentCustomizationService } from './frontend-prompt-customization-service';
+
+disableJSDOM();
 
 describe('Prompt Template Parser', () => {
 
@@ -199,4 +211,191 @@ Template`;
             expect(result.metadata?.description).to.be.undefined;
         });
     });
+
+    describe('DefaultPromptFragmentCustomizationService - addTemplate conflict resolution', () => {
+        before(() => disableJSDOM = enableJSDOM());
+        after(() => disableJSDOM());
+
+        interface FragmentEntry {
+            id: string;
+            template: string;
+            sourceUri: string;
+            sourceUris: string[];
+            priority: number;
+            origin: CustomizationSource;
+            customizationId: string;
+        }
+
+        /**
+         * Test subclass that exposes the protected `addTemplate` and `provenanceLabel`
+         * methods so we can unit-test conflict resolution without mocking the filesystem.
+         */
+        class TestableCustomizationService extends DefaultPromptFragmentCustomizationService {
+            // Prevent @postConstruct from running (it touches preferences)
+            protected override init(): void { }
+
+            /** Configure fake workspace roots so provenanceLabel can resolve them. */
+            setRoots(rootUris: string[]): void {
+                const roots = rootUris.map(r => new URI(r));
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (this as any).workspaceService = {
+                    getWorkspaceRootUri(uri: URI): URI | undefined {
+                        return roots.find(root => uri.toString().startsWith(root.toString()));
+                    }
+                };
+            }
+
+            public testAddTemplate(
+                active: Map<string, FragmentEntry>,
+                id: string,
+                template: string,
+                sourceUri: string,
+                all: Map<string, FragmentEntry>,
+                priority: number,
+                origin: CustomizationSource
+            ): void {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (this as any).addTemplate(active, id, template, sourceUri, all, priority, origin);
+            }
+
+            public testProvenanceLabel(sourceUri: string): string {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return (this as any).provenanceLabel(sourceUri);
+            }
+        }
+
+        let service: TestableCustomizationService;
+        let activeMap: Map<string, FragmentEntry>;
+        let allMap: Map<string, FragmentEntry>;
+
+        beforeEach(() => {
+            service = new TestableCustomizationService();
+            service.setRoots([
+                'file:///rootA',
+                'file:///rootB',
+                'file:///rootC',
+                'file:///home/user/my-project'
+            ]);
+            activeMap = new Map();
+            allMap = new Map();
+        });
+
+        it('adds a fragment when no conflict exists', () => {
+            const uri = 'file:///rootA/.prompts/project-info.prompttemplate';
+            service.testAddTemplate(
+                activeMap, 'project-info', 'Content A', uri, allMap, 2, CustomizationSource.FOLDER
+            );
+
+            expect(activeMap.has('project-info')).to.be.true;
+            expect(activeMap.get('project-info')!.template).to.equal('Content A');
+            expect(activeMap.get('project-info')!.sourceUris).to.deep.equal([uri]);
+        });
+
+        it('higher priority replaces lower priority', () => {
+            service.testAddTemplate(
+                activeMap, 'project-info', 'Low priority',
+                'file:///rootA/.prompts/project-info.prompttemplate', allMap, 1, CustomizationSource.CUSTOMIZED
+            );
+            service.testAddTemplate(
+                activeMap, 'project-info', 'High priority',
+                'file:///rootB/.prompts/project-info.prompttemplate', allMap, 2, CustomizationSource.FOLDER
+            );
+
+            expect(activeMap.get('project-info')!.template).to.equal('High priority');
+        });
+
+        it('same source URI updates in place', () => {
+            const uri = 'file:///rootA/.prompts/project-info.prompttemplate';
+            service.testAddTemplate(activeMap, 'project-info', 'Original', uri, allMap, 2, CustomizationSource.FOLDER);
+            service.testAddTemplate(activeMap, 'project-info', 'Updated', uri, allMap, 2, CustomizationSource.FOLDER);
+
+            expect(activeMap.get('project-info')!.template).to.equal('Updated');
+            expect(activeMap.get('project-info')!.sourceUris).to.deep.equal([uri]);
+        });
+
+        it('equal priority from different sources concatenates with provenance labels', () => {
+            service.testAddTemplate(
+                activeMap, 'project-info', 'Content A',
+                'file:///rootA/.prompts/project-info.prompttemplate', allMap, 2, CustomizationSource.FOLDER
+            );
+            service.testAddTemplate(
+                activeMap, 'project-info', 'Content B',
+                'file:///rootB/.prompts/project-info.prompttemplate', allMap, 2, CustomizationSource.FOLDER
+            );
+
+            const entry = activeMap.get('project-info')!;
+            expect(entry.sourceUris).to.have.lengthOf(2);
+            expect(entry.template).to.contain('Content A');
+            expect(entry.template).to.contain('Content B');
+            expect(entry.template).to.contain('### rootA');
+            expect(entry.template).to.contain('### rootB');
+        });
+
+        it('three-way merge concatenates all sources in order', () => {
+            service.testAddTemplate(
+                activeMap, 'project-info', 'Content A',
+                'file:///rootA/.prompts/project-info.prompttemplate', allMap, 2, CustomizationSource.FOLDER
+            );
+            service.testAddTemplate(
+                activeMap, 'project-info', 'Content B',
+                'file:///rootB/.prompts/project-info.prompttemplate', allMap, 2, CustomizationSource.FOLDER
+            );
+            service.testAddTemplate(
+                activeMap, 'project-info', 'Content C',
+                'file:///rootC/.prompts/project-info.prompttemplate', allMap, 2, CustomizationSource.FOLDER
+            );
+
+            const entry = activeMap.get('project-info')!;
+            expect(entry.sourceUris).to.have.lengthOf(3);
+            expect(entry.template).to.contain('### rootA');
+            expect(entry.template).to.contain('### rootB');
+            expect(entry.template).to.contain('### rootC');
+            // Verify ordering: A before B before C
+            const idxA = entry.template.indexOf('Content A');
+            const idxB = entry.template.indexOf('Content B');
+            const idxC = entry.template.indexOf('Content C');
+            expect(idxA).to.be.lessThan(idxB);
+            expect(idxB).to.be.lessThan(idxC);
+        });
+
+        it('provenanceLabel extracts grandparent directory name from URI', () => {
+            // For "file:///home/user/my-project/.prompts/foo.prompttemplate"
+            // parent is ".prompts", grandparent is "my-project"
+            const label = service.testProvenanceLabel(
+                'file:///home/user/my-project/.prompts/foo.prompttemplate'
+            );
+            expect(label).to.equal('my-project');
+        });
+
+        it('provenanceLabel falls back to parent if grandparent is empty', () => {
+            expect(service.testProvenanceLabel('file:///.prompts/foo.prompttemplate'))
+                .to.equal('.prompts');
+        });
+
+        it('merged entry preserves primary sourceUri for backwards compatibility', () => {
+            const uriA = 'file:///rootA/.prompts/project-info.prompttemplate';
+            const uriB = 'file:///rootB/.prompts/project-info.prompttemplate';
+            service.testAddTemplate(activeMap, 'project-info', 'Content A', uriA, allMap, 2, CustomizationSource.FOLDER);
+            service.testAddTemplate(activeMap, 'project-info', 'Content B', uriB, allMap, 2, CustomizationSource.FOLDER);
+
+            const entry = activeMap.get('project-info')!;
+            // Primary sourceUri should be the first one added
+            expect(entry.sourceUri).to.equal(uriA);
+            // All sources tracked
+            expect(entry.sourceUris).to.deep.equal([uriA, uriB]);
+        });
+
+        it('all map tracks each source independently', () => {
+            const uriA = 'file:///rootA/.prompts/project-info.prompttemplate';
+            const uriB = 'file:///rootB/.prompts/project-info.prompttemplate';
+            service.testAddTemplate(activeMap, 'project-info', 'Content A', uriA, allMap, 2, CustomizationSource.FOLDER);
+            service.testAddTemplate(activeMap, 'project-info', 'Content B', uriB, allMap, 2, CustomizationSource.FOLDER);
+
+            // allCustomizations is keyed by sourceUri, so both should be present
+            expect(allMap.has(uriA)).to.be.true;
+            expect(allMap.has(uriB)).to.be.true;
+            expect(allMap.get(uriA)!.template).to.equal('Content A');
+            expect(allMap.get(uriB)!.template).to.equal('Content B');
+        });
+    });
 });

package/src/browser/frontend-prompt-customization-service.ts

@@ -27,6 +27,7 @@ import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { dump, load } from 'js-yaml';
 import { PROMPT_TEMPLATE_EXTENSION } from './prompttemplate-contribution';
 import { parseTemplateWithMetadata, ParsedTemplate } from './prompttemplate-parser';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
 
 /**
  * Default template entry for creating custom agents
@@ -89,9 +90,12 @@ interface PromptFragmentCustomization extends CommandPromptFragmentMetadata {
     /** The template content */
     template: string;
 
-    /** Source URI where this template is stored */
+    /** Source URI where this template is stored (first/primary source when merged) */
     sourceUri: string;
 
+    /** All source URIs when multiple equal-priority sources were merged */
+    sourceUris: string[];
+
     /** Source type of the customization */
     origin: CustomizationSource;
 
@@ -136,6 +140,9 @@ export class DefaultPromptFragmentCustomizationService implements PromptFragment
     @inject(ConfigurableInMemoryResources)
     protected readonly inMemoryResources: ConfigurableInMemoryResources;
 
+    @inject(WorkspaceService)
+    protected readonly workspaceService: WorkspaceService;
+
     /** Stores URI strings of template files from directories currently being monitored for changes. */
     protected trackedTemplateURIs = new Set<string>();
 
@@ -240,6 +247,7 @@ export class DefaultPromptFragmentCustomizationService implements PromptFragment
             id,
             template,
             sourceUri,
+            sourceUris: [sourceUri],
             priority,
             customizationId,
             origin,
@@ -262,6 +270,16 @@ export class DefaultPromptFragmentCustomizationService implements PromptFragment
         const existingEntry = activeCustomizationsCopy.get(id);
 
         if (existingEntry) {
+            // If the existing entry was merged from multiple sources and we're
+            // operating on the live maps (incremental watcher update), a single
+            // file change can't reconstruct the merge correctly. Schedule a
+            // full rebuild instead. During update() the maps are fresh locals,
+            // so this check won't fire.
+            if (existingEntry.sourceUris.length > 1 && activeCustomizationsCopy === this.activeCustomizations) {
+                this.update();
+                return;
+            }
+
             // If this is an update to the same file (same source URI)
             if (sourceUri && existingEntry.sourceUri === sourceUri) {
                 // Update the content while keeping the same priority and source
@@ -274,9 +292,17 @@ export class DefaultPromptFragmentCustomizationService implements PromptFragment
                 activeCustomizationsCopy.set(id, customization);
                 return;
             } else if (priority === existingEntry.priority) {
-                // There is a conflict with the same priority, we ignore the new customization
-                const conflictSourceUri = existingEntry.sourceUri ? ` (Existing source: ${existingEntry.sourceUri}, New source: ${sourceUri})` : '';
-                console.warn(`Fragment conflict detected for ID '${id}' with equal priority.${conflictSourceUri}`);
+                // Same priority from different sources: concatenate with provenance labels.
+                // Build a new object so we don't mutate the entry shared with allCustomizationsCopy.
+                const existingLabel = this.provenanceLabel(existingEntry.sourceUri);
+                const newLabel = this.provenanceLabel(sourceUri);
+                const mergedTemplate = `### ${existingLabel}\n\n${existingEntry.template}\n\n### ${newLabel}\n\n${template}`;
+                const mergedEntry: PromptFragmentCustomization = {
+                    ...existingEntry,
+                    template: mergedTemplate,
+                    sourceUris: [...existingEntry.sourceUris, sourceUri],
+                };
+                activeCustomizationsCopy.set(id, mergedEntry);
             }
             return;
         }
@@ -298,6 +324,24 @@ export class DefaultPromptFragmentCustomizationService implements PromptFragment
         return `${id}_${sourceHash}`;
     }
 
+    /**
+     * Extracts a human-readable provenance label from a source URI.
+     * Returns the name of the workspace root that contains the file,
+     * falling back to the file's own base name if it is not inside any root.
+     */
+    protected provenanceLabel(uri: string): string {
+        try {
+            const parsed = new URI(uri);
+            const rootUri = this.workspaceService.getWorkspaceRootUri(parsed);
+            if (rootUri) {
+                return rootUri.path.base;
+            }
+            return parsed.path.dir.base || parsed.path.base || uri;
+        } catch {
+            return uri;
+        }
+    }
+
     /**
      * Simple hash function to generate a short identifier from a string
      * @param str The string to hash

package/src/browser/generic-capabilities-variable-contribution.spec.ts

@@ -27,9 +27,12 @@ import {
     GenericCapabilitiesVariableContribution,
     SELECTED_SKILLS_VARIABLE,
     SELECTED_FUNCTIONS_VARIABLE,
+    SELECTED_MCP_FUNCTIONS_VARIABLE,
     SELECTED_VARIABLES_VARIABLE
 } from './generic-capabilities-variable-contribution';
 import { CapabilityAwareContext } from '../common/capability-utils';
+import { ToolInvocationRegistry } from '../common/tool-invocation-registry';
+import { ToolRequest } from '../common/language-model';
 
 disableJSDOM();
 
@@ -39,6 +42,22 @@ describe('GenericCapabilitiesVariableContribution', () => {
     let contribution: GenericCapabilitiesVariableContribution;
     let container: Container;
 
+    function createMockToolInvocationRegistry(registeredToolIds: string[]): ToolInvocationRegistry {
+        const tools = new Map<string, ToolRequest>();
+        for (const id of registeredToolIds) {
+            tools.set(id, { id, providerName: 'test', parameters: {}, handler: async () => '' } as unknown as ToolRequest);
+        }
+        return {
+            getFunction: (toolId: string) => tools.get(toolId),
+            getFunctions: (...toolIds: string[]) => toolIds.map(id => tools.get(id)).filter((t): t is ToolRequest => t !== undefined),
+            registerTool: () => { },
+            unregisterTool: () => { },
+            unregisterAllTools: () => { },
+            getAllFunctions: () => Array.from(tools.values()),
+            onDidChange: () => ({ dispose: () => { } }),
+        } as unknown as ToolInvocationRegistry;
+    }
+
     beforeEach(() => {
         container = new Container();
         container.bind<GenericCapabilitiesVariableContribution>(GenericCapabilitiesVariableContribution).toSelf().inSingletonScope();
@@ -80,6 +99,95 @@ describe('GenericCapabilitiesVariableContribution', () => {
     });
 
     describe('resolve', () => {
+        describe('resolveSelectedFunctions filtering', () => {
+            it('returns empty string when toolInvocationRegistry is not available', async () => {
+                const context: CapabilityAwareContext = {
+                    genericCapabilitySelections: {
+                        functions: ['tool1', 'tool2']
+                    }
+                };
+
+                const result = await contribution.resolve(
+                    { variable: SELECTED_FUNCTIONS_VARIABLE },
+                    context
+                );
+
+                expect(result?.value).to.equal('');
+            });
+
+            it('filters out stale tool IDs that are not in the registry', async () => {
+                const mockRegistry = createMockToolInvocationRegistry(['tool1', 'tool3']);
+                (contribution as unknown as { toolInvocationRegistry: ToolInvocationRegistry }).toolInvocationRegistry = mockRegistry;
+
+                const context: CapabilityAwareContext = {
+                    genericCapabilitySelections: {
+                        functions: ['tool1', 'tool2_stale', 'tool3']
+                    }
+                };
+
+                const result = await contribution.resolve(
+                    { variable: SELECTED_FUNCTIONS_VARIABLE },
+                    context
+                );
+
+                expect(result?.value).to.equal('~{tool1}\n~{tool3}');
+            });
+
+            it('returns empty string when all tool IDs are stale', async () => {
+                const mockRegistry = createMockToolInvocationRegistry([]);
+                (contribution as unknown as { toolInvocationRegistry: ToolInvocationRegistry }).toolInvocationRegistry = mockRegistry;
+
+                const context: CapabilityAwareContext = {
+                    genericCapabilitySelections: {
+                        functions: ['stale1', 'stale2']
+                    }
+                };
+
+                const result = await contribution.resolve(
+                    { variable: SELECTED_FUNCTIONS_VARIABLE },
+                    context
+                );
+
+                expect(result?.value).to.equal('');
+            });
+
+            it('returns all tool references when all IDs are valid', async () => {
+                const mockRegistry = createMockToolInvocationRegistry(['tool1', 'tool2']);
+                (contribution as unknown as { toolInvocationRegistry: ToolInvocationRegistry }).toolInvocationRegistry = mockRegistry;
+
+                const context: CapabilityAwareContext = {
+                    genericCapabilitySelections: {
+                        functions: ['tool1', 'tool2']
+                    }
+                };
+
+                const result = await contribution.resolve(
+                    { variable: SELECTED_FUNCTIONS_VARIABLE },
+                    context
+                );
+
+                expect(result?.value).to.equal('~{tool1}\n~{tool2}');
+            });
+
+            it('filters stale MCP function IDs the same way', async () => {
+                const mockRegistry = createMockToolInvocationRegistry(['mcp_fetch_fetch']);
+                (contribution as unknown as { toolInvocationRegistry: ToolInvocationRegistry }).toolInvocationRegistry = mockRegistry;
+
+                const context: CapabilityAwareContext = {
+                    genericCapabilitySelections: {
+                        mcpFunctions: ['mcp_fetch_fetch', 'mcp_removed_server_tool']
+                    }
+                };
+
+                const result = await contribution.resolve(
+                    { variable: SELECTED_MCP_FUNCTIONS_VARIABLE },
+                    context
+                );
+
+                expect(result?.value).to.equal('~{mcp_fetch_fetch}');
+            });
+        });
+
         it('returns empty string when no selections exist', async () => {
             const context: CapabilityAwareContext = {};
 

package/src/browser/generic-capabilities-variable-contribution.ts

@@ -27,7 +27,8 @@ import {
     ResolvedAIVariable,
     CapabilityAwareContext,
     AgentService,
-    AgentsVariableContribution
+    AgentsVariableContribution,
+    ToolInvocationRegistry
 } from '../common';
 import { PromptVariableContribution } from './prompt-variable-contribution';
 import { SkillService } from './skill-service';
@@ -105,6 +106,9 @@ export class GenericCapabilitiesVariableContribution implements AIVariableContri
     @inject(AgentsVariableContribution) @optional()
     protected readonly agentsContribution: AgentsVariableContribution | undefined;
 
+    @inject(ToolInvocationRegistry) @optional()
+    protected readonly toolInvocationRegistry: ToolInvocationRegistry | undefined;
+
     @inject(PromptVariableContribution) @optional()
     protected readonly promptContribution: PromptVariableContribution | undefined;
 
@@ -170,12 +174,20 @@ export class GenericCapabilitiesVariableContribution implements AIVariableContri
      * The chat request parser will pick these up and add them to the toolRequests map.
      */
     protected resolveSelectedFunctions(variable: AIVariable, functionIds: string[] | undefined): ResolvedAIVariable {
-        if (!functionIds || functionIds.length === 0) {
+        if (!functionIds || functionIds.length === 0 || !this.toolInvocationRegistry) {
+            return { variable, value: '' };
+        }
+
+        // Filter out stale/orphaned tool IDs that no longer exist in the registry
+        const validIds = functionIds
+            .filter(id => this.toolInvocationRegistry!.getFunction(id) !== undefined);
+
+        if (validIds.length === 0) {
             return { variable, value: '' };
         }
 
         // Output function references in ~{id} format so the chat parser picks them up
-        const functionRefs = functionIds.map(id => `~{${id}}`).join('\n');
+        const functionRefs = validIds.map(id => `~{${id}}`).join('\n');
         return { variable, value: functionRefs };
     }
 

package/src/browser/open-editors-variable-contribution.ts

@@ -23,7 +23,8 @@ import { AIVariable, ResolvedAIVariable, AIVariableContribution, AIVariableResol
 
 export const OPEN_EDITORS_VARIABLE: AIVariable = {
     id: 'openEditors',
-    description: nls.localize('theia/ai/core/openEditorsVariable/description', 'A comma-separated list of all currently open files, relative to the workspace root.'),
+    description: nls.localize('theia/ai/core/openEditorsVariable/description',
+        'A comma-separated list of all currently open files as workspace-relative paths (e.g., my-project/src/index.ts).'),
     name: 'openEditors',
 };
 
@@ -80,9 +81,7 @@ export class OpenEditorsVariableContribution implements AIVariableContribution,
         return openFiles.join(', ');
     }
 
-    protected getWorkspaceRelativePath(uri: URI): string | undefined {
-        const workspaceRootUri = this.workspaceService.getWorkspaceRootUri(uri);
-        const path = workspaceRootUri && workspaceRootUri.path.relative(uri.path);
-        return path && path.toString();
+    protected getWorkspaceRelativePath(uri: URI): string {
+        return this.workspaceService.getRootPrefixedPath(uri);
     }
 }

package/src/browser/skill-service.ts

@@ -171,7 +171,7 @@ export class DefaultSkillService implements SkillService {
         const newDisposables = new DisposableCollection();
         const newSkills = new Map<string, Skill>();
 
-        const workspaceSkillsDir = this.getWorkspaceSkillsDirectoryPath();
+        const workspaceSkillsDirs = this.getWorkspaceSkillsDirectoryPaths();
 
         const homeDirUri = await this.envVariablesServer.getHomeDirUri();
         const homePath = new URI(homeDirUri).path.fsPath();
@@ -183,7 +183,7 @@ export class DefaultSkillService implements SkillService {
         const newWatchedDirectories = new Set<string>();
         const newParentWatchers = new Map<string, string>();
 
-        if (workspaceSkillsDir) {
+        for (const workspaceSkillsDir of workspaceSkillsDirs) {
             await this.processSkillDirectoryWithParentWatching(
                 workspaceSkillsDir,
                 newSkills,
@@ -223,13 +223,9 @@ export class DefaultSkillService implements SkillService {
         this.onSkillsChangedEmitter.fire();
     }
 
-    protected getWorkspaceSkillsDirectoryPath(): string | undefined {
-        const roots = this.workspaceService.tryGetRoots();
-        if (roots.length === 0) {
-            return undefined;
-        }
-        // Use primary workspace root
-        return roots[0].resource.resolve('.prompts/skills').path.fsPath();
+    protected getWorkspaceSkillsDirectoryPaths(): string[] {
+        return this.workspaceService.tryGetRoots()
+            .map(root => root.resource.resolve('.prompts/skills').path.fsPath());
     }
 
     protected async getDefaultSkillsDirectoryPath(): Promise<string> {

package/src/browser/theia-variable-contribution.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
 import { nls } from '@theia/core/lib/common/nls';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { VariableRegistry, VariableResolverService } from '@theia/variable-resolver/lib/browser';
@@ -51,41 +52,39 @@ export class TheiaVariableContribution implements AIVariableContribution, AIVari
             {
                 name: 'currentAbsoluteFilePath',
                 description: nls.localize('theia/ai/core/variable-contribution/currentAbsoluteFilePath', 'The absolute path of the \
-                currently opened file. Please note that most agents will expect a relative file path (relative to the current workspace).')
+                currently opened file.')
             }
         ]],
         ['selectedText', [
             {
                 description: nls.localize('theia/ai/core/variable-contribution/currentSelectedText', 'The plain text that is currently selected in the \
-                opened file. This excludes the information where the content is coming from. Please note that most agents will work better with a relative file path \
-                (relative to the current workspace).')
+                opened file. This excludes the information where the content is coming from.')
             }
         ]],
         ['currentText', [
             {
                 name: 'currentFileContent',
                 description: nls.localize('theia/ai/core/variable-contribution/currentFileContent', 'The plain content of the \
-                currently opened file. This excludes the information where the content is coming from. Please note that most agents will work better with a relative file path \
-                (relative to the current workspace).')
+                currently opened file. This excludes the information where the content is coming from.')
             }
         ]],
         ['relativeFile', [
             {
                 name: 'currentRelativeFilePath',
-                description: nls.localize('theia/ai/core/variable-contribution/currentRelativeFilePath', 'The relative path of the \
-                currently opened file.')
+                description: nls.localize('theia/ai/core/variable-contribution/currentRelativeFilePath', 'The workspace-relative path of the \
+                currently opened file (e.g., my-project/src/index.ts).')
             },
             {
                 name: '_f',
-                description: nls.localize('theia/ai/core/variable-contribution/dotRelativePath', 'Short reference to the relative path of the \
+                description: nls.localize('theia/ai/core/variable-contribution/dotRelativePath', 'Short reference to the workspace-relative path of the \
                 currently opened file (\'currentRelativeFilePath\').')
             }
         ]],
         ['relativeFileDirname', [
             {
                 name: 'currentRelativeDirPath',
-                description: nls.localize('theia/ai/core/variable-contribution/currentRelativeDirPath', 'The relative path of the directory \
-                containing the currently opened file.')
+                description: nls.localize('theia/ai/core/variable-contribution/currentRelativeDirPath', 'The workspace-relative path of the directory \
+                containing the currently opened file (e.g., my-project/src).')
             }
         ]],
         ['lineNumber', [{}]],
@@ -108,7 +107,9 @@ export class TheiaVariableContribution implements AIVariableContribution, AIVari
                     const newName = (mapping.name && mapping.name.trim() !== '') ? mapping.name : variable.name;
                     const newDescription = (mapping.description && mapping.description.trim() !== '') ? mapping.description
                         : (variable.description && variable.description.trim() !== '' ? variable.description
-                            : nls.localize('theia/ai/core/variable-contribution/builtInVariable', 'Theia Built-in Variable'));
+                            : nls.localize('theia/ai/core/variable-contribution/builtInVariable',
+                            '{0} Built-in Variable',
+                            FrontendApplicationConfigProvider.get().applicationName));
 
                     // For multiple mappings of the same variable, add a suffix to the ID to make it unique
                     const idSuffix = mappings.length > 1 ? `-${index}` : '';