@theia/ai-core 1.74.0-next.5 → 1.74.0-next.53

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

@@ -23,9 +23,10 @@ FrontendApplicationConfigProvider.set({});
 import 'reflect-metadata';
 
 import { expect } from 'chai';
-import { dump } from 'js-yaml';
+import { dump, load } from 'js-yaml';
 import URI from '@theia/core/lib/common/uri';
 import { parseTemplateWithMetadata, ParsedTemplate } from './prompttemplate-parser';
+import { serializeFrontmatter } from '../common/frontmatter';
 import {
     CustomizationSource, DefaultPromptFragmentCustomizationService, CUSTOM_AGENTS_DIRECTORY, CUSTOM_AGENT_FILE_NAME
 } from './frontend-prompt-customization-service';
@@ -518,6 +519,12 @@ describe('DefaultPromptFragmentCustomizationService - customAgents.yml migration
         protected override getTemplatesDirectoryURI(): Promise<URI> {
             return Promise.resolve(this.templatesDir);
         }
+        testParse(raw: string): unknown {
+            return this.parseCustomAgentsYaml(raw);
+        }
+        testUnfold(raw: string): string {
+            return this.unfoldPromptBlockScalars(raw);
+        }
     }
 
     const scope = new URI('file:///ws/.prompts');
@@ -617,6 +624,128 @@ describe('DefaultPromptFragmentCustomizationService - customAgents.yml migration
         // ...and because a backup already exists, the yaml is left untouched for inspection.
         expect(await fileService.exists(yamlURI)).to.be.true;
     });
