@theia/ai-ide 1.77.0-next.95 → 1.77.0

package/lib/browser/workspace-functions.spec.js

@@ -1,4 +1,3 @@
-"use strict";
 // *****************************************************************************
 // Copyright (C) 2025 EclipseSource GmbH.
 //
@@ -14,29 +13,28 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-Object.defineProperty(exports, "__esModule", { value: true });
-const jsdom_1 = require("@theia/core/lib/browser/test/jsdom");
-let disableJSDOM = (0, jsdom_1.enableJSDOM)();
-const frontend_application_config_provider_1 = require("@theia/core/lib/browser/frontend-application-config-provider");
-frontend_application_config_provider_1.FrontendApplicationConfigProvider.set({});
-const chai_1 = require("chai");
-const core_1 = require("@theia/core");
-const workspace_functions_1 = require("./workspace-functions");
-const contribution_provider_1 = require("@theia/core/lib/common/contribution-provider");
-const ai_core_1 = require("@theia/ai-core");
-const inversify_1 = require("@theia/core/shared/inversify");
-const env_variables_1 = require("@theia/core/lib/common/env-variables");
-const file_service_1 = require("@theia/filesystem/lib/browser/file-service");
-const files_1 = require("@theia/filesystem/lib/common/files");
-const uri_1 = require("@theia/core/lib/common/uri");
-const browser_1 = require("@theia/workspace/lib/browser");
-const browser_2 = require("@theia/markers/lib/browser");
-const monaco_text_model_service_1 = require("@theia/monaco/lib/browser/monaco-text-model-service");
-const monaco_workspace_1 = require("@theia/monaco/lib/browser/monaco-workspace");
-const file_search_service_1 = require("@theia/file-search/lib/common/file-search-service");
-const minimatch_1 = require("minimatch");
-const mock_logger_1 = require("@theia/core/lib/common/test/mock-logger");
-const with_workspace_service_defaults_1 = require("@theia/workspace/lib/browser/test/with-workspace-service-defaults");
+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 { CancellationTokenSource, OS, PreferenceService, ILogger } from '@theia/core';
+import { AccessibleRootContribution, GetWorkspaceDirectoryStructure, FileContentFunction, GetWorkspaceFileList, FileDiagnosticProvider, WorkspaceFunctionScope, FindFilesByPattern } from './workspace-functions.js';
+import { bindRootContributionProvider } from '@theia/core/lib/common/contribution-provider';
+import { AiConfigurationService } from '@theia/ai-core';
+import { Container } from '@theia/core/shared/inversify';
+import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { FileOperationError } from '@theia/filesystem/lib/common/files';
+import { URI } from '@theia/core/lib/common/uri';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { ProblemManager } from '@theia/markers/lib/browser';
+import { MonacoTextModelService } from '@theia/monaco/lib/browser/monaco-text-model-service';
+import { MonacoWorkspace } from '@theia/monaco/lib/browser/monaco-workspace';
+import { FileSearchService } from '@theia/file-search/lib/common/file-search-service';
+import { Minimatch } from 'minimatch';
+import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
+import { withWorkspaceServiceDefaults } from '@theia/workspace/lib/browser/test/with-workspace-service-defaults';
 const makeFileSearchService = (impl) => {
     const calls = [];
     return {
@@ -57,11 +55,11 @@ const makeRipgrepLikeSearchService = (filesByRoot) => makeFileSearchService(asyn
     if (!root) {
         return [];
     }
-    const rootUri = new uri_1.URI(root);
-    const includes = (options.includePatterns ?? []).map(pattern => new minimatch_1.Minimatch(pattern, { dot: true }));
-    const excludes = (options.excludePatterns ?? []).map(pattern => new minimatch_1.Minimatch(pattern, { dot: true }));
+    const rootUri = new URI(root);
+    const includes = (options.includePatterns ?? []).map(pattern => new Minimatch(pattern, { dot: true }));
+    const excludes = (options.excludePatterns ?? []).map(pattern => new Minimatch(pattern, { dot: true }));
     return (filesByRoot[root] ?? []).filter(file => {
-        const relativePath = rootUri.relative(new uri_1.URI(file))?.toString() ?? '';
+        const relativePath = rootUri.relative(new URI(file))?.toString() ?? '';
         const included = includes.length === 0 || includes.some(matcher => matcher.match(relativePath));
         const excluded = excludes.some(matcher => matcher.match(relativePath));
         return included && !excluded;
@@ -85,24 +83,24 @@ describe('Workspace Functions Cancellation Tests', () => {
     let mockCtx;
     let container;
     before(() => {
-        disableJSDOM = (0, jsdom_1.enableJSDOM)();
+        disableJSDOM = enableJSDOM();
     });
     after(() => {
         // Disable JSDOM after all tests
         disableJSDOM();
     });
     beforeEach(() => {
-        cancellationTokenSource = new core_1.CancellationTokenSource();
+        cancellationTokenSource = new CancellationTokenSource();
         // Setup mock context
         mockCtx = {
             cancellationToken: cancellationTokenSource.token
         };
         // Create a new container for each test
-        container = new inversify_1.Container();
+        container = new Container();
         // Mock dependencies
         const mockWorkspaceService = {
-            roots: Promise.resolve([{ resource: new uri_1.URI('file:///workspace') }]),
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: Promise.resolve([{ resource: new URI('file:///workspace') }]),
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -112,16 +110,16 @@ describe('Workspace Functions Cancellation Tests', () => {
                 children: [
                     {
                         isDirectory: true,
-                        resource: new uri_1.URI('file:///workspace/dir'),
+                        resource: new URI('file:///workspace/dir'),
                         path: { base: 'dir' }
                     }
                 ],
-                resource: new uri_1.URI('file:///workspace')
+                resource: new URI('file:///workspace')
             }),
             read: async () => ({ value: { toString: () => 'test content' } })
         };
         const mockPreferenceService = {
-            get: (_path, defaultValue) => defaultValue
+            get: (_path, options) => options?.fallback
         };
         const mockMonacoWorkspace = {
             getTextDocument: () => undefined
@@ -140,53 +138,53 @@ describe('Workspace Functions Cancellation Tests', () => {
             })
         };
         // Register mocks in the container
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(monaco_workspace_1.MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
-        container.bind(browser_2.ProblemManager).toConstantValue(mockProblemManager);
-        container.bind(monaco_text_model_service_1.MonacoTextModelService).toConstantValue(mockMonacoTextModelService);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        container.bind(file_search_service_1.FileSearchService).toConstantValue(makeFileSearchService());
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.GetWorkspaceDirectoryStructure).toSelf();
-        container.bind(workspace_functions_1.FileContentFunction).toSelf();
-        container.bind(workspace_functions_1.GetWorkspaceFileList).toSelf();
-        container.bind(workspace_functions_1.FileDiagnosticProvider).toSelf();
-        container.bind(workspace_functions_1.FindFilesByPattern).toSelf();
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
+        container.bind(ProblemManager).toConstantValue(mockProblemManager);
+        container.bind(MonacoTextModelService).toConstantValue(mockMonacoTextModelService);
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        container.bind(FileSearchService).toConstantValue(makeFileSearchService());
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(GetWorkspaceDirectoryStructure).toSelf();
+        container.bind(FileContentFunction).toSelf();
+        container.bind(GetWorkspaceFileList).toSelf();
+        container.bind(FileDiagnosticProvider).toSelf();
+        container.bind(FindFilesByPattern).toSelf();
     });
     afterEach(() => {
         cancellationTokenSource.dispose();
     });
     it('GetWorkspaceDirectoryStructure should respect cancellation token', async () => {
-        const getDirectoryStructure = container.get(workspace_functions_1.GetWorkspaceDirectoryStructure);
+        const getDirectoryStructure = container.get(GetWorkspaceDirectoryStructure);
         cancellationTokenSource.cancel();
         const handler = getDirectoryStructure.getTool().handler;
         const result = await handler(JSON.stringify({}), mockCtx);
         const jsonResponse = typeof result === 'string' ? JSON.parse(result) : result;
-        (0, chai_1.expect)(jsonResponse.error).to.equal('Operation cancelled by user');
+        expect(jsonResponse.error).to.equal('Operation cancelled by user');
     });
     it('FileContentFunction should respect cancellation token', async () => {
-        const fileContentFunction = container.get(workspace_functions_1.FileContentFunction);
+        const fileContentFunction = container.get(FileContentFunction);
         cancellationTokenSource.cancel();
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt' }), mockCtx);
         const jsonResponse = JSON.parse(result);
-        (0, chai_1.expect)(jsonResponse.error).to.equal('Operation cancelled by user');
+        expect(jsonResponse.error).to.equal('Operation cancelled by user');
     });
     it('GetWorkspaceFileList should respect cancellation token', async () => {
-        const getWorkspaceFileList = container.get(workspace_functions_1.GetWorkspaceFileList);
+        const getWorkspaceFileList = container.get(GetWorkspaceFileList);
         cancellationTokenSource.cancel();
         const handler = getWorkspaceFileList.getTool().handler;
         const result = await handler(JSON.stringify({ path: '' }), mockCtx);
-        (0, chai_1.expect)(result).to.include('Operation cancelled by user');
+        expect(result).to.include('Operation cancelled by user');
     });
     it('GetWorkspaceFileList should check cancellation at multiple points', async () => {
-        const getWorkspaceFileList = container.get(workspace_functions_1.GetWorkspaceFileList);
+        const getWorkspaceFileList = container.get(GetWorkspaceFileList);
         // We'll let it pass the first check then cancel
-        const mockFileService = container.get(file_service_1.FileService);
+        const mockFileService = container.get(FileService);
         const originalResolve = mockFileService.resolve;
         // Mock resolve to cancel the token after it's called
         mockFileService.resolve = async (...args) => {
@@ -197,15 +195,15 @@ describe('Workspace Functions Cancellation Tests', () => {
         const handler = getWorkspaceFileList.getTool().handler;
         // Use a path that triggers file resolution (root name + subdirectory)
         const result = await handler(JSON.stringify({ path: 'workspace/dir' }), mockCtx);
-        (0, chai_1.expect)(result).to.include('Operation cancelled by user');
+        expect(result).to.include('Operation cancelled by user');
     });
     it('FileDiagnosticProvider should respect cancellation token', async () => {
-        const fileDiagnosticProvider = container.get(workspace_functions_1.FileDiagnosticProvider);
+        const fileDiagnosticProvider = container.get(FileDiagnosticProvider);
         cancellationTokenSource.cancel();
         const handler = fileDiagnosticProvider.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt' }), mockCtx);
         const jsonResponse = JSON.parse(result);
-        (0, chai_1.expect)(jsonResponse.error).to.equal('Operation cancelled by user');
+        expect(jsonResponse.error).to.equal('Operation cancelled by user');
     });
 });
 describe('FileContentFunction.getArgumentsShortLabel', () => {
@@ -213,16 +211,16 @@ describe('FileContentFunction.getArgumentsShortLabel', () => {
     let getArgumentsShortLabel;
     let disableJSDOMInner;
     before(() => {
-        disableJSDOMInner = (0, jsdom_1.enableJSDOM)();
+        disableJSDOMInner = enableJSDOM();
     });
     after(() => {
         disableJSDOMInner();
     });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         const mockWorkspaceService = {
-            roots: Promise.resolve([{ resource: new uri_1.URI('file:///workspace') }]),
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: Promise.resolve([{ resource: new URI('file:///workspace') }]),
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -230,52 +228,52 @@ describe('FileContentFunction.getArgumentsShortLabel', () => {
             resolve: async () => ({
                 isDirectory: true,
                 children: [],
-                resource: new uri_1.URI('file:///workspace')
+                resource: new URI('file:///workspace')
             }),
             read: async () => ({ value: { toString: () => 'test content' } })
         };
         const mockPreferenceService = {
-            get: (_path, defaultValue) => defaultValue
+            get: (_path, options) => options?.fallback
         };
         const mockMonacoWorkspace = {
             getTextDocument: () => undefined
         };
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(monaco_workspace_1.MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.FileContentFunction).toSelf();
-        const fileContentFunction = container.get(workspace_functions_1.FileContentFunction);
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(FileContentFunction).toSelf();
+        const fileContentFunction = container.get(FileContentFunction);
         const tool = fileContentFunction.getTool();
         getArgumentsShortLabel = tool.getArgumentsShortLabel;
     });
     it('returns label for valid file argument', () => {
         const result = getArgumentsShortLabel(JSON.stringify({ file: 'src/index.ts' }));
-        (0, chai_1.expect)(result).to.deep.equal({ label: 'src/index.ts', hasMore: false });
+        expect(result).to.deep.equal({ label: 'src/index.ts', hasMore: false });
     });
     it('returns undefined for invalid JSON', () => {
         const result = getArgumentsShortLabel('not valid json');
-        (0, chai_1.expect)(result).to.be.undefined;
+        expect(result).to.be.undefined;
     });
     it('returns undefined when file key is missing', () => {
         const result = getArgumentsShortLabel(JSON.stringify({ path: 'src/index.ts' }));
-        (0, chai_1.expect)(result).to.be.undefined;
+        expect(result).to.be.undefined;
     });
     it('returns hasMore true when offset is provided', () => {
         const result = getArgumentsShortLabel(JSON.stringify({ file: 'src/index.ts', offset: 10 }));
-        (0, chai_1.expect)(result).to.deep.equal({ label: 'src/index.ts', hasMore: true });
+        expect(result).to.deep.equal({ label: 'src/index.ts', hasMore: true });
     });
     it('returns hasMore true when limit is provided', () => {
         const result = getArgumentsShortLabel(JSON.stringify({ file: 'src/index.ts', limit: 50 }));
-        (0, chai_1.expect)(result).to.deep.equal({ label: 'src/index.ts', hasMore: true });
+        expect(result).to.deep.equal({ label: 'src/index.ts', hasMore: true });
     });
     it('returns hasMore true when both offset and limit are provided', () => {
         const result = getArgumentsShortLabel(JSON.stringify({ file: 'src/index.ts', offset: 10, limit: 50 }));
-        (0, chai_1.expect)(result).to.deep.equal({ label: 'src/index.ts', hasMore: true });
+        expect(result).to.deep.equal({ label: 'src/index.ts', hasMore: true });
     });
 });
 describe('FileContentFunction handler', () => {
@@ -305,23 +303,23 @@ describe('FileContentFunction handler', () => {
     };
     let disableJSDOMInner;
     before(() => {
-        disableJSDOMInner = (0, jsdom_1.enableJSDOM)();
+        disableJSDOMInner = enableJSDOM();
     });
     after(() => {
         disableJSDOMInner();
     });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         const mockWorkspaceService = {
-            roots: Promise.resolve([{ resource: new uri_1.URI('file:///workspace') }]),
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: Promise.resolve([{ resource: new URI('file:///workspace') }]),
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         mockResolve = async () => ({
             isFile: true,
             isDirectory: false,
             size: 1024,
-            resource: new uri_1.URI('file:///workspace/test.txt')
+            resource: new URI('file:///workspace/test.txt')
         });
         mockRead = async () => ({ value: 'line1\nline2\nline3\nline4\nline5' });
         mockReadStream = async () => ({ value: makeMockStream('line1\nline2\nline3\nline4\nline5') });
@@ -335,26 +333,35 @@ describe('FileContentFunction handler', () => {
             readStream: () => mockReadStream(),
         };
         mockPreferenceService = {
-            get: (_path, defaultValue) => defaultValue
+            get: (_path, optionsOrFallback) => {
+                if (optionsOrFallback === undefined) {
+                    return undefined;
+                }
+                // eslint-disable-next-line no-null/no-null
+                if (typeof optionsOrFallback === 'object' && optionsOrFallback !== null && !Array.isArray(optionsOrFallback) && 'fallback' in optionsOrFallback) {
+                    return optionsOrFallback.fallback;
+                }
+                return optionsOrFallback;
+            }
         };
         mockMonacoWorkspace = {
             getTextDocument: () => undefined
         };
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(monaco_workspace_1.MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.FileContentFunction).toSelf();
-        fileContentFunction = container.get(workspace_functions_1.FileContentFunction);
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(FileContentFunction).toSelf();
+        fileContentFunction = container.get(FileContentFunction);
     });
     it('returns file content when file is within size limit', async () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt' }), undefined);
-        (0, chai_1.expect)(result).to.equal('line1\nline2\nline3\nline4\nline5');
+        expect(result).to.equal('line1\nline2\nline3\nline4\nline5');
     });
     it('rejects without reading when on-disk size exceeds limit', async () => {
         // Stat reports 512 KB; default limit is 256 KB
@@ -363,7 +370,7 @@ describe('FileContentFunction handler', () => {
             isFile: true,
             isDirectory: false,
             size: 512 * 1024,
-            resource: new uri_1.URI('file:///workspace/big.txt')
+            resource: new URI('file:///workspace/big.txt')
         });
         mockRead = async () => {
             readCalled = true;
@@ -372,23 +379,23 @@ describe('FileContentFunction handler', () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'big.txt' }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('size limit');
-        (0, chai_1.expect)(parsed.sizeKB).to.equal(512);
-        (0, chai_1.expect)(readCalled).to.be.false;
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.sizeKB).to.equal(512);
+        expect(readCalled).to.be.false;
     });
     it('returns editor content when file is open in editor and within size limit', async () => {
         let resolveCalled = false;
         mockResolve = async () => {
             resolveCalled = true;
-            return { isFile: true, isDirectory: false, size: 1024, resource: new uri_1.URI('file:///workspace/open.txt') };
+            return { isFile: true, isDirectory: false, size: 1024, resource: new URI('file:///workspace/open.txt') };
         };
         mockMonacoWorkspace.getTextDocument = () => ({
             getText: () => 'editor content'
         });
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'open.txt' }), undefined);
-        (0, chai_1.expect)(result).to.equal('editor content');
-        (0, chai_1.expect)(resolveCalled).to.be.false;
+        expect(result).to.equal('editor content');
+        expect(resolveCalled).to.be.false;
     });
     it('rejects editor content when it exceeds the size limit', async () => {
         const bigContent = 'x'.repeat(512 * 1024);
@@ -398,14 +405,14 @@ describe('FileContentFunction handler', () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'open.txt' }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('size limit');
-        (0, chai_1.expect)(parsed.sizeKB).to.equal(512);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.sizeKB).to.equal(512);
     });
     it('returns sliced content with header when offset and limit are provided', async () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt', offset: 1, limit: 2 }), undefined);
-        (0, chai_1.expect)(result).to.include('[Lines 2\u20133 of 5 total.');
-        (0, chai_1.expect)(result).to.include('line2\nline3');
+        expect(result).to.include('[Lines 2\u20133 of 5 total.');
+        expect(result).to.include('line2\nline3');
     });
     it('returns sliced editor content with header when file is open and offset/limit are provided', async () => {
         mockMonacoWorkspace.getTextDocument = () => ({
@@ -413,8 +420,8 @@ describe('FileContentFunction handler', () => {
         });
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'open.txt', offset: 1, limit: 2 }), undefined);
-        (0, chai_1.expect)(result).to.include('[Lines 2\u20133 of 5 total.');
-        (0, chai_1.expect)(result).to.include('beta\ngamma');
+        expect(result).to.include('[Lines 2\u20133 of 5 total.');
+        expect(result).to.include('beta\ngamma');
     });
     it('does not call resolve() or read() for paginated disk reads, uses readStream instead', async () => {
         // Stat would report huge file, but the streaming path bypasses both stat and read
@@ -426,7 +433,7 @@ describe('FileContentFunction handler', () => {
                 isFile: true,
                 isDirectory: false,
                 size: 512 * 1024,
-                resource: new uri_1.URI('file:///workspace/big.txt')
+                resource: new URI('file:///workspace/big.txt')
             };
         };
         mockRead = async () => {
@@ -436,9 +443,9 @@ describe('FileContentFunction handler', () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'big.txt', offset: 0, limit: 3 }), undefined);
         // resolve and read are NOT called in the streaming path
-        (0, chai_1.expect)(resolveCalled).to.be.false;
-        (0, chai_1.expect)(readCalled).to.be.false;
-        (0, chai_1.expect)(result).to.include('line1\nline2\nline3');
+        expect(resolveCalled).to.be.false;
+        expect(readCalled).to.be.false;
+        expect(result).to.include('line1\nline2\nline3');
     });
     it('rejects when the requested slice itself exceeds the size limit', async () => {
         const bigLine = 'x'.repeat(1024);
@@ -448,8 +455,8 @@ describe('FileContentFunction handler', () => {
         // Reading all 300 lines × 1 KB each = ~300 KB, over the 256 KB default limit
         const result = await handler(JSON.stringify({ file: 'big.txt', offset: 0, limit: 300 }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('size limit');
-        (0, chai_1.expect)(parsed.resultSizeKB).to.be.greaterThan(256);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.resultSizeKB).to.be.greaterThan(256);
     });
     it('returns File not found error when file does not exist', async () => {
         mockResolve = async () => { throw new Error('File not found'); };
@@ -458,66 +465,66 @@ describe('FileContentFunction handler', () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'nonexistent.txt' }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.equal('File not found');
+        expect(parsed.error).to.equal('File not found');
     });
     it('rejects negative offset', async () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt', offset: -1 }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('non-negative integer');
+        expect(parsed.error).to.include('non-negative integer');
     });
     it('rejects fractional offset', async () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt', offset: 1.5 }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('non-negative integer');
+        expect(parsed.error).to.include('non-negative integer');
     });
     it('rejects negative limit', async () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt', limit: -1 }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('positive integer');
+        expect(parsed.error).to.include('positive integer');
     });
     it('rejects zero limit', async () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt', limit: 0 }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('positive integer');
+        expect(parsed.error).to.include('positive integer');
     });
     it('returns content from offset to end when only offset is provided', async () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt', offset: 2 }), undefined);
-        (0, chai_1.expect)(result).to.include('[Lines 3\u20135 of 5 total.');
-        (0, chai_1.expect)(result).to.include('line3\nline4\nline5');
+        expect(result).to.include('[Lines 3\u20135 of 5 total.');
+        expect(result).to.include('line3\nline4\nline5');
     });
     it('returns last line when offset is at boundary', async () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt', offset: 4, limit: 1 }), undefined);
-        (0, chai_1.expect)(result).to.include('[Lines 5\u20135 of 5 total.');
-        (0, chai_1.expect)(result).to.include('line5');
+        expect(result).to.include('[Lines 5\u20135 of 5 total.');
+        expect(result).to.include('line5');
     });
     it('returns empty content when offset is beyond end of file', async () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt', offset: 100, limit: 5 }), undefined);
         // slice beyond end returns empty array → empty joined string
-        (0, chai_1.expect)(result).to.include('[Lines 101\u2013100 of 5 total.');
+        expect(result).to.include('[Lines 101\u2013100 of 5 total.');
     });
     it('uses custom preference value for size limit', async () => {
         // Set a very small limit of 1 KB
-        mockPreferenceService.get = (_path, _defaultValue) => 1;
+        mockPreferenceService.get = (_path, _optionsOrFallback) => 1;
         const content = 'x'.repeat(2 * 1024); // 2 KB
         mockRead = async () => ({ value: content });
         mockResolve = async () => ({
             isFile: true,
             isDirectory: false,
             size: 2 * 1024,
-            resource: new uri_1.URI('file:///workspace/test.txt')
+            resource: new URI('file:///workspace/test.txt')
         });
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt' }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('size limit');
-        (0, chai_1.expect)(parsed.maxSizeKB).to.equal(1);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.maxSizeKB).to.equal(1);
     });
     it('falls back to streaming when stat.size is undefined and file is within limit', async () => {
         // stat does not include a size — the code must not treat this as "0 KB"
@@ -527,7 +534,7 @@ describe('FileContentFunction handler', () => {
             isFile: true,
             isDirectory: false,
             size: undefined,
-            resource: new uri_1.URI('file:///workspace/test.txt')
+            resource: new URI('file:///workspace/test.txt')
         });
         mockRead = async () => {
             readCalled = true;
@@ -536,10 +543,10 @@ describe('FileContentFunction handler', () => {
         // mockReadStream already returns the small 5-line fixture from beforeEach
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt' }), undefined);
-        (0, chai_1.expect)(readCalled).to.be.false;
-        (0, chai_1.expect)(result).to.include('line1');
+        expect(readCalled).to.be.false;
+        expect(result).to.include('line1');
         // Full-file streaming fallback must NOT include the [Lines...] header
-        (0, chai_1.expect)(result).to.not.include('[Lines');
+        expect(result).to.not.include('[Lines');
     });
     it('returns size-limit error (not "File not found") when stat.size is undefined and streamed content exceeds limit', async () => {
         // stat does not include a size; the streamed content is larger than the limit.
@@ -547,7 +554,7 @@ describe('FileContentFunction handler', () => {
             isFile: true,
             isDirectory: false,
             size: undefined,
-            resource: new uri_1.URI('file:///workspace/big.txt')
+            resource: new URI('file:///workspace/big.txt')
         });
         const bigLine = 'x'.repeat(1024);
         const bigContent = Array.from({ length: 300 }, () => bigLine).join('\n'); // ~300 KB
@@ -555,9 +562,9 @@ describe('FileContentFunction handler', () => {
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'big.txt' }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('size limit');
-        (0, chai_1.expect)(parsed.error).to.include('offset');
-        (0, chai_1.expect)(parsed.error).not.to.equal('File not found');
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.error).to.include('offset');
+        expect(parsed.error).not.to.equal('File not found');
     });
     it('returns size-limit error (not "File not found") when fileService.read throws FILE_TOO_LARGE', async () => {
         // Simulate a file system provider that enforces its own hard size limit below maxSizeKB.
@@ -566,34 +573,34 @@ describe('FileContentFunction handler', () => {
             isFile: true,
             isDirectory: false,
             size: 100 * 1024, // 100 KB — under the 256 KB default limit
-            resource: new uri_1.URI('file:///workspace/test.txt')
+            resource: new URI('file:///workspace/test.txt')
         });
         mockRead = async () => {
-            throw new files_1.FileOperationError('File too large', 7 /* FileOperationResult.FILE_TOO_LARGE */);
+            throw new FileOperationError('File too large', 7 /* FileOperationResult.FILE_TOO_LARGE */);
         };
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt' }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('size limit');
-        (0, chai_1.expect)(parsed.error).to.include('offset');
-        (0, chai_1.expect)(parsed.maxSizeKB).to.equal(256);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.error).to.include('offset');
+        expect(parsed.maxSizeKB).to.equal(256);
     });
     it('returns size-limit error (not "File not found") when fileService.read throws FILE_EXCEEDS_MEMORY_LIMIT', async () => {
         mockResolve = async () => ({
             isFile: true,
             isDirectory: false,
             size: 100 * 1024,
-            resource: new uri_1.URI('file:///workspace/test.txt')
+            resource: new URI('file:///workspace/test.txt')
         });
         mockRead = async () => {
-            throw new files_1.FileOperationError('Exceeds memory limit', 9 /* FileOperationResult.FILE_EXCEEDS_MEMORY_LIMIT */);
+            throw new FileOperationError('Exceeds memory limit', 9 /* FileOperationResult.FILE_EXCEEDS_MEMORY_LIMIT */);
         };
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'test.txt' }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('size limit');
-        (0, chai_1.expect)(parsed.error).to.include('offset');
-        (0, chai_1.expect)(parsed.maxSizeKB).to.equal(256);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.error).to.include('offset');
+        expect(parsed.maxSizeKB).to.equal(256);
     });
     it('returns size-limit error (not "File not found") when readStream throws FILE_TOO_LARGE for paginated read', async () => {
         // This is the key scenario: files.maxFileSizeMB is lower than the file size,
@@ -601,15 +608,15 @@ describe('FileContentFunction handler', () => {
         // Before the fix, readStream would throw FILE_TOO_LARGE and the catch block
         // would return "File not found".
         mockReadStream = async () => {
-            throw new files_1.FileOperationError('File too large', 7 /* FileOperationResult.FILE_TOO_LARGE */);
+            throw new FileOperationError('File too large', 7 /* FileOperationResult.FILE_TOO_LARGE */);
         };
         const handler = fileContentFunction.getTool().handler;
         const result = await handler(JSON.stringify({ file: 'big.txt', offset: 0, limit: 50 }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('size limit');
-        (0, chai_1.expect)(parsed.error).to.include('offset');
-        (0, chai_1.expect)(parsed.error).not.to.equal('File not found');
-        (0, chai_1.expect)(parsed.maxSizeKB).to.equal(256);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.error).to.include('offset');
+        expect(parsed.error).not.to.equal('File not found');
+        expect(parsed.maxSizeKB).to.equal(256);
     });
 });
 describe('FindFilesByPattern.getArgumentsShortLabel', () => {
@@ -617,16 +624,16 @@ describe('FindFilesByPattern.getArgumentsShortLabel', () => {
     let getArgumentsShortLabel;
     let disableJSDOMInner;
     before(() => {
-        disableJSDOMInner = (0, jsdom_1.enableJSDOM)();
+        disableJSDOMInner = enableJSDOM();
     });
     after(() => {
         disableJSDOMInner();
     });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         const mockWorkspaceService = {
-            roots: Promise.resolve([{ resource: new uri_1.URI('file:///workspace') }]),
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: Promise.resolve([{ resource: new URI('file:///workspace') }]),
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -634,41 +641,41 @@ describe('FindFilesByPattern.getArgumentsShortLabel', () => {
             resolve: async () => ({
                 isDirectory: true,
                 children: [],
-                resource: new uri_1.URI('file:///workspace')
+                resource: new URI('file:///workspace')
             }),
             read: async () => ({ value: { toString: () => 'test content' } })
         };
         const mockPreferenceService = {
-            get: (_path, defaultValue) => defaultValue
-        };
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        container.bind(file_search_service_1.FileSearchService).toConstantValue(makeFileSearchService());
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.FindFilesByPattern).toSelf();
-        const findFilesByPattern = container.get(workspace_functions_1.FindFilesByPattern);
+            get: (_path, options) => options?.fallback
+        };
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        container.bind(FileSearchService).toConstantValue(makeFileSearchService());
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(FindFilesByPattern).toSelf();
+        const findFilesByPattern = container.get(FindFilesByPattern);
         const tool = findFilesByPattern.getTool();
         getArgumentsShortLabel = tool.getArgumentsShortLabel;
     });
     it('returns label for valid pattern argument', () => {
         const result = getArgumentsShortLabel(JSON.stringify({ pattern: '**/*.ts' }));
-        (0, chai_1.expect)(result).to.deep.equal({ label: '**/*.ts', hasMore: false });
+        expect(result).to.deep.equal({ label: '**/*.ts', hasMore: false });
     });
     it('returns hasMore true when additional arguments exist', () => {
         const result = getArgumentsShortLabel(JSON.stringify({ pattern: '**/*.ts', exclude: ['node_modules'] }));
-        (0, chai_1.expect)(result).to.deep.equal({ label: '**/*.ts', hasMore: true });
+        expect(result).to.deep.equal({ label: '**/*.ts', hasMore: true });
     });
     it('returns undefined for invalid JSON', () => {
         const result = getArgumentsShortLabel('not valid json');
-        (0, chai_1.expect)(result).to.be.undefined;
+        expect(result).to.be.undefined;
     });
     it('returns undefined when pattern key is missing', () => {
         const result = getArgumentsShortLabel(JSON.stringify({ glob: '**/*.ts' }));
-        (0, chai_1.expect)(result).to.be.undefined;
+        expect(result).to.be.undefined;
     });
 });
 describe('FindFilesByPattern.findFiles', () => {
@@ -680,20 +687,20 @@ describe('FindFilesByPattern.findFiles', () => {
     let prefs;
     let allowedExternal;
     let disableJSDOMInner;
-    before(() => { disableJSDOMInner = (0, jsdom_1.enableJSDOM)(); });
+    before(() => { disableJSDOMInner = enableJSDOM(); });
     after(() => { disableJSDOMInner(); });
     // External hits are rendered with `Path.fsPath()`, which branches on the backend OS, so the POSIX
     // fixtures below pin it instead of inheriting the OS the tests happen to run on.
     let originalIsWindows;
     beforeEach(() => {
-        originalIsWindows = core_1.OS.backend.isWindows;
-        core_1.OS.backend.isWindows = false;
+        originalIsWindows = OS.backend.isWindows;
+        OS.backend.isWindows = false;
     });
-    afterEach(() => { core_1.OS.backend.isWindows = originalIsWindows; });
+    afterEach(() => { OS.backend.isWindows = originalIsWindows; });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         searchResults = [];
-        roots = [{ resource: new uri_1.URI('file:///workspace') }];
+        roots = [{ resource: new URI('file:///workspace') }];
         prefs = {
             'ai-features.workspaceFunctions.considerGitIgnore': true,
             'ai-features.workspaceFunctions.userExcludes': ['node_modules', 'lib']
@@ -718,99 +725,99 @@ describe('FindFilesByPattern.findFiles', () => {
             onDidChangeTrust: () => ({ dispose: () => { } })
         };
         fileSearchService = makeFileSearchService(async () => searchResults);
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(trustAwareReader);
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        container.bind(file_search_service_1.FileSearchService).toConstantValue(fileSearchService);
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.FindFilesByPattern).toSelf();
-        findFilesByPattern = container.get(workspace_functions_1.FindFilesByPattern);
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(AiConfigurationService).toConstantValue(trustAwareReader);
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        container.bind(FileSearchService).toConstantValue(fileSearchService);
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(FindFilesByPattern).toSelf();
+        findFilesByPattern = container.get(FindFilesByPattern);
     });
     const call = (args, ctx) => findFilesByPattern.getTool().handler(JSON.stringify(args), ctx);
     it('returns root-prefixed workspace-relative paths', async () => {
         searchResults = ['file:///workspace/src/a.ts', 'file:///workspace/src/b.ts'];
         const result = JSON.parse(await call({ pattern: '**/*.ts' }));
-        (0, chai_1.expect)(result.files).to.deep.equal(['workspace/src/a.ts', 'workspace/src/b.ts']);
+        expect(result.files).to.deep.equal(['workspace/src/a.ts', 'workspace/src/b.ts']);
     });
     it('passes the glob, user excludes, gitignore flag and root to the search service', async () => {
         await call({ pattern: '**/*.ts', exclude: ['**/*.spec.ts'] });
-        (0, chai_1.expect)(fileSearchService.calls).to.have.length(1);
+        expect(fileSearchService.calls).to.have.length(1);
         const options = fileSearchService.calls[0].options;
-        (0, chai_1.expect)(options.includePatterns).to.deep.equal(['**/*.ts']);
-        (0, chai_1.expect)(options.excludePatterns).to.deep.equal(['node_modules', 'lib', '**/*.spec.ts']);
-        (0, chai_1.expect)(options.useGitIgnore).to.equal(true);
-        (0, chai_1.expect)(options.rootUris).to.deep.equal(['file:///workspace']);
-        (0, chai_1.expect)(options.fuzzyMatch).to.equal(false);
+        expect(options.includePatterns).to.deep.equal(['**/*.ts']);
+        expect(options.excludePatterns).to.deep.equal(['node_modules', 'lib', '**/*.spec.ts']);
+        expect(options.useGitIgnore).to.equal(true);
+        expect(options.rootUris).to.deep.equal(['file:///workspace']);
+        expect(options.fuzzyMatch).to.equal(false);
     });
     it('does not use gitignore when the preference is disabled', async () => {
         prefs['ai-features.workspaceFunctions.considerGitIgnore'] = false;
         await call({ pattern: '**/*.ts' });
-        (0, chai_1.expect)(fileSearchService.calls[0].options.useGitIgnore).to.equal(false);
+        expect(fileSearchService.calls[0].options.useGitIgnore).to.equal(false);
     });
     it('reports an error when no workspace is open', async () => {
         roots.length = 0;
         const result = JSON.parse(await call({ pattern: '**/*.ts' }));
-        (0, chai_1.expect)(result.error).to.equal('No workspace has been opened yet');
+        expect(result.error).to.equal('No workspace has been opened yet');
     });
     it('respects the cancellation token', async () => {
-        const cts = new core_1.CancellationTokenSource();
+        const cts = new CancellationTokenSource();
         cts.cancel();
         const result = JSON.parse(await call({ pattern: '**/*.ts' }, { cancellationToken: cts.token }));
-        (0, chai_1.expect)(result.error).to.equal('Operation cancelled by user');
+        expect(result.error).to.equal('Operation cancelled by user');
     });
     it('truncates to 200 results and flags truncation', async () => {
         searchResults = Array.from({ length: 250 }, (_, i) => `file:///workspace/f${i}.ts`);
         const result = JSON.parse(await call({ pattern: '**/*.ts' }));
-        (0, chai_1.expect)(result.files).to.have.length(200);
-        (0, chai_1.expect)(result.truncated).to.equal(true);
+        expect(result.files).to.have.length(200);
+        expect(result.truncated).to.equal(true);
     });
     it('returns absolute paths for an allow-listed external searchRoot', async () => {
         allowedExternal = ['/external/data'];
         searchResults = ['file:///external/data/x.ts'];
         const result = JSON.parse(await call({ pattern: '**/*.ts', searchRoot: '/external/data' }));
-        (0, chai_1.expect)(result.files).to.deep.equal(['/external/data/x.ts']);
-        (0, chai_1.expect)(fileSearchService.calls[0].options.rootUris).to.deep.equal(['file:///external/data']);
+        expect(result.files).to.deep.equal(['/external/data/x.ts']);
+        expect(fileSearchService.calls[0].options.rootUris).to.deep.equal(['file:///external/data']);
     });
     it('does not apply gitignore to external roots (it is scoped to workspace roots)', async () => {
         prefs['ai-features.workspaceFunctions.considerGitIgnore'] = true;
         allowedExternal = ['/external/data'];
         await call({ pattern: '**/*.ts', searchRoot: '/external/data' });
         const options = fileSearchService.calls[0].options;
-        (0, chai_1.expect)(options.useGitIgnore).to.equal(false);
-        (0, chai_1.expect)(options.excludePatterns).to.include('.git');
+        expect(options.useGitIgnore).to.equal(false);
+        expect(options.excludePatterns).to.include('.git');
     });
     it('still applies gitignore to workspace roots', async () => {
         prefs['ai-features.workspaceFunctions.considerGitIgnore'] = true;
         await call({ pattern: '**/*.ts' });
-        (0, chai_1.expect)(fileSearchService.calls[0].options.useGitIgnore).to.equal(true);
+        expect(fileSearchService.calls[0].options.useGitIgnore).to.equal(true);
     });
     it('matches an allow-list entry with a trailing slash against a searchRoot without one', async () => {
         allowedExternal = ['/external/data/']; // trailing slash, as a user/file-picker may enter it
         searchResults = ['file:///external/data/x.ts'];
         const result = JSON.parse(await call({ pattern: '**/*.ts', searchRoot: '/external/data' }));
-        (0, chai_1.expect)(result.error).to.be.undefined;
-        (0, chai_1.expect)(result.files).to.deep.equal(['/external/data/x.ts']);
+        expect(result.error).to.be.undefined;
+        expect(result.files).to.deep.equal(['/external/data/x.ts']);
     });
     it('matches an allow-list entry without a trailing slash against a searchRoot that has one', async () => {
         allowedExternal = ['/external/data'];
         searchResults = ['file:///external/data/x.ts'];
         const result = JSON.parse(await call({ pattern: '**/*.ts', searchRoot: '/external/data/' }));
-        (0, chai_1.expect)(result.error).to.be.undefined;
-        (0, chai_1.expect)(result.files).to.deep.equal(['/external/data/x.ts']);
+        expect(result.error).to.be.undefined;
+        expect(result.files).to.deep.equal(['/external/data/x.ts']);
     });
     describe('on Windows', () => {
         // The tool promises the returned paths can be passed back to the file tools, so an external
         // hit must be rendered as a native path and not as the URI-style `/c:/...`.
         it('returns native paths for an allow-listed external searchRoot', async () => {
-            core_1.OS.backend.isWindows = true;
+            OS.backend.isWindows = true;
             allowedExternal = ['C:\\external\\data'];
             searchResults = ['file:///c%3A/external/data/x.ts'];
             const result = JSON.parse(await call({ pattern: '**/*.ts', searchRoot: 'C:\\external\\data' }));
-            (0, chai_1.expect)(result.error).to.be.undefined;
-            (0, chai_1.expect)(result.files).to.deep.equal(['C:\\external\\data\\x.ts']);
+            expect(result.error).to.be.undefined;
+            expect(result.files).to.deep.equal(['C:\\external\\data\\x.ts']);
         });
     });
 });
@@ -820,15 +827,15 @@ describe('WorkspaceFunctionScope gitignore caching', () => {
     let resolveCount;
     let gitignoreReadCount;
     let disableJSDOMInner;
-    before(() => { disableJSDOMInner = (0, jsdom_1.enableJSDOM)(); });
+    before(() => { disableJSDOMInner = enableJSDOM(); });
     after(() => { disableJSDOMInner(); });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         resolveCount = 0;
         gitignoreReadCount = 0;
         const mockWorkspaceService = {
-            roots: Promise.resolve([{ resource: new uri_1.URI('file:///workspace') }]),
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: Promise.resolve([{ resource: new URI('file:///workspace') }]),
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -846,30 +853,30 @@ describe('WorkspaceFunctionScope gitignore caching', () => {
         const mockPreferenceService = {
             get: (path, defaultValue) => (path === 'ai-features.workspaceFunctions.considerGitIgnore' ? true : defaultValue)
         };
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        scope = container.get(workspace_functions_1.WorkspaceFunctionScope);
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        container.bind(WorkspaceFunctionScope).toSelf();
+        scope = container.get(WorkspaceFunctionScope);
     });
     const stat = (path, isDirectory = false) => ({
-        resource: new uri_1.URI(path),
+        resource: new URI(path),
         isDirectory,
         path: { base: path.split('/').pop() }
     });
     it('still excludes gitignored paths and keeps others', async () => {
-        (0, chai_1.expect)(await scope.shouldExclude(stat('file:///workspace/dist/a.js'))).to.be.true;
-        (0, chai_1.expect)(await scope.shouldExclude(stat('file:///workspace/src/b.ts'))).to.be.false;
+        expect(await scope.shouldExclude(stat('file:///workspace/dist/a.js'))).to.be.true;
+        expect(await scope.shouldExclude(stat('file:///workspace/src/b.ts'))).to.be.false;
     });
     it('reads .gitignore at most once and issues no per-check resolve RPC', async () => {
         for (let i = 0; i < 25; i++) {
             await scope.shouldExclude(stat(`file:///workspace/src/file${i}.ts`));
         }
-        (0, chai_1.expect)(gitignoreReadCount).to.equal(1);
-        (0, chai_1.expect)(resolveCount).to.equal(0);
+        expect(gitignoreReadCount).to.equal(1);
+        expect(resolveCount).to.equal(0);
     });
 });
 describe('GetWorkspaceFileList resolves the target directory once', () => {
@@ -877,14 +884,14 @@ describe('GetWorkspaceFileList resolves the target directory once', () => {
     let tool;
     let resolveCount;
     let disableJSDOMInner;
-    before(() => { disableJSDOMInner = (0, jsdom_1.enableJSDOM)(); });
+    before(() => { disableJSDOMInner = enableJSDOM(); });
     after(() => { disableJSDOMInner(); });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         resolveCount = 0;
         const mockWorkspaceService = {
-            roots: Promise.resolve([{ resource: new uri_1.URI('file:///workspace') }]),
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: Promise.resolve([{ resource: new URI('file:///workspace') }]),
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -895,8 +902,8 @@ describe('GetWorkspaceFileList resolves the target directory once', () => {
                     isDirectory: true,
                     resource: uri,
                     children: [
-                        { isDirectory: false, resource: new uri_1.URI('file:///workspace/sub/a.ts'), path: { base: 'a.ts' } },
-                        { isDirectory: true, resource: new uri_1.URI('file:///workspace/sub/dir'), path: { base: 'dir' } }
+                        { isDirectory: false, resource: new URI('file:///workspace/sub/a.ts'), path: { base: 'a.ts' } },
+                        { isDirectory: true, resource: new URI('file:///workspace/sub/dir'), path: { base: 'dir' } }
                     ]
                 };
             },
@@ -905,20 +912,20 @@ describe('GetWorkspaceFileList resolves the target directory once', () => {
             onDidFilesChange: () => ({ dispose: () => { } })
         };
         const mockPreferenceService = { get: (_path, def) => def };
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.GetWorkspaceFileList).toSelf();
-        tool = container.get(workspace_functions_1.GetWorkspaceFileList);
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(GetWorkspaceFileList).toSelf();
+        tool = container.get(GetWorkspaceFileList);
     });
     it('lists one level and resolves the directory only once', async () => {
         const result = JSON.parse(await tool.getTool().handler(JSON.stringify({ path: 'workspace/sub' }), undefined));
-        (0, chai_1.expect)(result).to.deep.equal({ 'a.ts': 'file', 'dir': 'directory' });
-        (0, chai_1.expect)(resolveCount).to.equal(1);
+        expect(result).to.deep.equal({ 'a.ts': 'file', 'dir': 'directory' });
+        expect(resolveCount).to.equal(1);
     });
 });
 describe('GetWorkspaceDirectoryStructure preserves empty folders', () => {
@@ -932,13 +939,13 @@ describe('GetWorkspaceDirectoryStructure preserves empty folders', () => {
         'file:///workspace/node_modules': ['file:///workspace/node_modules/pkg']
     };
     let disableJSDOMInner;
-    before(() => { disableJSDOMInner = (0, jsdom_1.enableJSDOM)(); });
+    before(() => { disableJSDOMInner = enableJSDOM(); });
     after(() => { disableJSDOMInner(); });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         const mockWorkspaceService = {
-            roots: Promise.resolve([{ resource: new uri_1.URI('file:///workspace') }]),
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: Promise.resolve([{ resource: new URI('file:///workspace') }]),
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -947,7 +954,7 @@ describe('GetWorkspaceDirectoryStructure preserves empty folders', () => {
                 resource: uri,
                 children: (TREE[uri.toString()] ?? []).map(child => ({
                     isDirectory: true,
-                    resource: new uri_1.URI(child),
+                    resource: new URI(child),
                     path: { base: child.split('/').pop() }
                 }))
             }),
@@ -958,19 +965,19 @@ describe('GetWorkspaceDirectoryStructure preserves empty folders', () => {
         const mockPreferenceService = {
             get: (path, def) => (path === 'ai-features.workspaceFunctions.userExcludes' ? ['node_modules'] : def)
         };
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.GetWorkspaceDirectoryStructure).toSelf();
-        tool = container.get(workspace_functions_1.GetWorkspaceDirectoryStructure);
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(GetWorkspaceDirectoryStructure).toSelf();
+        tool = container.get(GetWorkspaceDirectoryStructure);
     });
     it('includes empty directories and excludes user-excluded ones', async () => {
         const result = await tool.getTool().handler(JSON.stringify({}), undefined);
-        (0, chai_1.expect)(result).to.deep.equal({
+        expect(result).to.deep.equal({
             workspace: {
                 src: { nested: {} },
                 empty: {}
@@ -985,15 +992,15 @@ describe('FileContentFunction external paths', () => {
     let allowedPaths;
     let trustedScopeOnly;
     let disableJSDOMInner;
-    before(() => { disableJSDOMInner = (0, jsdom_1.enableJSDOM)(); });
+    before(() => { disableJSDOMInner = enableJSDOM(); });
     after(() => { disableJSDOMInner(); });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         allowedPaths = [];
         trustedScopeOnly = false;
         const mockWorkspaceService = {
-            roots: [{ resource: new uri_1.URI('file:///workspace') }],
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: [{ resource: new URI('file:///workspace') }],
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -1018,72 +1025,72 @@ describe('FileContentFunction external paths', () => {
             ready: Promise.resolve(),
             onDidChangeTrust: () => ({ dispose: () => { } })
         };
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(monaco_workspace_1.MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(trustAwareReader);
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer('file:///home/test'));
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.FileContentFunction).toSelf();
-        fileContentFunction = container.get(workspace_functions_1.FileContentFunction);
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
+        container.bind(AiConfigurationService).toConstantValue(trustAwareReader);
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer('file:///home/test'));
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(FileContentFunction).toSelf();
+        fileContentFunction = container.get(FileContentFunction);
     });
     const callTool = (file) => fileContentFunction.getTool().handler(JSON.stringify({ file }), undefined);
     it('rejects absolute path outside the workspace when allow-list is empty', async () => {
         const result = await callTool('/etc/hosts');
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
-        (0, chai_1.expect)(parsed.error).to.include('allowedExternalPaths');
+        expect(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('allowedExternalPaths');
     });
     it('allows absolute path inside an allow-listed directory', async () => {
         allowedPaths = ['/external/configs'];
         const result = await callTool('/external/configs/myapp.json');
-        (0, chai_1.expect)(result).to.equal('content-of-/external/configs/myapp.json');
+        expect(result).to.equal('content-of-/external/configs/myapp.json');
     });
     it('allows file:// URI inside an allow-listed directory', async () => {
         allowedPaths = ['file:///external/configs'];
         const result = await callTool('file:///external/configs/myapp.json');
-        (0, chai_1.expect)(result).to.equal('content-of-/external/configs/myapp.json');
+        expect(result).to.equal('content-of-/external/configs/myapp.json');
     });
     it('rejects sibling that shares the prefix but is not a child', async () => {
         // /external/configs-other must NOT be matched by /external/configs
         allowedPaths = ['/external/configs'];
         const result = await callTool('/external/configs-other/myapp.json');
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('not allowed');
     });
     it('rejects path with .. traversal', async () => {
         allowedPaths = ['/external/configs'];
         const result = await callTool('/external/configs/../secrets.txt');
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('Invalid path');
+        expect(parsed.error).to.include('Invalid path');
     });
     it('expands ~ in allow-list entries', async () => {
         allowedPaths = ['~/configs'];
         const result = await callTool('/home/test/configs/myapp.json');
-        (0, chai_1.expect)(result).to.equal('content-of-/home/test/configs/myapp.json');
+        expect(result).to.equal('content-of-/home/test/configs/myapp.json');
     });
     it('expands ~ in tool input paths', async () => {
         allowedPaths = ['/home/test/configs'];
         const result = await callTool('~/configs/myapp.json');
-        (0, chai_1.expect)(result).to.equal('content-of-/home/test/configs/myapp.json');
+        expect(result).to.equal('content-of-/home/test/configs/myapp.json');
     });
     it('expands ~ in both allow-list entries and tool input paths', async () => {
         allowedPaths = ['~/configs'];
         const result = await callTool('~/configs/myapp.json');
-        (0, chai_1.expect)(result).to.equal('content-of-/home/test/configs/myapp.json');
+        expect(result).to.equal('content-of-/home/test/configs/myapp.json');
     });
     it('rejects ~-prefixed tool input that escapes via .. traversal', async () => {
         allowedPaths = ['/home/test/configs'];
         const result = await callTool('~/configs/../secrets.txt');
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('Invalid path');
+        expect(parsed.error).to.include('Invalid path');
     });
     it('still allows workspace-relative paths', async () => {
         allowedPaths = [];
         const result = await callTool('src/index.ts');
-        (0, chai_1.expect)(result).to.equal('content-of-/workspace/src/index.ts');
+        expect(result).to.equal('content-of-/workspace/src/index.ts');
     });
     it('accepts Windows-style absolute paths in the allow-list', async () => {
         // Mixed: backslash separators in the entry, forward-slash in the file argument
@@ -1091,21 +1098,21 @@ describe('FileContentFunction external paths', () => {
         const result = await callTool('C:/external/configs/myapp.json');
         // The mock returns content keyed off the resolved URI's path. Both forms
         // normalize to the same `file:///c:/external/configs/myapp.json`.
-        (0, chai_1.expect)(result).to.match(/^content-of-/);
-        (0, chai_1.expect)(result).to.include('external/configs/myapp.json');
+        expect(result).to.match(/^content-of-/);
+        expect(result).to.include('external/configs/myapp.json');
     });
     it('accepts Windows drive paths as the tool argument', async () => {
         allowedPaths = ['C:/external'];
         const result = await callTool('C:\\external\\file.txt');
-        (0, chai_1.expect)(result).to.match(/^content-of-/);
-        (0, chai_1.expect)(result).to.include('external/file.txt');
+        expect(result).to.match(/^content-of-/);
+        expect(result).to.include('external/file.txt');
     });
     it('drops workspace-scoped allow-list values when workspace is untrusted', async () => {
         // simulate trust-aware reader behavior: when untrusted, only user/default scope is returned
         trustedScopeOnly = true;
         const result = await callTool('/external/configs/myapp.json');
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('not allowed');
     });
 });
 describe('WorkspaceFunctionScope accessible root contributions', () => {
@@ -1115,17 +1122,17 @@ describe('WorkspaceFunctionScope accessible root contributions', () => {
     let contributionFails;
     let rootQueries;
     let disableJSDOMInner;
-    before(() => { disableJSDOMInner = (0, jsdom_1.enableJSDOM)(); });
+    before(() => { disableJSDOMInner = enableJSDOM(); });
     after(() => { disableJSDOMInner(); });
     beforeEach(() => {
-        container = new inversify_1.Container();
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
+        container = new Container();
+        container.bind(ILogger).to(MockLogger);
         contributedRoots = [];
         contributionFails = false;
         rootQueries = 0;
         const mockWorkspaceService = {
-            roots: [{ resource: new uri_1.URI('file:///workspace') }],
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: [{ resource: new URI('file:///workspace') }],
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -1142,52 +1149,52 @@ describe('WorkspaceFunctionScope accessible root contributions', () => {
                 return contributedRoots;
             }
         };
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue({ get: (_path, defaultValue) => defaultValue });
-        container.bind(monaco_workspace_1.MonacoWorkspace).toConstantValue({ getTextDocument: () => undefined });
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        (0, contribution_provider_1.bindRootContributionProvider)(container, workspace_functions_1.AccessibleRootContribution);
-        container.bind(workspace_functions_1.AccessibleRootContribution).toConstantValue(contribution);
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.FileContentFunction).toSelf();
-        fileContentFunction = container.get(workspace_functions_1.FileContentFunction);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue({ get: (_path, defaultValue) => defaultValue });
+        container.bind(MonacoWorkspace).toConstantValue({ getTextDocument: () => undefined });
+        container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        bindRootContributionProvider(container, AccessibleRootContribution);
+        container.bind(AccessibleRootContribution).toConstantValue(contribution);
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(FileContentFunction).toSelf();
+        fileContentFunction = container.get(FileContentFunction);
     });
     const callTool = (file) => fileContentFunction.getTool().handler(JSON.stringify({ file }), undefined);
     it('allows a file under a contributed root although the allow-list is empty', async () => {
-        contributedRoots = [new uri_1.URI('file:///config/workspace-metadata/uuid/memory')];
+        contributedRoots = [new URI('file:///config/workspace-metadata/uuid/memory')];
         const result = await callTool('/config/workspace-metadata/uuid/memory/wiki/index.md');
-        (0, chai_1.expect)(result).to.equal('content-of-/config/workspace-metadata/uuid/memory/wiki/index.md');
+        expect(result).to.equal('content-of-/config/workspace-metadata/uuid/memory/wiki/index.md');
     });
     it('rejects a sibling that only shares the contributed root\'s prefix', async () => {
-        contributedRoots = [new uri_1.URI('file:///config/memory')];
+        contributedRoots = [new URI('file:///config/memory')];
         const parsed = JSON.parse(await callTool('/config/memory-other/wiki/index.md'));
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('not allowed');
     });
     it('matches a contributed root that carries a trailing separator', async () => {
-        contributedRoots = [new uri_1.URI('file:///config/memory/')];
+        contributedRoots = [new URI('file:///config/memory/')];
         const result = await callTool('/config/memory/wiki/index.md');
-        (0, chai_1.expect)(result).to.equal('content-of-/config/memory/wiki/index.md');
+        expect(result).to.equal('content-of-/config/memory/wiki/index.md');
     });
     it('re-queries the contributions, so a root that moves needs no invalidation', async () => {
-        contributedRoots = [new uri_1.URI('file:///config/first/memory')];
-        (0, chai_1.expect)(await callTool('/config/first/memory/notes.md')).to.match(/^content-of-/);
-        contributedRoots = [new uri_1.URI('file:///config/second/memory')];
-        (0, chai_1.expect)(JSON.parse(await callTool('/config/first/memory/notes.md')).error).to.include('not allowed');
-        (0, chai_1.expect)(await callTool('/config/second/memory/notes.md')).to.match(/^content-of-/);
-        (0, chai_1.expect)(rootQueries).to.equal(3);
+        contributedRoots = [new URI('file:///config/first/memory')];
+        expect(await callTool('/config/first/memory/notes.md')).to.match(/^content-of-/);
+        contributedRoots = [new URI('file:///config/second/memory')];
+        expect(JSON.parse(await callTool('/config/first/memory/notes.md')).error).to.include('not allowed');
+        expect(await callTool('/config/second/memory/notes.md')).to.match(/^content-of-/);
+        expect(rootQueries).to.equal(3);
     });
     it('keeps checking the other sources when a contribution fails', async () => {
         contributionFails = true;
         const parsed = JSON.parse(await callTool('/config/memory/wiki/index.md'));
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('not allowed');
         // The workspace itself is unaffected by the broken contribution.
-        (0, chai_1.expect)(await callTool('src/index.ts')).to.equal('content-of-/workspace/src/index.ts');
+        expect(await callTool('src/index.ts')).to.equal('content-of-/workspace/src/index.ts');
     });
     it('is not consulted for paths inside the workspace', async () => {
-        (0, chai_1.expect)(await callTool('src/index.ts')).to.equal('content-of-/workspace/src/index.ts');
-        (0, chai_1.expect)(rootQueries).to.equal(0);
+        expect(await callTool('src/index.ts')).to.equal('content-of-/workspace/src/index.ts');
+        expect(rootQueries).to.equal(0);
     });
 });
 describe('GetWorkspaceFileList / GetWorkspaceDirectoryStructure with external paths', () => {
@@ -1205,14 +1212,14 @@ describe('GetWorkspaceFileList / GetWorkspaceDirectoryStructure with external pa
         'file:///external/configs/sub': { isDirectory: true, children: [] }
     };
     let disableJSDOMInner;
-    before(() => { disableJSDOMInner = (0, jsdom_1.enableJSDOM)(); });
+    before(() => { disableJSDOMInner = enableJSDOM(); });
     after(() => { disableJSDOMInner(); });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         allowedPaths = [];
         const mockWorkspaceService = {
-            roots: [{ resource: new uri_1.URI('file:///workspace') }],
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: [{ resource: new URI('file:///workspace') }],
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -1229,7 +1236,7 @@ describe('GetWorkspaceFileList / GetWorkspaceDirectoryStructure with external pa
                     children: node.children?.map(child => ({
                         isDirectory: !!FS_TREE[child]?.isDirectory,
                         isFile: !FS_TREE[child]?.isDirectory,
-                        resource: new uri_1.URI(child),
+                        resource: new URI(child),
                         path: { base: child.split('/').pop() }
                     })) ?? []
                 };
@@ -1244,48 +1251,48 @@ describe('GetWorkspaceFileList / GetWorkspaceDirectoryStructure with external pa
             ready: Promise.resolve(),
             onDidChangeTrust: () => ({ dispose: () => { } })
         };
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(trustAwareReader);
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.GetWorkspaceFileList).toSelf();
-        container.bind(workspace_functions_1.GetWorkspaceDirectoryStructure).toSelf();
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(AiConfigurationService).toConstantValue(trustAwareReader);
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(GetWorkspaceFileList).toSelf();
+        container.bind(GetWorkspaceDirectoryStructure).toSelf();
     });
     it('GetWorkspaceFileList rejects absolute path outside the allow-list', async () => {
-        const tool = container.get(workspace_functions_1.GetWorkspaceFileList).getTool();
+        const tool = container.get(GetWorkspaceFileList).getTool();
         const result = await tool.handler(JSON.stringify({ path: '/external/configs' }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('not allowed');
     });
     it('GetWorkspaceFileList lists an allow-listed external directory', async () => {
         allowedPaths = ['/external/configs'];
-        const tool = container.get(workspace_functions_1.GetWorkspaceFileList).getTool();
+        const tool = container.get(GetWorkspaceFileList).getTool();
         const result = await tool.handler(JSON.stringify({ path: '/external/configs' }), undefined);
-        (0, chai_1.expect)(JSON.parse(result)).to.deep.equal({ 'myapp.json': 'file', 'sub': 'directory' });
+        expect(JSON.parse(result)).to.deep.equal({ 'myapp.json': 'file', 'sub': 'directory' });
     });
     it('GetWorkspaceFileList still lists workspace-relative paths', async () => {
-        const tool = container.get(workspace_functions_1.GetWorkspaceFileList).getTool();
+        const tool = container.get(GetWorkspaceFileList).getTool();
         const result = await tool.handler(JSON.stringify({ path: '' }), undefined);
-        (0, chai_1.expect)(JSON.parse(result)).to.deep.equal({ workspace: 'directory' });
+        expect(JSON.parse(result)).to.deep.equal({ workspace: 'directory' });
     });
     it('GetWorkspaceDirectoryStructure rejects external root not in the allow-list', async () => {
-        const tool = container.get(workspace_functions_1.GetWorkspaceDirectoryStructure).getTool();
+        const tool = container.get(GetWorkspaceDirectoryStructure).getTool();
         const result = await tool.handler(JSON.stringify({ root: '/external/configs' }), undefined);
-        (0, chai_1.expect)(result.error).to.include('not allowed');
+        expect(result.error).to.include('not allowed');
     });
     it('GetWorkspaceDirectoryStructure walks an allow-listed external root', async () => {
         allowedPaths = ['/external/configs'];
-        const tool = container.get(workspace_functions_1.GetWorkspaceDirectoryStructure).getTool();
+        const tool = container.get(GetWorkspaceDirectoryStructure).getTool();
         const result = await tool.handler(JSON.stringify({ root: '/external/configs' }), undefined);
-        (0, chai_1.expect)(result).to.deep.equal({ sub: {} });
+        expect(result).to.deep.equal({ sub: {} });
     });
     it('GetWorkspaceDirectoryStructure preserves prior workspace-only behavior when root omitted', async () => {
-        const tool = container.get(workspace_functions_1.GetWorkspaceDirectoryStructure).getTool();
+        const tool = container.get(GetWorkspaceDirectoryStructure).getTool();
         const result = await tool.handler('', undefined);
-        (0, chai_1.expect)(result).to.deep.equal({ workspace: { sub: {} } });
+        expect(result).to.deep.equal({ workspace: { sub: {} } });
     });
 });
 describe('FindFilesByPattern with searchRoot', () => {
@@ -1297,22 +1304,22 @@ describe('FindFilesByPattern with searchRoot', () => {
         'file:///external/configs': ['file:///external/configs/myapp.json', 'file:///external/configs/other.txt']
     };
     let disableJSDOMInner;
-    before(() => { disableJSDOMInner = (0, jsdom_1.enableJSDOM)(); });
+    before(() => { disableJSDOMInner = enableJSDOM(); });
     after(() => { disableJSDOMInner(); });
     // External hits are rendered with `Path.fsPath()`, which branches on the backend OS, so the POSIX
     // fixtures below pin it instead of inheriting the OS the tests happen to run on.
     let originalIsWindows;
     beforeEach(() => {
-        originalIsWindows = core_1.OS.backend.isWindows;
-        core_1.OS.backend.isWindows = false;
+        originalIsWindows = OS.backend.isWindows;
+        OS.backend.isWindows = false;
     });
-    afterEach(() => { core_1.OS.backend.isWindows = originalIsWindows; });
+    afterEach(() => { OS.backend.isWindows = originalIsWindows; });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         allowedPaths = [];
         const mockWorkspaceService = {
-            roots: [{ resource: new uri_1.URI('file:///workspace') }],
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace') }],
+            roots: [{ resource: new URI('file:///workspace') }],
+            tryGetRoots: () => [{ resource: new URI('file:///workspace') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -1328,33 +1335,33 @@ describe('FindFilesByPattern with searchRoot', () => {
             ready: Promise.resolve(),
             onDidChangeTrust: () => ({ dispose: () => { } })
         };
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(trustAwareReader);
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-        container.bind(file_search_service_1.FileSearchService).toConstantValue(makeRipgrepLikeSearchService(FILES_BY_ROOT));
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.FindFilesByPattern).toSelf();
-        findFilesByPattern = container.get(workspace_functions_1.FindFilesByPattern);
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(AiConfigurationService).toConstantValue(trustAwareReader);
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+        container.bind(FileSearchService).toConstantValue(makeRipgrepLikeSearchService(FILES_BY_ROOT));
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(FindFilesByPattern).toSelf();
+        findFilesByPattern = container.get(FindFilesByPattern);
     });
     const callTool = (args) => findFilesByPattern.getTool().handler(JSON.stringify(args), undefined);
     it('searches the workspace by default and returns relative paths', async () => {
         const result = await callTool({ pattern: '**/*.ts' });
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.files).to.deep.equal(['workspace/a.ts']);
+        expect(parsed.files).to.deep.equal(['workspace/a.ts']);
     });
     it('rejects searchRoot that is not in the allow-list', async () => {
         const result = await callTool({ pattern: '**/*.json', searchRoot: '/external/configs' });
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('not allowed');
     });
     it('searches an allow-listed external root and returns absolute paths', async () => {
         allowedPaths = ['/external/configs'];
         const result = await callTool({ pattern: '**/*.json', searchRoot: '/external/configs' });
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.files).to.deep.equal(['/external/configs/myapp.json']);
+        expect(parsed.files).to.deep.equal(['/external/configs/myapp.json']);
     });
     it('honors exclude patterns when using an external searchRoot', async () => {
         allowedPaths = ['/external/configs'];
@@ -1364,7 +1371,7 @@ describe('FindFilesByPattern with searchRoot', () => {
             searchRoot: '/external/configs'
         });
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.files).to.deep.equal(['/external/configs/myapp.json']);
+        expect(parsed.files).to.deep.equal(['/external/configs/myapp.json']);
     });
 });
 describe('WorkspaceFunctionScope path-traversal hardening', () => {
@@ -1374,16 +1381,16 @@ describe('WorkspaceFunctionScope path-traversal hardening', () => {
     let trustReady;
     let trustAwareGet;
     let disableJSDOMInner;
-    before(() => { disableJSDOMInner = (0, jsdom_1.enableJSDOM)(); });
+    before(() => { disableJSDOMInner = enableJSDOM(); });
     after(() => { disableJSDOMInner(); });
     beforeEach(() => {
-        container = new inversify_1.Container();
+        container = new Container();
         allowedPaths = [];
         trustReady = Promise.resolve();
         trustAwareGet = (_name, _fallback) => allowedPaths;
         const mockWorkspaceService = {
-            roots: [{ resource: new uri_1.URI('file:///workspace/project') }],
-            tryGetRoots: () => [{ resource: new uri_1.URI('file:///workspace/project') }],
+            roots: [{ resource: new URI('file:///workspace/project') }],
+            tryGetRoots: () => [{ resource: new URI('file:///workspace/project') }],
             onWorkspaceChanged: () => ({ dispose: () => { } })
         };
         const mockFileService = {
@@ -1408,29 +1415,29 @@ describe('WorkspaceFunctionScope path-traversal hardening', () => {
             get ready() { return trustReady; },
             onDidChangeTrust: () => ({ dispose: () => { } })
         };
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-        container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-        container.bind(file_service_1.FileService).toConstantValue(mockFileService);
-        container.bind(core_1.PreferenceService).toConstantValue(mockPreferenceService);
-        container.bind(monaco_workspace_1.MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
-        container.bind(ai_core_1.AiConfigurationService).toConstantValue(trustAwareReader);
-        container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer('file:///home/test'));
-        container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-        container.bind(workspace_functions_1.FileContentFunction).toSelf();
-        container.bind(workspace_functions_1.FileDiagnosticProvider).toSelf();
+        container.bind(ILogger).to(MockLogger);
+        container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
+        container.bind(AiConfigurationService).toConstantValue(trustAwareReader);
+        container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer('file:///home/test'));
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(FileContentFunction).toSelf();
+        container.bind(FileDiagnosticProvider).toSelf();
         const mockProblemManager = {
             findMarkers: () => [],
             onDidChangeMarkers: () => ({ dispose: () => { } })
         };
-        container.bind(browser_2.ProblemManager).toConstantValue(mockProblemManager);
+        container.bind(ProblemManager).toConstantValue(mockProblemManager);
         const mockMonacoTextModelService = {
             createModelReference: async () => ({
                 object: { lineCount: 10, getText: () => '' },
                 dispose: () => { }
             })
         };
-        container.bind(monaco_text_model_service_1.MonacoTextModelService).toConstantValue(mockMonacoTextModelService);
-        fileContentFunction = container.get(workspace_functions_1.FileContentFunction);
+        container.bind(MonacoTextModelService).toConstantValue(mockMonacoTextModelService);
+        fileContentFunction = container.get(FileContentFunction);
     });
     const callContent = (file) => fileContentFunction.getTool().handler(JSON.stringify({ file }), undefined);
     // Item 1 — URL-encoded and literal `..` in file:// URIs must be normalized
@@ -1440,33 +1447,33 @@ describe('WorkspaceFunctionScope path-traversal hardening', () => {
         allowedPaths = ['/external/configs'];
         const result = await callContent('file:///external/configs/../secrets.txt');
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('not allowed');
     });
     it('rejects file:// URI with percent-encoded %2e%2e traversal', async () => {
         allowedPaths = ['/external/configs'];
         const result = await callContent('file:///external/configs/%2e%2e/secrets.txt');
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('not allowed');
     });
     it('rejects file:// URI with upper-case percent-encoded traversal', async () => {
         allowedPaths = ['/external/configs'];
         const result = await callContent('file:///external/configs/%2E%2E/secrets.txt');
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('not allowed');
     });
     // Item 4 — A filename that contains `..` as a substring but is not a
     // traversal segment must be accepted.
     it('accepts a valid filename whose name contains ".." as a substring', async () => {
         allowedPaths = ['/external/configs'];
         const result = await callContent('/external/configs/my..file.json');
-        (0, chai_1.expect)(result).to.equal('content-of-/external/configs/my..file.json');
+        expect(result).to.equal('content-of-/external/configs/my..file.json');
     });
     // Item 3 — Non-file allow-list entries are documented as unsupported.
     it('rejects http:// allow-list entry even if target path appears to match', async () => {
         allowedPaths = ['http://example.com/external/configs'];
         const result = await callContent('/external/configs/myapp.json');
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('not allowed');
+        expect(parsed.error).to.include('not allowed');
     });
     // Item 7 — getAllowedExternalUris must await AiConfigurationService.ready
     // so that preference reads see the resolved trust state.
@@ -1482,7 +1489,7 @@ describe('WorkspaceFunctionScope path-traversal hardening', () => {
         preferenceVisible = true;
         resolveReady();
         const result = await promise;
-        (0, chai_1.expect)(result).to.equal('content-of-/external/configs/myapp.json');
+        expect(result).to.equal('content-of-/external/configs/myapp.json');
     });
     // Item 2 — On case-insensitive filesystems (Windows, macOS by default)
     // the allow-list match must be case-insensitive. Stub OS.backend flags
@@ -1491,51 +1498,51 @@ describe('WorkspaceFunctionScope path-traversal hardening', () => {
         let originalIsWindows;
         let originalIsOSX;
         beforeEach(() => {
-            originalIsWindows = core_1.OS.backend.isWindows;
-            originalIsOSX = core_1.OS.backend.isOSX;
+            originalIsWindows = OS.backend.isWindows;
+            originalIsOSX = OS.backend.isOSX;
         });
         afterEach(() => {
-            core_1.OS.backend.isWindows = originalIsWindows;
-            core_1.OS.backend.isOSX = originalIsOSX;
+            OS.backend.isWindows = originalIsWindows;
+            OS.backend.isOSX = originalIsOSX;
         });
         it('admits a case-mismatched Windows target when allow-list entry is mixed-case', async () => {
-            core_1.OS.backend.isWindows = true;
-            core_1.OS.backend.isOSX = false;
+            OS.backend.isWindows = true;
+            OS.backend.isOSX = false;
             allowedPaths = ['C:\\External\\Configs'];
             const result = await callContent('c:/external/configs/myapp.json');
             // The mock returns the URI's path; both forms canonicalize to the
             // same file:///c:/... URI (drive letter is lowercased by URI.fromFilePath),
             // but the path segments differ in case.
-            (0, chai_1.expect)(result).to.match(/^content-of-/);
-            (0, chai_1.expect)(result.toLowerCase()).to.include('external/configs/myapp.json');
+            expect(result).to.match(/^content-of-/);
+            expect(result.toLowerCase()).to.include('external/configs/myapp.json');
         });
         it('admits a case-mismatched macOS target when allow-list entry is mixed-case', async () => {
-            core_1.OS.backend.isWindows = false;
-            core_1.OS.backend.isOSX = true;
+            OS.backend.isWindows = false;
+            OS.backend.isOSX = true;
             allowedPaths = ['/Users/safi/External/Configs'];
             const result = await callContent('/users/safi/external/configs/myapp.json');
-            (0, chai_1.expect)(result).to.match(/^content-of-/);
-            (0, chai_1.expect)(result.toLowerCase()).to.include('/users/safi/external/configs/myapp.json');
+            expect(result).to.match(/^content-of-/);
+            expect(result.toLowerCase()).to.include('/users/safi/external/configs/myapp.json');
         });
         it('keeps Linux case-sensitive: rejects a case-mismatched target', async () => {
-            core_1.OS.backend.isWindows = false;
-            core_1.OS.backend.isOSX = false;
+            OS.backend.isWindows = false;
+            OS.backend.isOSX = false;
             allowedPaths = ['/home/safi/External/Configs'];
             const result = await callContent('/home/safi/external/configs/myapp.json');
             const parsed = JSON.parse(result);
-            (0, chai_1.expect)(parsed.error).to.include('not allowed');
+            expect(parsed.error).to.include('not allowed');
         });
     });
     // getFileDiagnostics goes through the same `resolveAccessiblePath` gate as every other tool, so a
     // sibling that merely shares the workspace root's string prefix must not pass.
     it('FileDiagnosticProvider rejects sibling-prefix path outside the workspace', async () => {
-        const diag = container.get(workspace_functions_1.FileDiagnosticProvider);
+        const diag = container.get(FileDiagnosticProvider);
         const handler = diag.getTool().handler;
         // Workspace root is file:///workspace/project, so file:///workspace/project-other/file.txt is
         // outside it — and a `..` segment is refused before it can even be resolved.
         const result = await handler(JSON.stringify({ file: '../project-other/file.txt' }), undefined);
         const parsed = JSON.parse(result);
-        (0, chai_1.expect)(parsed.error).to.include('Invalid path');
+        expect(parsed.error).to.include('Invalid path');
     });
 });
 // ── Branch: Multi-root workspace tests ──────────────────────────────────────
@@ -1544,177 +1551,177 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
     let workspaceScope;
     let disableJSDOMInner;
     before(() => {
-        disableJSDOMInner = (0, jsdom_1.enableJSDOM)();
+        disableJSDOMInner = enableJSDOM();
     });
     after(() => {
         disableJSDOMInner();
     });
     beforeEach(() => {
-        container = new inversify_1.Container();
-        container.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
+        container = new Container();
+        container.bind(ILogger).to(MockLogger);
     });
     describe('getRootMapping', () => {
         it('returns single root with its basename', () => {
             const mockWorkspaceService = {
-                tryGetRoots: () => [{ resource: new uri_1.URI('file:///home/user/my-project') }],
+                tryGetRoots: () => [{ resource: new URI('file:///home/user/my-project') }],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
             const mapping = workspaceScope.getRootMapping();
-            (0, chai_1.expect)(mapping.size).to.equal(1);
-            (0, chai_1.expect)(mapping.get('my-project')?.toString()).to.equal('file:///home/user/my-project');
+            expect(mapping.size).to.equal(1);
+            expect(mapping.get('my-project')?.toString()).to.equal('file:///home/user/my-project');
         });
         it('returns multiple roots with their basenames', () => {
             const mockWorkspaceService = {
                 tryGetRoots: () => [
-                    { resource: new uri_1.URI('file:///home/user/frontend') },
-                    { resource: new uri_1.URI('file:///home/user/backend') },
-                    { resource: new uri_1.URI('file:///home/user/shared') }
+                    { resource: new URI('file:///home/user/frontend') },
+                    { resource: new URI('file:///home/user/backend') },
+                    { resource: new URI('file:///home/user/shared') }
                 ],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
             const mapping = workspaceScope.getRootMapping();
-            (0, chai_1.expect)(mapping.size).to.equal(3);
-            (0, chai_1.expect)(mapping.get('frontend')?.toString()).to.equal('file:///home/user/frontend');
-            (0, chai_1.expect)(mapping.get('backend')?.toString()).to.equal('file:///home/user/backend');
-            (0, chai_1.expect)(mapping.get('shared')?.toString()).to.equal('file:///home/user/shared');
+            expect(mapping.size).to.equal(3);
+            expect(mapping.get('frontend')?.toString()).to.equal('file:///home/user/frontend');
+            expect(mapping.get('backend')?.toString()).to.equal('file:///home/user/backend');
+            expect(mapping.get('shared')?.toString()).to.equal('file:///home/user/shared');
         });
         it('names roots sharing a basename as peers', () => {
             const mockWorkspaceService = {
                 tryGetRoots: () => [
-                    { resource: new uri_1.URI('file:///alice/app') },
-                    { resource: new uri_1.URI('file:///bob/app') }
+                    { resource: new URI('file:///alice/app') },
+                    { resource: new URI('file:///bob/app') }
                 ],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
             const mapping = workspaceScope.getRootMapping();
-            (0, chai_1.expect)(mapping.size).to.equal(2);
-            (0, chai_1.expect)(mapping.get('alice/app')?.toString()).to.equal('file:///alice/app');
-            (0, chai_1.expect)(mapping.get('bob/app')?.toString()).to.equal('file:///bob/app');
+            expect(mapping.size).to.equal(2);
+            expect(mapping.get('alice/app')?.toString()).to.equal('file:///alice/app');
+            expect(mapping.get('bob/app')?.toString()).to.equal('file:///bob/app');
         });
     });
     describe('toWorkspaceRelativePath', () => {
         it('returns root-prefixed path for file in single root', () => {
             const mockWorkspaceService = {
-                tryGetRoots: () => [{ resource: new uri_1.URI('file:///home/user/project') }],
+                tryGetRoots: () => [{ resource: new URI('file:///home/user/project') }],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
-            const uri = new uri_1.URI('file:///home/user/project/src/index.ts');
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
+            const uri = new URI('file:///home/user/project/src/index.ts');
             const result = workspaceScope.toWorkspaceRelativePath(uri);
-            (0, chai_1.expect)(result).to.equal('project/src/index.ts');
+            expect(result).to.equal('project/src/index.ts');
         });
         it('returns root-prefixed path for file in multi-root workspace', () => {
             const mockWorkspaceService = {
                 tryGetRoots: () => [
-                    { resource: new uri_1.URI('file:///home/user/frontend') },
-                    { resource: new uri_1.URI('file:///home/user/backend') }
+                    { resource: new URI('file:///home/user/frontend') },
+                    { resource: new URI('file:///home/user/backend') }
                 ],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
-            const frontendFile = new uri_1.URI('file:///home/user/frontend/src/App.tsx');
-            (0, chai_1.expect)(workspaceScope.toWorkspaceRelativePath(frontendFile)).to.equal('frontend/src/App.tsx');
-            const backendFile = new uri_1.URI('file:///home/user/backend/src/server.ts');
-            (0, chai_1.expect)(workspaceScope.toWorkspaceRelativePath(backendFile)).to.equal('backend/src/server.ts');
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
+            const frontendFile = new URI('file:///home/user/frontend/src/App.tsx');
+            expect(workspaceScope.toWorkspaceRelativePath(frontendFile)).to.equal('frontend/src/App.tsx');
+            const backendFile = new URI('file:///home/user/backend/src/server.ts');
+            expect(workspaceScope.toWorkspaceRelativePath(backendFile)).to.equal('backend/src/server.ts');
         });
         it('returns undefined for file outside workspace', () => {
             const mockWorkspaceService = {
-                tryGetRoots: () => [{ resource: new uri_1.URI('file:///home/user/project') }],
+                tryGetRoots: () => [{ resource: new URI('file:///home/user/project') }],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
-            const uri = new uri_1.URI('file:///etc/passwd');
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
+            const uri = new URI('file:///etc/passwd');
             const result = workspaceScope.toWorkspaceRelativePath(uri);
-            (0, chai_1.expect)(result).to.be.undefined;
+            expect(result).to.be.undefined;
         });
         it('returns just root name for the root directory itself', () => {
             const mockWorkspaceService = {
-                tryGetRoots: () => [{ resource: new uri_1.URI('file:///home/user/project') }],
+                tryGetRoots: () => [{ resource: new URI('file:///home/user/project') }],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
-            const uri = new uri_1.URI('file:///home/user/project');
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
+            const uri = new URI('file:///home/user/project');
             const result = workspaceScope.toWorkspaceRelativePath(uri);
             // When the URI is the root itself, it returns just the root name
-            (0, chai_1.expect)(result).to.equal('project');
+            expect(result).to.equal('project');
         });
     });
     describe('resolveRelativePath', () => {
         function createScope(roots) {
-            const rootObjects = roots.map(r => ({ resource: new uri_1.URI(r) }));
+            const rootObjects = roots.map(r => ({ resource: new URI(r) }));
             const mockWorkspaceService = {
                 tryGetRoots: () => rootObjects,
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            return container.get(workspace_functions_1.WorkspaceFunctionScope);
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            return container.get(WorkspaceFunctionScope);
         }
         describe('Phase 1 — root+relative', () => {
             it('resolves path with matching root prefix', () => {
                 workspaceScope = createScope(['file:///home/user/frontend', 'file:///home/user/backend']);
                 const result = workspaceScope.resolveRelativePath('backend/src/server.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/backend/src/server.ts');
+                expect(result.toString()).to.equal('file:///home/user/backend/src/server.ts');
             });
             it('returns the root URI when path is just a root name', () => {
                 workspaceScope = createScope(['file:///home/user/frontend', 'file:///home/user/backend']);
                 const result = workspaceScope.resolveRelativePath('frontend');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/frontend');
+                expect(result.toString()).to.equal('file:///home/user/frontend');
             });
             it('root name takes priority over subdirectory with same name', () => {
                 // Root named 'src' exists, AND another root has a 'src/' subdirectory
                 workspaceScope = createScope(['file:///home/user/src', 'file:///home/user/app']);
                 const result = workspaceScope.resolveRelativePath('src/index.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/src/index.ts');
+                expect(result.toString()).to.equal('file:///home/user/src/index.ts');
             });
         });
         describe('Phase 2 — supra-relative', () => {
@@ -1722,114 +1729,114 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
                 workspaceScope = createScope(['file:///home/user/backend']);
                 // 'user/backend/src/file.ts' — 'backend' matches root basename, 'user' matches preceding component
                 const result = workspaceScope.resolveRelativePath('user/backend/src/file.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/backend/src/file.ts');
+                expect(result.toString()).to.equal('file:///home/user/backend/src/file.ts');
             });
             it('resolves with full preceding path match', () => {
                 workspaceScope = createScope(['file:///home/user/backend']);
                 const result = workspaceScope.resolveRelativePath('home/user/backend/src/file.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/backend/src/file.ts');
+                expect(result.toString()).to.equal('file:///home/user/backend/src/file.ts');
             });
             it('does not match when preceding components differ', () => {
                 // Must use multi-root so Phase 3 (single-root fallback) doesn't short-circuit
                 workspaceScope = createScope(['file:///home/user/frontend', 'file:///home/user/backend']);
                 // 'other/backend/src/file.ts' — 'other' does NOT match any suffix of 'home/user'
-                (0, chai_1.expect)(() => workspaceScope.resolveRelativePath('other/backend/src/file.ts')).to.throw(/Could not resolve path/);
+                expect(() => workspaceScope.resolveRelativePath('other/backend/src/file.ts')).to.throw(/Could not resolve path/);
             });
             it('resolves with no preceding components (just root basename at start)', () => {
                 // This should be caught by Phase 1 (root+relative) since the first segment IS the root name
                 workspaceScope = createScope(['file:///home/user/backend']);
                 const result = workspaceScope.resolveRelativePath('backend/src/file.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/backend/src/file.ts');
+                expect(result.toString()).to.equal('file:///home/user/backend/src/file.ts');
             });
             it('resolves supra-relative path in multi-root workspace', () => {
                 workspaceScope = createScope(['file:///home/user/frontend', 'file:///home/user/backend']);
                 const result = workspaceScope.resolveRelativePath('user/backend/src/file.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/backend/src/file.ts');
+                expect(result.toString()).to.equal('file:///home/user/backend/src/file.ts');
             });
         });
         describe('Phase 3 — single-root fallback', () => {
             it('resolves unprefixed path relative to the single root', () => {
                 workspaceScope = createScope(['file:///home/user/project']);
                 const result = workspaceScope.resolveRelativePath('src/index.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/project/src/index.ts');
+                expect(result.toString()).to.equal('file:///home/user/project/src/index.ts');
             });
             it('resolves new file path relative to single root', () => {
                 workspaceScope = createScope(['file:///home/user/project']);
                 const result = workspaceScope.resolveRelativePath('new-file.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/project/new-file.ts');
+                expect(result.toString()).to.equal('file:///home/user/project/new-file.ts');
             });
         });
         describe('Phase 4 — error for unresolvable multi-root paths', () => {
             it('throws when unprefixed path cannot be resolved in multi-root', () => {
                 workspaceScope = createScope(['file:///home/user/frontend', 'file:///home/user/backend']);
-                (0, chai_1.expect)(() => workspaceScope.resolveRelativePath('src/index.ts')).to.throw(/Could not resolve path/);
+                expect(() => workspaceScope.resolveRelativePath('src/index.ts')).to.throw(/Could not resolve path/);
             });
             it('error message lists available roots', () => {
                 workspaceScope = createScope(['file:///home/user/frontend', 'file:///home/user/backend']);
                 try {
                     workspaceScope.resolveRelativePath('src/index.ts');
-                    chai_1.expect.fail('Expected an error');
+                    expect.fail('Expected an error');
                 }
                 catch (e) {
                     const error = e;
-                    (0, chai_1.expect)(error.message).to.include('frontend');
-                    (0, chai_1.expect)(error.message).to.include('backend');
+                    expect(error.message).to.include('frontend');
+                    expect(error.message).to.include('backend');
                 }
             });
             it('does not throw when root prefix is provided in multi-root', () => {
                 workspaceScope = createScope(['file:///home/user/frontend', 'file:///home/user/backend']);
                 const result = workspaceScope.resolveRelativePath('frontend/src/index.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/frontend/src/index.ts');
+                expect(result.toString()).to.equal('file:///home/user/frontend/src/index.ts');
             });
         });
         describe('normalization', () => {
             it('normalizes backslash paths', () => {
                 workspaceScope = createScope(['file:///home/user/project']);
                 const result = workspaceScope.resolveRelativePath('project\\src\\index.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/project/src/index.ts');
+                expect(result.toString()).to.equal('file:///home/user/project/src/index.ts');
             });
             it('resolves .. segments', () => {
                 workspaceScope = createScope(['file:///home/user/project']);
                 const result = workspaceScope.resolveRelativePath('project/src/../src/index.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///home/user/project/src/index.ts');
+                expect(result.toString()).to.equal('file:///home/user/project/src/index.ts');
             });
             it('normalizes redundant separators', () => {
                 workspaceScope = createScope(['file:///home/user/project']);
                 const result = workspaceScope.resolveRelativePath('project/src//index.ts');
-                (0, chai_1.expect)(result.path.toString()).to.include('project/src/index.ts');
+                expect(result.path.toString()).to.include('project/src/index.ts');
             });
             it('handles trailing slashes', () => {
                 workspaceScope = createScope(['file:///home/user/project']);
                 const result = workspaceScope.resolveRelativePath('project/src/');
-                (0, chai_1.expect)(result.path.toString()).to.include('project/src');
+                expect(result.path.toString()).to.include('project/src');
             });
         });
         describe('duplicate root basenames', () => {
             it('names all roots sharing a basename as peers and round-trips each of them', () => {
                 workspaceScope = createScope(['file:///workspace/a/app', 'file:///workspace/b/app']);
                 const mapping = workspaceScope.getRootMapping();
-                (0, chai_1.expect)(Array.from(mapping.keys())).to.deep.equal(['a/app', 'b/app']);
+                expect(Array.from(mapping.keys())).to.deep.equal(['a/app', 'b/app']);
                 for (const [name, rootUri] of mapping) {
                     const uri = rootUri.resolve('src/index.ts');
                     const relPath = workspaceScope.toWorkspaceRelativePath(uri);
-                    (0, chai_1.expect)(relPath).to.equal(`${name}/src/index.ts`);
-                    (0, chai_1.expect)(workspaceScope.resolveRelativePath(relPath).toString()).to.equal(uri.toString());
+                    expect(relPath).to.equal(`${name}/src/index.ts`);
+                    expect(workspaceScope.resolveRelativePath(relPath).toString()).to.equal(uri.toString());
                 }
             });
             it('rejects the shared basename as ambiguous', () => {
                 workspaceScope = createScope(['file:///workspace/a/app', 'file:///workspace/b/app']);
-                (0, chai_1.expect)(() => workspaceScope.resolveRelativePath('app/src/index.ts')).to.throw(/ambiguous.*a\/app.*b\/app/);
+                expect(() => workspaceScope.resolveRelativePath('app/src/index.ts')).to.throw(/ambiguous.*a\/app.*b\/app/);
             });
             it('resolves a longer parent-qualified path (Phase 2)', () => {
                 workspaceScope = createScope(['file:///workspace/a/app', 'file:///workspace/b/app']);
                 const result = workspaceScope.resolveRelativePath('workspace/b/app/src/index.ts');
-                (0, chai_1.expect)(result.toString()).to.equal('file:///workspace/b/app/src/index.ts');
+                expect(result.toString()).to.equal('file:///workspace/b/app/src/index.ts');
             });
             // The external file change notice names files by a uri when roots share a basename.
             it('resolves a uri for a root sharing its basename', async () => {
                 workspaceScope = createScope(['file:///workspace/a/app', 'file:///workspace/b/app']);
                 const uri = 'file:///workspace/b/app/src/index.ts';
-                (0, chai_1.expect)((await workspaceScope.resolveAccessiblePath(uri)).toString()).to.equal(uri);
+                expect((await workspaceScope.resolveAccessiblePath(uri)).toString()).to.equal(uri);
             });
         });
     });
@@ -1838,131 +1845,131 @@ describe('WorkspaceFunctionScope Multi-Root Tests', () => {
             // First ordering
             const mockWorkspaceServiceA = {
                 tryGetRoots: () => [
-                    { resource: new uri_1.URI('file:///workspace/b/app') },
-                    { resource: new uri_1.URI('file:///workspace/a/app') }
+                    { resource: new URI('file:///workspace/b/app') },
+                    { resource: new URI('file:///workspace/a/app') }
                 ],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceServiceA));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            const scopeA = container.get(workspace_functions_1.WorkspaceFunctionScope);
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceServiceA));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            const scopeA = container.get(WorkspaceFunctionScope);
             const mappingA = scopeA.getRootMapping();
             // Reverse ordering in a fresh container
-            const container2 = new inversify_1.Container();
+            const container2 = new Container();
             const mockWorkspaceServiceB = {
                 tryGetRoots: () => [
-                    { resource: new uri_1.URI('file:///workspace/a/app') },
-                    { resource: new uri_1.URI('file:///workspace/b/app') }
+                    { resource: new URI('file:///workspace/a/app') },
+                    { resource: new URI('file:///workspace/b/app') }
                 ],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container2.bind(core_1.ILogger).to(mock_logger_1.MockLogger);
-            container2.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceServiceB));
-            container2.bind(file_service_1.FileService).toConstantValue({});
-            container2.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container2.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container2.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container2.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            const scopeB = container2.get(workspace_functions_1.WorkspaceFunctionScope);
+            container2.bind(ILogger).to(MockLogger);
+            container2.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceServiceB));
+            container2.bind(FileService).toConstantValue({});
+            container2.bind(PreferenceService).toConstantValue({ get: () => false });
+            container2.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container2.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container2.bind(WorkspaceFunctionScope).toSelf();
+            const scopeB = container2.get(WorkspaceFunctionScope);
             const mappingB = scopeB.getRootMapping();
             for (const name of ['a/app', 'b/app']) {
-                (0, chai_1.expect)(mappingA.get(name)?.toString()).to.equal(mappingB.get(name)?.toString());
+                expect(mappingA.get(name)?.toString()).to.equal(mappingB.get(name)?.toString());
             }
-            (0, chai_1.expect)(mappingA.get('a/app')?.toString()).to.equal('file:///workspace/a/app');
+            expect(mappingA.get('a/app')?.toString()).to.equal('file:///workspace/a/app');
         });
     });
     describe('getContainingRoot', () => {
         it('returns the most specific root for nested roots', () => {
             const mockWorkspaceService = {
                 tryGetRoots: () => [
-                    { resource: new uri_1.URI('file:///projects/monorepo') },
-                    { resource: new uri_1.URI('file:///projects/monorepo/packages/shared') }
+                    { resource: new URI('file:///projects/monorepo') },
+                    { resource: new URI('file:///projects/monorepo/packages/shared') }
                 ],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
             // File in nested root should resolve to the more specific root
-            const fileInNested = new uri_1.URI('file:///projects/monorepo/packages/shared/src/utils.ts');
+            const fileInNested = new URI('file:///projects/monorepo/packages/shared/src/utils.ts');
             const result = workspaceScope.getContainingRoot(fileInNested);
-            (0, chai_1.expect)(result?.toString()).to.equal('file:///projects/monorepo/packages/shared');
+            expect(result?.toString()).to.equal('file:///projects/monorepo/packages/shared');
             // File in parent root (outside nested) should resolve to parent
-            const fileInParent = new uri_1.URI('file:///projects/monorepo/src/main.ts');
+            const fileInParent = new URI('file:///projects/monorepo/src/main.ts');
             const resultParent = workspaceScope.getContainingRoot(fileInParent);
-            (0, chai_1.expect)(resultParent?.toString()).to.equal('file:///projects/monorepo');
+            expect(resultParent?.toString()).to.equal('file:///projects/monorepo');
         });
         it('returns undefined for file outside all workspace roots', () => {
             const mockWorkspaceService = {
                 tryGetRoots: () => [
-                    { resource: new uri_1.URI('file:///home/user/project') }
+                    { resource: new URI('file:///home/user/project') }
                 ],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
-            const externalFile = new uri_1.URI('file:///tmp/outside.ts');
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
+            const externalFile = new URI('file:///tmp/outside.ts');
             const result = workspaceScope.getContainingRoot(externalFile);
-            (0, chai_1.expect)(result).to.be.undefined;
+            expect(result).to.be.undefined;
         });
     });
     describe('round-trip consistency', () => {
         it('toWorkspaceRelativePath and resolveRelativePath are inverses', () => {
             const mockWorkspaceService = {
                 tryGetRoots: () => [
-                    { resource: new uri_1.URI('file:///home/user/frontend') },
-                    { resource: new uri_1.URI('file:///home/user/backend') }
+                    { resource: new URI('file:///home/user/frontend') },
+                    { resource: new URI('file:///home/user/backend') }
                 ],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
-            const originalUri = new uri_1.URI('file:///home/user/backend/src/index.ts');
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
+            const originalUri = new URI('file:///home/user/backend/src/index.ts');
             const relativePath = workspaceScope.toWorkspaceRelativePath(originalUri);
             const resolvedUri = workspaceScope.resolveRelativePath(relativePath);
-            (0, chai_1.expect)(resolvedUri.toString()).to.equal(originalUri.toString());
+            expect(resolvedUri.toString()).to.equal(originalUri.toString());
         });
         it('paths from toWorkspaceRelativePath always have a root prefix that resolves directly', () => {
             const mockWorkspaceService = {
                 tryGetRoots: () => [
-                    { resource: new uri_1.URI('file:///home/user/frontend') },
-                    { resource: new uri_1.URI('file:///home/user/backend') }
+                    { resource: new URI('file:///home/user/frontend') },
+                    { resource: new URI('file:///home/user/backend') }
                 ],
                 onWorkspaceChanged: () => ({ dispose: () => { } })
             };
-            container.bind(browser_1.WorkspaceService).toConstantValue((0, with_workspace_service_defaults_1.withWorkspaceServiceDefaults)(mockWorkspaceService));
-            container.bind(file_service_1.FileService).toConstantValue({});
-            container.bind(core_1.PreferenceService).toConstantValue({ get: () => false });
-            container.bind(ai_core_1.AiConfigurationService).toConstantValue(makeTrustAwareReader());
-            container.bind(env_variables_1.EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
-            container.bind(workspace_functions_1.WorkspaceFunctionScope).toSelf();
-            workspaceScope = container.get(workspace_functions_1.WorkspaceFunctionScope);
+            container.bind(WorkspaceService).toConstantValue(withWorkspaceServiceDefaults(mockWorkspaceService));
+            container.bind(FileService).toConstantValue({});
+            container.bind(PreferenceService).toConstantValue({ get: () => false });
+            container.bind(AiConfigurationService).toConstantValue(makeTrustAwareReader());
+            container.bind(EnvVariablesServer).toConstantValue(makeEnvVariablesServer());
+            container.bind(WorkspaceFunctionScope).toSelf();
+            workspaceScope = container.get(WorkspaceFunctionScope);
             // Test for each root
             const roots = workspaceScope.getRootMapping();
             for (const [rootName, rootUri] of roots) {
                 const fileUri = rootUri.resolve('src/app.ts');
                 const relPath = workspaceScope.toWorkspaceRelativePath(fileUri);
-                (0, chai_1.expect)(relPath.startsWith(rootName + '/')).to.be.true;
+                expect(relPath.startsWith(rootName + '/')).to.be.true;
                 const resolved = workspaceScope.resolveRelativePath(relPath);
-                (0, chai_1.expect)(resolved.toString()).to.equal(fileUri.toString());
+                expect(resolved.toString()).to.equal(fileUri.toString());
             }
         });
     });