+
+    describe('folded block-scalar prompts', () => {
+        // A folded YAML scalar (`>-`) collapses single newlines into spaces, which merges markdown
+        // headings into the paragraph below them. Migration must recover the original line breaks.
+        const foldedYaml =
+            '- id: rel\n' +
+            '  name: Rel\n' +
+            '  description: Release agent\n' +
+            '  defaultLLM: default/code\n' +
+            '  prompt: >-\n' +
+            '    ## Task\n' +
+            '    Do the thing.\n' +
+            '\n' +
+            '    ## Workflow\n' +
+            '    Step one.\n';
+
+        it('migrates a folded prompt with its headings on separate lines', async () => {
+            fileService.write(yamlURI, foldedYaml);
+
+            const [report] = await service.migrateCustomAgentsYaml();
+
+            expect(report.migrated).to.equal(1);
+            const content = fileService.content(agentMd('rel'))!;
+            // js-yaml would have folded these into '## Task Do the thing.'; the fix keeps them split.
+            expect(content).to.contain('## Task\nDo the thing.');
+            expect(content).to.contain('## Workflow\nStep one.');
+            expect(content).to.not.contain('## Task Do the thing.');
+        });
+
+        it('loads an un-migrated folded prompt with separated headings at runtime', async () => {
+            fileService.write(yamlURI, foldedYaml);
+
+            const [agent] = await service.getCustomAgents();
+
+            expect(agent.prompt).to.contain('## Task\nDo the thing.');
+            expect(agent.prompt).to.not.contain('## Task Do the thing.');
+        });
+
+        it('leaves plain and quoted prompt values untouched', () => {
+            const plain = 'prompt: just a short prompt';
+            const quoted = 'prompt: "> not a header"';
+            expect(service.testUnfold(plain)).to.equal(plain);
+            expect(service.testUnfold(quoted)).to.equal(quoted);
+            // Folded headers (with or without indicators) become literal.
+            expect(service.testUnfold('prompt: >-')).to.equal('prompt: |-');
+            expect(service.testUnfold('prompt: >2-')).to.equal('prompt: |2-');
+        });
+    });
+
+    describe('correcting already-migrated agents', () => {
+        // Reproduces the bytes the v1.73.0 migration wrote: parse the backup the old (folded) way and
+        // serialize it with the same frontmatter format the migration used.
+        const buggyAgentMd = (raw: string, id: string): string => {
+            const entry = (load(raw) as Array<{ id: string; name: string; description: string; prompt: string; defaultLLM: string }>).find(e => e.id === id)!;
+            return serializeFrontmatter({ name: entry.name, description: entry.description, defaultLLM: entry.defaultLLM }, entry.prompt);
+        };
+        const foldedYaml =
+            '- id: rel\n' +
+            '  name: Rel\n' +
+            '  description: Release agent\n' +
+            '  defaultLLM: default/code\n' +
+            '  prompt: >-\n' +
+            '    ## Task\n' +
+            '    Do the thing.\n';
+
+        it('rewrites an untouched agent.md to recover folded headings', async () => {
+            // Simulate the post-v1.73.0 state: yaml already backed up, agent.md written with merged headings.
+            fileService.write(backupURI, foldedYaml);
+            fileService.write(agentMd('rel'), buggyAgentMd(foldedYaml, 'rel'));
+
+            const [report] = await service.migrateCustomAgentsYaml();
+
+            expect(report.corrected).to.equal(1);
+            expect(fileService.content(agentMd('rel'))!).to.contain('## Task\nDo the thing.');
+        });
+
+        it('does not touch an agent.md the user edited after migration', async () => {
+            fileService.write(backupURI, foldedYaml);
+            const edited = buggyAgentMd(foldedYaml, 'rel') + '\n\nManually added section.';
+            fileService.write(agentMd('rel'), edited);
+
+            const reports = await service.migrateCustomAgentsYaml();
+
+            // Nothing is migrated and the edited file is not eligible for correction, so no report.
+            expect(reports).to.have.lengthOf(0);
+            expect(fileService.content(agentMd('rel'))).to.equal(edited);
+        });
+
+        it('reports nothing to do when the backup prompt has no folded headings', async () => {
+            fileService.write(backupURI, dump(agents));
+            fileService.write(agentMd('foo'), buggyAgentMd(dump(agents), 'foo'));
+
+            const reports = await service.migrateCustomAgentsYaml();
+
+            // Nothing to migrate and nothing correctable -> no report for the scope.
+            expect(reports).to.have.lengthOf(0);
+        });
+    });
+
+    describe('hasPendingCustomAgentMigration', () => {
+        it('is true while a legacy customAgents.yml exists', async () => {
+            fileService.write(yamlURI, dump(agents));
+            expect(await service.hasPendingCustomAgentMigration()).to.be.true;
+        });
+
+        it('is true when a backup has correctable agents', async () => {
+            const foldedYaml =
+                '- id: rel\n  name: Rel\n  description: d\n  defaultLLM: default/code\n  prompt: >-\n    ## Task\n    Body.\n';
+            fileService.write(backupURI, foldedYaml);
+            const entry = (load(foldedYaml) as Array<{ name: string; description: string; prompt: string; defaultLLM: string }>)[0];
+            fileService.write(agentMd('rel'), serializeFrontmatter({ name: entry.name, description: entry.description, defaultLLM: entry.defaultLLM }, entry.prompt));
+
+            expect(await service.hasPendingCustomAgentMigration()).to.be.true;
+        });
+
+        it('is false once everything is migrated and correct', async () => {
+            fileService.write(yamlURI, dump(agents));
+            await service.migrateCustomAgentsYaml();
+
+            expect(await service.hasPendingCustomAgentMigration()).to.be.false;
+        });
+    });
 });
 
 describe('DefaultPromptFragmentCustomizationService - custom agent scopes', () => {

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

@@ -1669,7 +1669,7 @@ export class DefaultPromptFragmentCustomizationService implements PromptFragment
 
         try {
             const fileContent = await this.fileService.read(customAgentYamlUri, { encoding: 'utf-8' });
-            const doc = load(fileContent.value);
+            const doc = this.parseCustomAgentsYaml(fileContent.value);
 
             if (!Array.isArray(doc) || !doc.every(entry => CustomAgentDescription.is(entry))) {
                 this.logger.debug(`Invalid customAgents.yml file content in ${directoryURI.toString()}`);
@@ -1736,6 +1736,47 @@ export class DefaultPromptFragmentCustomizationService implements PromptFragment
         return fileURI;
     }
 
+    /**
+     * Parse a `customAgents.yml` document, preserving newlines in folded-block-scalar prompts.
+     *
+     * `js-yaml` folds the single newlines of a folded scalar (`>` / `>-`) into spaces, which merges
+     * a markdown heading (`## Task`) into the paragraph below it. Markdown is newline-sensitive, so
+     * we re-interpret folded `prompt:` scalars as literal (`|`) before parsing. Only the block-scalar
+     * header is rewritten; quoted, plain and already-literal values are left untouched.
+     *
+     * Known limitation: prompts stored as a plain or quoted multi-line scalar (rare) still fold.
+     */
+    protected parseCustomAgentsYaml(content: string): unknown {
+        return load(this.unfoldPromptBlockScalars(content));
+    }
+
+    /**
+     * Rewrite a folded `prompt:` block-scalar header (`>`, `>-`, `>+`, `>2-`, ...) to its literal
+     * equivalent (`|`...). The lookahead ensures only a block-scalar header is matched (indentation
+     * and chomping indicators plus an optional trailing comment), so plain/quoted prompt values and
+     * any `>` inside the prompt body are never touched.
+     */
+    protected unfoldPromptBlockScalars(content: string): string {
+        return content.replace(/^([ \t]*prompt:[ \t]*)>(?=[-+0-9]*[ \t]*(?:#.*)?$)/mg, '$1|');
+    }
+
+    /**
+     * Returns `true` if migration would write anything: a scope still holds a legacy
+     * `customAgents.yml`, or a previously migrated scope has `agent.md` files that can be corrected
+     * (see {@link computeScopeCorrections}). Read-only; used to decide whether to prompt the user.
+     */
+    async hasPendingCustomAgentMigration(): Promise<boolean> {
+        for (const scope of await this.getCustomAgentScopes()) {
+            if (await this.fileService.exists(scope.resolve('customAgents.yml'))) {
+                return true;
+            }
+            if ((await this.computeScopeCorrections(scope)).length > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     /**
      * Auto-migrate every legacy `customAgents.yml` reachable from the configured scopes to the new
      * `agents/<id>/agent.md` layout. The original content is never deleted:
@@ -1769,7 +1810,7 @@ export class DefaultPromptFragmentCustomizationService implements PromptFragment
                 reports.push(report);
             }
         }
-        if (reports.some(r => r.migrated > 0)) {
+        if (reports.some(r => r.migrated > 0 || r.corrected > 0)) {
             this.onDidChangeCustomAgentsEmitter.fire();
         }
         return reports;
@@ -1777,116 +1818,193 @@ export class DefaultPromptFragmentCustomizationService implements PromptFragment
 
     protected async migrateSingleScope(scopeDir: URI): Promise<MigrationReport | undefined> {
         const yamlURI = scopeDir.resolve('customAgents.yml');
-        if (!(await this.fileService.exists(yamlURI))) {
-            return undefined;
-        }
-        this.logger.info(`Migrating custom agents from ${yamlURI.toString()}`);
-        let entries: CustomAgentDescription[];
-        try {
-            const fileContent = await this.fileService.read(yamlURI, { encoding: 'utf-8' });
-            const doc = load(fileContent.value);
-            if (!Array.isArray(doc) || !doc.every(CustomAgentDescription.is)) {
-                this.logger.warn(`Skipping migration of ${yamlURI.toString()}: file content is not a valid CustomAgentDescription[]`);
-                return { scope: scopeDir, yamlURI, migrated: 0, alreadyPresent: 0, failed: 0, yamlBackedUp: false, promptOverridesMigrated: 0 };
-            }
-            entries = doc;
-        } catch (e) {
-            this.logger.warn(`Skipping migration of ${yamlURI.toString()}: ${e.message}`);
-            return { scope: scopeDir, yamlURI, migrated: 0, alreadyPresent: 0, failed: 0, yamlBackedUp: false, promptOverridesMigrated: 0 };
-        }
+        const backupURI = scopeDir.resolve('customAgents.yml.bak');
+        const yamlExists = await this.fileService.exists(yamlURI);
 
         let migrated = 0;
         let alreadyPresent = 0;
         let failed = 0;
         let promptOverridesMigrated = 0;
+        let yamlBackedUp = false;
 
-        // A previous failed migration may have created `agents/<id>/` directories without an
-        // `agent.md` inside. Remove those empty placeholders so this run can recreate them cleanly.
-        await this.cleanupEmptyAgentFolders(scopeDir);
+        const emptyReport = (): MigrationReport => ({
+            scope: scopeDir, yamlURI, migrated: 0, alreadyPresent: 0, failed: 0,
+            yamlBackedUp: false, promptOverridesMigrated: 0, corrected: 0
+        });
 
-        // Snapshot scope-root template files once so we can match per agent without re-listing.
-        const scopeRootTemplateFiles = await this.listScopeRootPromptTemplates(scopeDir);
+        if (yamlExists) {
+            this.logger.info(`Migrating custom agents from ${yamlURI.toString()}`);
+            let entries: CustomAgentDescription[];
+            try {
+                const fileContent = await this.fileService.read(yamlURI, { encoding: 'utf-8' });
+                const doc = this.parseCustomAgentsYaml(fileContent.value);
+                if (!Array.isArray(doc) || !doc.every(CustomAgentDescription.is)) {
+                    this.logger.warn(`Skipping migration of ${yamlURI.toString()}: file content is not a valid CustomAgentDescription[]`);
+                    return emptyReport();
+                }
+                entries = doc;
+            } catch (e) {
+                this.logger.warn(`Skipping migration of ${yamlURI.toString()}: ${e.message}`);
+                return emptyReport();
+            }
 
-        // Prompt-fragment files are matched by agent *name* (the fragment id is `<name>_prompt`)
-        // while folders are keyed by the unique *id*. When two entries share a name, only the first
-        // can own the name-based files, so track seen names and skip the move for the duplicates.
-        const seenNames = new Set<string>();
+            // A previous failed migration may have created `agents/<id>/` directories without an
+            // `agent.md` inside. Remove those empty placeholders so this run can recreate them cleanly.
+            await this.cleanupEmptyAgentFolders(scopeDir);
 
-        for (const entry of entries) {
-            const agentFolderURI = scopeDir.resolve(CUSTOM_AGENTS_DIRECTORY).resolve(entry.id);
-            const targetURI = agentFolderURI.resolve(CUSTOM_AGENT_FILE_NAME);
-            if (await this.fileService.exists(targetURI)) {
-                alreadyPresent++;
-            } else {
-                try {
-                    await this.fileService.createFile(
-                        targetURI,
-                        BinaryBuffer.fromString(serializeCustomAgentFile(entry)),
-                        { overwrite: true }
+            // Snapshot scope-root template files once so we can match per agent without re-listing.
+            const scopeRootTemplateFiles = await this.listScopeRootPromptTemplates(scopeDir);
+
+            // Prompt-fragment files are matched by agent *name* (the fragment id is `<name>_prompt`)
+            // while folders are keyed by the unique *id*. When two entries share a name, only the first
+            // can own the name-based files, so track seen names and skip the move for the duplicates.
+            const seenNames = new Set<string>();
+
+            for (const entry of entries) {
+                const agentFolderURI = scopeDir.resolve(CUSTOM_AGENTS_DIRECTORY).resolve(entry.id);
+                const targetURI = agentFolderURI.resolve(CUSTOM_AGENT_FILE_NAME);
+                if (await this.fileService.exists(targetURI)) {
+                    alreadyPresent++;
+                } else {
+                    try {
+                        await this.fileService.createFile(
+                            targetURI,
+                            BinaryBuffer.fromString(serializeCustomAgentFile(entry)),
+                            { overwrite: true }
+                        );
+                        migrated++;
+                    } catch (e) {
+                        this.logger.warn(`Failed to migrate agent '${entry.id}' from ${yamlURI.toString()}: ${e?.message ?? e}`, e);
+                        failed++;
+                        continue;
+                    }
+                }
+
+                if (seenNames.has(entry.name)) {
+                    this.logger.warn(
+                        `Multiple custom agents in ${yamlURI.toString()} share the name '${entry.name}'; ` +
+                        'prompt fragment files were migrated to the first matching agent only.'
                     );
-                    migrated++;
-                } catch (e) {
-                    this.logger.warn(`Failed to migrate agent '${entry.id}' from ${yamlURI.toString()}: ${e?.message ?? e}`, e);
-                    failed++;
                     continue;
                 }
+                seenNames.add(entry.name);
+
+                // Move any scope-root .prompttemplate files that look like they belong to this agent
+                // (filename stem starts with `<name>_prompt`, followed by EOF or a separator).
+                // They become variants under `<scope>/agents/<id>/`.
+                for (const file of scopeRootTemplateFiles) {
+                    if (!matchesAgentPromptPrefix(file.stem, entry.name)) {
+                        continue;
+                    }
+                    const destURI = agentFolderURI.resolve(file.uri.path.base);
+                    if (await this.fileService.exists(destURI)) {
+                        continue;
+                    }
+                    try {
+                        await this.fileService.move(file.uri, destURI);
+                        promptOverridesMigrated++;
+                    } catch (e) {
+                        this.logger.warn(`Failed to move prompt fragment ${file.uri.toString()} into ${destURI.toString()}: ${e?.message ?? e}`);
+                    }
+                }
             }
 
-            if (seenNames.has(entry.name)) {
-                this.logger.warn(
-                    `Multiple custom agents in ${yamlURI.toString()} share the name '${entry.name}'; ` +
-                    'prompt fragment files were migrated to the first matching agent only.'
-                );
-                continue;
-            }
-            seenNames.add(entry.name);
-
-            // Move any scope-root .prompttemplate files that look like they belong to this agent
-            // (filename stem starts with `<name>_prompt`, followed by EOF or a separator).
-            // They become variants under `<scope>/agents/<id>/`.
-            for (const file of scopeRootTemplateFiles) {
-                if (!matchesAgentPromptPrefix(file.stem, entry.name)) {
-                    continue;
-                }
-                const destURI = agentFolderURI.resolve(file.uri.path.base);
-                if (await this.fileService.exists(destURI)) {
-                    continue;
+            if (failed === 0) {
+                try {
+                    await this.fileService.move(yamlURI, backupURI, { overwrite: true });
+                    yamlBackedUp = true;
+                } catch (e) {
+                    this.logger.warn(`Migrated ${migrated} agents but failed to back up ${yamlURI.toString()}: ${e.message}`);
                 }
+            } else {
                 try {
-                    await this.fileService.move(file.uri, destURI);
-                    promptOverridesMigrated++;
+                    if (!(await this.fileService.exists(backupURI))) {
+                        await this.fileService.move(yamlURI, backupURI);
+                        yamlBackedUp = true;
+                    }
                 } catch (e) {
-                    this.logger.warn(`Failed to move prompt fragment ${file.uri.toString()} into ${destURI.toString()}: ${e?.message ?? e}`);
+                    this.logger.warn(`Failed to back up ${yamlURI.toString()} to ${backupURI.toString()}: ${e.message}`);
                 }
             }
         }
 
-        let yamlBackedUp = false;
-        const backupURI = scopeDir.resolve('customAgents.yml.bak');
-        if (failed === 0) {
+        // Correct any `agent.md` left with merged headings by an earlier (v1.73.0) migration. Anything
+        // just migrated above is already correct, so only stale files from a previous run are rewritten.
+        let corrected = 0;
+        for (const { uri, content } of await this.computeScopeCorrections(scopeDir)) {
             try {
-                await this.fileService.move(yamlURI, backupURI, { overwrite: true });
-                yamlBackedUp = true;
+                await this.fileService.createFile(uri, BinaryBuffer.fromString(content), { overwrite: true });
+                corrected++;
             } catch (e) {
-                this.logger.warn(`Migrated ${migrated} agents but failed to back up ${yamlURI.toString()}: ${e.message}`);
-            }
-        } else {
-            try {
-                if (!(await this.fileService.exists(backupURI))) {
-                    await this.fileService.move(yamlURI, backupURI);
-                    yamlBackedUp = true;
-                }
-            } catch (e) {
-                this.logger.warn(`Failed to back up ${yamlURI.toString()} to ${backupURI.toString()}: ${e.message}`);
+                this.logger.warn(`Failed to correct migrated agent file ${uri.toString()}: ${e?.message ?? e}`);
             }
         }
 
+        if (!yamlExists && corrected === 0) {
+            return undefined; // nothing to migrate and nothing to correct in this scope
+        }
+
         this.logger.info(
-            `Migration done for ${yamlURI.toString()}: ` +
-            `migrated=${migrated}, alreadyPresent=${alreadyPresent}, failed=${failed}, ` +
-            `yamlBackedUp=${yamlBackedUp}, promptOverridesMigrated=${promptOverridesMigrated}`
+            `Migration done for ${scopeDir.toString()}: migrated=${migrated}, alreadyPresent=${alreadyPresent}, ` +
+            `failed=${failed}, yamlBackedUp=${yamlBackedUp}, promptOverridesMigrated=${promptOverridesMigrated}, corrected=${corrected}`
         );
-        return { scope: scopeDir, yamlURI, migrated, alreadyPresent, failed, yamlBackedUp, promptOverridesMigrated };
+        return { scope: scopeDir, yamlURI, migrated, alreadyPresent, failed, yamlBackedUp, promptOverridesMigrated, corrected };
+    }
+
+    /**
+     * Compute the `agent.md` rewrites needed to recover headings folded by an earlier (v1.73.0)
+     * migration. The backup (`customAgents.yml.bak`) is the source that migration used: parsing it
+     * the old (folded) way reproduces the exact bytes it wrote, and parsing it the new (literal) way
+     * produces the corrected content. Only files still byte-identical to the buggy output are eligible,
+     * so files the user edited (and already-correct files) are left untouched. Read-only; used both to
+     * detect pending work and to perform the rewrite.
+     */
+    protected async computeScopeCorrections(scopeDir: URI): Promise<Array<{ uri: URI; content: string }>> {
+        const backupURI = scopeDir.resolve('customAgents.yml.bak');
+        if (!(await this.fileService.exists(backupURI))) {
+            return [];
+        }
+        let oldEntries: unknown;
+        let newEntries: unknown;
+        try {
+            const raw = (await this.fileService.read(backupURI, { encoding: 'utf-8' })).value;
+            oldEntries = load(raw);                       // reproduces the folded (buggy) output
+            newEntries = this.parseCustomAgentsYaml(raw); // produces the heading-preserving fix
+        } catch {
+            return [];
+        }
+        if (!Array.isArray(oldEntries) || !oldEntries.every(CustomAgentDescription.is)
+            || !Array.isArray(newEntries) || !newEntries.every(CustomAgentDescription.is)) {
+            return [];
+        }
+        const fixedById = new Map((newEntries as CustomAgentDescription[]).map(e => [e.id, e] as const));
+        const corrections: Array<{ uri: URI; content: string }> = [];
+        for (const oldEntry of oldEntries as CustomAgentDescription[]) {
+            const fixed = fixedById.get(oldEntry.id);
+            if (!fixed) {
+                continue;
+            }
+            const buggyContent = serializeCustomAgentFile(oldEntry);
+            const fixedContent = serializeCustomAgentFile(fixed);
+            if (buggyContent === fixedContent) {
+                continue; // prompt had no folded headings to recover
+            }
+            const agentMdURI = scopeDir.resolve(CUSTOM_AGENTS_DIRECTORY).resolve(oldEntry.id).resolve(CUSTOM_AGENT_FILE_NAME);
+            if (!(await this.fileService.exists(agentMdURI))) {
+                continue;
+            }
+            let current: string;
+            try {
+                current = (await this.fileService.read(agentMdURI, { encoding: 'utf-8' })).value;
+            } catch {
+                continue;
+            }
+            // Only rewrite files untouched since migration; current bytes still matching the buggy output.
+            if (current === buggyContent) {
+                corrections.push({ uri: agentMdURI, content: fixedContent });
+            }
+        }
+        return corrections;
     }
 
     /**
@@ -1923,6 +2041,8 @@ export interface MigrationReport {
     yamlBackedUp: boolean;
     /** Number of scope-root prompt customization files (`<name>_prompt.prompttemplate`) folded into agent.md and deleted. */
     promptOverridesMigrated: number;
+    /** Number of already-migrated `agent.md` files rewritten to recover folded headings. */
+    corrected: number;
 }
 
 /**

package/src/browser/index.ts

@@ -23,6 +23,7 @@ export * from './ai-core-frontend-application-contribution';
 export * from './ai-core-frontend-module';
 export * from '../common/ai-core-preferences';
 export * from './ai-settings-service';
+export * from './ai-configuration-service-impl';
 export * from './ai-view-contribution';
 export * from './frontend-language-model-registry';
 export * from './frontend-language-model-alias-registry';

package/src/browser/trust-aware-preference-reader.spec.ts

@@ -165,6 +165,35 @@ describe('TrustAwarePreferenceReader', () => {
         });
     });
 
+    describe('suppressUntrusted', () => {
+        const inspection = {
+            preferenceName: PREFERENCE_NAME,
+            defaultValue: 'default',
+            globalValue: 'user',
+            workspaceValue: 'workspace',
+            workspaceFolderValue: 'folder',
+            value: 'folder'
+        };
+
+        it('clears the workspace and folder values when untrusted', async () => {
+            trust.trustDeferred.resolve(false);
+            await reader.ready;
+            const result = reader.suppressUntrusted({ ...inspection });
+            expect(result.workspaceValue).to.equal(undefined);
+            expect(result.workspaceFolderValue).to.equal(undefined);
+            expect(result.globalValue).to.equal('user');
+            expect(result.defaultValue).to.equal('default');
+        });
+
+        it('returns the inspection unchanged when trusted', async () => {
+            trust.trustDeferred.resolve(true);
+            await reader.ready;
+            const result = reader.suppressUntrusted({ ...inspection });
+            expect(result.workspaceValue).to.equal('workspace');
+            expect(result.workspaceFolderValue).to.equal('folder');
+        });
+    });
+
     describe('onDidChangeTrust', () => {
         beforeEach(async () => {
             trust.trustDeferred.resolve(false);

package/src/browser/trust-aware-preference-reader.ts

@@ -18,7 +18,7 @@ import { inject, injectable, postConstruct } from '@theia/core/shared/inversify'
 import { JSONValue } from '@theia/core/shared/@lumino/coreutils';
 import { Emitter, Event } from '@theia/core';
 import { Deferred } from '@theia/core/lib/common/promise-util';
-import { PreferenceService } from '@theia/core/lib/common/preferences';
+import { PreferenceInspection, PreferenceService } from '@theia/core/lib/common/preferences';
 import { WorkspaceTrustService } from '@theia/workspace/lib/browser/workspace-trust-service';
 
 /**
@@ -27,6 +27,9 @@ import { WorkspaceTrustService } from '@theia/workspace/lib/browser/workspace-tr
  *
  * Writes should continue to go through `PreferenceService` directly; trust only
  * affects reads.
+ *
+ * @internal This is an implementation detail of {@link AiConfigurationService}. AI configuration
+ * consumers should go through `AiConfigurationService` rather than injecting this reader directly.
  */
 @injectable()
 export class TrustAwarePreferenceReader {
@@ -102,7 +105,24 @@ export class TrustAwarePreferenceReader {
             return this.preferences.get<T>(preferenceName, fallback, resourceUri);
         }
         const inspection = this.preferences.inspect<JSONValue>(preferenceName, resourceUri);
-        const value = inspection?.globalValue ?? inspection?.defaultValue;
-        return (value as T | undefined) ?? fallback;
+        if (!inspection) {
+            return fallback;
+        }
+        const suppressed = this.suppressUntrusted(inspection);
+        return ((suppressed.globalValue ?? suppressed.defaultValue) as T | undefined) ?? fallback;
+    }
+
+    /**
+     * Narrows a raw {@link PreferenceInspection} according to workspace trust: when the workspace is
+     * untrusted the folder and workspace scope values are dropped so that only the user and default
+     * scopes contribute (failing closed until the trust state resolves). A trusted inspection is
+     * returned unchanged. This is the single definition of the trust-suppression rule, shared by
+     * {@link get} and by inspection-based consumers, so value reads and inspections cannot drift.
+     */
+    suppressUntrusted<T extends JSONValue>(inspection: PreferenceInspection<T>): PreferenceInspection<T> {
+        if (this.trusted) {
+            return inspection;
+        }
+        return { ...inspection, workspaceValue: undefined, workspaceFolderValue: undefined };
     }
 }