From b1b5c1e6811411a31bb8fb8bd3708c4cbf673667 Mon Sep 17 00:00:00 2001
From: Daniel Imms <2193314+Tyriar@users.noreply.github.com>
Date: Wed, 31 Dec 2025 07:11:50 -0800
Subject: [PATCH 01/10] Auto approve npm scripts by default

Fixes #285509
---
 ...commandLineNpmScriptAutoApproveAnalyzer.ts | 265 ++++++++++++++
 .../browser/tools/runInTerminalTool.ts        |   2 +
 .../terminalChatAgentToolsConfiguration.ts    |   8 +
 ...ndLineNpmScriptAutoApproveAnalyzer.test.ts | 329 ++++++++++++++++++
 4 files changed, 604 insertions(+)
 create mode 100644 src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
 create mode 100644 src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts

diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
new file mode 100644
index 0000000000000..6b913ce3716a0
--- /dev/null
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
@@ -0,0 +1,265 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { visit, type JSONVisitor } from '../../../../../../../base/common/json.js';
+import { Disposable } from '../../../../../../../base/common/lifecycle.js';
+import { URI } from '../../../../../../../base/common/uri.js';
+import { IConfigurationService } from '../../../../../../../platform/configuration/common/configuration.js';
+import { IFileService } from '../../../../../../../platform/files/common/files.js';
+import { IWorkspaceContextService } from '../../../../../../../platform/workspace/common/workspace.js';
+import { TerminalChatAgentToolsSettingId } from '../../../common/terminalChatAgentToolsConfiguration.js';
+import type { TreeSitterCommandParser } from '../../treeSitterCommandParser.js';
+import type { ICommandLineAnalyzer, ICommandLineAnalyzerOptions, ICommandLineAnalyzerResult } from './commandLineAnalyzer.js';
+import { MarkdownString } from '../../../../../../../base/common/htmlContent.js';
+import { localize } from '../../../../../../../nls.js';
+import { IStorageService, StorageScope } from '../../../../../../../platform/storage/common/storage.js';
+import { TerminalToolConfirmationStorageKeys } from '../../../../../chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
+
+/**
+ * Regex patterns to match npm/yarn/pnpm run commands and extract the script name.
+ * Captures the script name in group 1.
+ */
+const npmRunPatterns = [
+	// npm run <script>, npm run-script <script>
+	/^npm\s+(?:run(?:-script)?)\s+([^\s&|;]+)/i,
+	// yarn run <script>
+	/^yarn\s+run\s+([^\s&|;]+)/i,
+	// yarn <script> (shorthand, but exclude yarn built-in commands)
+	/^yarn\s+([^\s&|;]+)/i,
+	// pnpm run <script>
+	/^pnpm\s+run\s+([^\s&|;]+)/i,
+	// pnpm <script> (shorthand)
+	/^pnpm\s+([^\s&|;]+)/i,
+];
+
+/**
+ * Yarn built-in commands that should not be treated as script names.
+ */
+const yarnBuiltinCommands = new Set([
+	'add', 'audit', 'autoclean', 'bin', 'cache', 'check', 'config',
+	'create', 'dedupe', 'dlx', 'exec', 'explain', 'generate-lock-entry',
+	'global', 'help', 'import', 'info', 'init', 'install', 'licenses',
+	'link', 'list', 'login', 'logout', 'node', 'outdated', 'owner',
+	'pack', 'patch', 'patch-commit', 'plugin', 'policies', 'publish',
+	'rebuild', 'remove', 'run', 'search', 'set', 'stage', 'tag', 'team',
+	'test', 'unlink', 'unplug', 'up', 'upgrade', 'upgrade-interactive',
+	'version', 'versions', 'why', 'workspace', 'workspaces',
+]);
+
+/**
+ * pnpm built-in commands that should not be treated as script names.
+ */
+const pnpmBuiltinCommands = new Set([
+	'add', 'audit', 'bin', 'config', 'dedupe', 'deploy', 'dlx', 'doctor',
+	'env', 'exec', 'fetch', 'import', 'init', 'install', 'install-test',
+	'licenses', 'link', 'list', 'ln', 'ls', 'outdated', 'pack', 'patch',
+	'patch-commit', 'patch-remove', 'prune', 'publish', 'rb', 'rebuild',
+	'remove', 'rm', 'root', 'run', 'server', 'setup', 'store', 'test',
+	'un', 'uninstall', 'unlink', 'up', 'update', 'why',
+]);
+
+interface IPackageJsonScripts {
+	uri: URI;
+	scripts: Set<string>;
+}
+
+export class CommandLineNpmScriptAutoApproveAnalyzer extends Disposable implements ICommandLineAnalyzer {
+
+	constructor(
+		private readonly _treeSitterCommandParser: TreeSitterCommandParser,
+		private readonly _log: (message: string, ...args: unknown[]) => void,
+		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@IFileService private readonly _fileService: IFileService,
+		@IStorageService private readonly _storageService: IStorageService,
+		@IWorkspaceContextService private readonly _workspaceContextService: IWorkspaceContextService,
+	) {
+		super();
+	}
+
+	async analyze(options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult> {
+		// Check if the feature is enabled
+		const isNpmScriptAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts) === true;
+		if (!isNpmScriptAutoApproveEnabled) {
+			return { isAutoApproveAllowed: true };
+		}
+
+		// Check if auto-approve is enabled
+		const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
+		const isAutoApproveWarningAccepted = this._storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
+		if (!isAutoApproveEnabled || !isAutoApproveWarningAccepted) {
+			return { isAutoApproveAllowed: true };
+		}
+
+		// Parse sub-commands
+		let subCommands: string[] | undefined;
+		try {
+			subCommands = await this._treeSitterCommandParser.extractSubCommands(options.treeSitterLanguage, options.commandLine);
+			this._log('Parsed sub-commands for npm script check', subCommands);
+		} catch (e) {
+			this._log('Failed to parse sub-commands for npm script check');
+			return { isAutoApproveAllowed: true };
+		}
+
+		if (!subCommands || subCommands.length === 0) {
+			return { isAutoApproveAllowed: true };
+		}
+
+		// Extract script names from npm/yarn/pnpm run commands
+		const scriptNamesToCheck = this._extractScriptNames(subCommands);
+		if (scriptNamesToCheck.length === 0) {
+			return { isAutoApproveAllowed: true };
+		}
+
+		this._log('Script names to check', scriptNamesToCheck);
+
+		// Find and parse package.json
+		const packageJsonScripts = await this._getPackageJsonScripts(options.cwd);
+		if (!packageJsonScripts) {
+			this._log('No package.json found or no scripts section');
+			return { isAutoApproveAllowed: true };
+		}
+
+		this._log('Found package.json scripts', Array.from(packageJsonScripts.scripts));
+
+		// Check if all script names exist in package.json
+		const allScriptsExist = scriptNamesToCheck.every(script => packageJsonScripts.scripts.has(script));
+		if (!allScriptsExist) {
+			const missingScripts = scriptNamesToCheck.filter(script => !packageJsonScripts.scripts.has(script));
+			this._log('Some scripts not found in package.json', missingScripts);
+			return { isAutoApproveAllowed: true };
+		}
+
+		this._log('All scripts found in package.json, auto-approving');
+
+		// All scripts exist - auto approve
+		const scriptsList = scriptNamesToCheck.length === 1
+			? `\`${scriptNamesToCheck[0]}\``
+			: scriptNamesToCheck.map(s => `\`${s}\``).join(', ');
+
+		return {
+			isAutoApproved: true,
+			isAutoApproveAllowed: true,
+			autoApproveInfo: new MarkdownString(
+				localize('autoApprove.npmScript', 'Auto approved as {0} is defined in package.json', scriptsList)
+			),
+		};
+	}
+
+	/**
+	 * Extracts script names from npm/yarn/pnpm run commands.
+	 */
+	private _extractScriptNames(subCommands: string[]): string[] {
+		const scriptNames: string[] = [];
+
+		for (const subCommand of subCommands) {
+			const trimmedCommand = subCommand.trim();
+
+			for (const pattern of npmRunPatterns) {
+				const match = trimmedCommand.match(pattern);
+				if (match && match[1]) {
+					const scriptName = match[1];
+
+					// Check if this is a yarn/pnpm shorthand that matches a built-in command
+					if (pattern.source.includes('yarn\\s+([^')) {
+						if (yarnBuiltinCommands.has(scriptName.toLowerCase())) {
+							continue;
+						}
+					}
+					if (pattern.source.includes('pnpm\\s+([^')) {
+						if (pnpmBuiltinCommands.has(scriptName.toLowerCase())) {
+							continue;
+						}
+					}
+
+					scriptNames.push(scriptName);
+					break; // Only match one pattern per sub-command
+				}
+			}
+		}
+
+		return scriptNames;
+	}
+
+	/**
+	 * Finds and parses package.json to get the scripts section.
+	 */
+	private async _getPackageJsonScripts(cwd: URI | undefined): Promise<IPackageJsonScripts | undefined> {
+		// Try cwd first
+		if (cwd) {
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			const scripts = await this._readPackageJsonScripts(packageJsonUri);
+			if (scripts) {
+				return { uri: packageJsonUri, scripts };
+			}
+		}
+
+		// Fall back to workspace folder roots
+		const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
+		for (const folder of workspaceFolders) {
+			const packageJsonUri = URI.joinPath(folder.uri, 'package.json');
+			const scripts = await this._readPackageJsonScripts(packageJsonUri);
+			if (scripts) {
+				return { uri: packageJsonUri, scripts };
+			}
+		}
+
+		return undefined;
+	}
+
+	/**
+	 * Reads and parses the scripts section from a package.json file.
+	 */
+	private async _readPackageJsonScripts(packageJsonUri: URI): Promise<Set<string> | undefined> {
+		try {
+			const exists = await this._fileService.exists(packageJsonUri);
+			if (!exists) {
+				return undefined;
+			}
+
+			const content = await this._fileService.readFile(packageJsonUri);
+			const text = content.value.toString();
+
+			return this._parsePackageJsonScripts(text);
+		} catch (e) {
+			this._log('Failed to read package.json', packageJsonUri.toString(), e);
+			return undefined;
+		}
+	}
+
+	/**
+	 * Parses the scripts section from package.json content using jsonc-parser.
+	 */
+	private _parsePackageJsonScripts(content: string): Set<string> | undefined {
+		const scripts = new Set<string>();
+		let inScripts = false;
+		let level = 0;
+
+		const visitor: JSONVisitor = {
+			onError() {
+				// Ignore parse errors
+			},
+			onObjectBegin() {
+				level++;
+			},
+			onObjectEnd() {
+				if (inScripts && level === 2) {
+					inScripts = false;
+				}
+				level--;
+			},
+			onObjectProperty(property: string) {
+				if (level === 1 && property === 'scripts') {
+					inScripts = true;
+				} else if (inScripts && level === 2) {
+					scripts.add(property);
+				}
+			},
+		};
+
+		visit(content, visitor);
+
+		return scripts.size > 0 ? scripts : undefined;
+	}
+}
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool.ts
index 82864a5b18660..db685d506c8ac 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool.ts
@@ -42,6 +42,7 @@ import { TreeSitterCommandParser, TreeSitterCommandParserLanguage } from '../tre
 import { type ICommandLineAnalyzer, type ICommandLineAnalyzerOptions } from './commandLineAnalyzer/commandLineAnalyzer.js';
 import { CommandLineAutoApproveAnalyzer } from './commandLineAnalyzer/commandLineAutoApproveAnalyzer.js';
 import { CommandLineFileWriteAnalyzer } from './commandLineAnalyzer/commandLineFileWriteAnalyzer.js';
+import { CommandLineNpmScriptAutoApproveAnalyzer } from './commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.js';
 import { OutputMonitor } from './monitoring/outputMonitor.js';
 import { IPollingResult, OutputMonitorState } from './monitoring/types.js';
 import { LocalChatSessionUri } from '../../../../chat/common/chatUri.js';
@@ -316,6 +317,7 @@ export class RunInTerminalTool extends Disposable implements IToolImpl {
 		this._commandLineAnalyzers = [
 			this._register(this._instantiationService.createInstance(CommandLineFileWriteAnalyzer, this._treeSitterCommandParser, (message, args) => this._logService.info(`RunInTerminalTool#CommandLineFileWriteAnalyzer: ${message}`, args))),
 			this._register(this._instantiationService.createInstance(CommandLineAutoApproveAnalyzer, this._treeSitterCommandParser, this._telemetry, (message, args) => this._logService.info(`RunInTerminalTool#CommandLineAutoApproveAnalyzer: ${message}`, args))),
+			this._register(this._instantiationService.createInstance(CommandLineNpmScriptAutoApproveAnalyzer, this._treeSitterCommandParser, (message, args) => this._logService.info(`RunInTerminalTool#CommandLineNpmScriptAutoApproveAnalyzer: ${message}`, args))),
 		];
 
 		// Clear out warning accepted state if the setting is disabled
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration.ts
index 68f4bc6390d79..2f3ce57c5397b 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration.ts
@@ -15,6 +15,7 @@ import { PolicyCategory } from '../../../../../base/common/policy.js';
 export const enum TerminalChatAgentToolsSettingId {
 	EnableAutoApprove = 'chat.tools.terminal.enableAutoApprove',
 	AutoApprove = 'chat.tools.terminal.autoApprove',
+	AutoApproveWorkspaceNpmScripts = 'chat.tools.terminal.autoApproveWorkspaceNpmScripts',
 	IgnoreDefaultAutoApproveRules = 'chat.tools.terminal.ignoreDefaultAutoApproveRules',
 	BlockDetectedFileWrites = 'chat.tools.terminal.blockDetectedFileWrites',
 	ShellIntegrationTimeout = 'chat.tools.terminal.shellIntegrationTimeout',
@@ -355,6 +356,13 @@ export const terminalChatAgentToolsConfiguration: IStringDictionary<IConfigurati
 		tags: ['experimental'],
 		markdownDescription: localize('ignoreDefaultAutoApproveRules.description', "Whether to ignore the built-in default auto-approve rules used by the run in terminal tool as defined in {0}. When this setting is enabled, the run in terminal tool will ignore any rule that comes from the default set but still follow rules defined in the user, remote and workspace settings. Use this setting at your own risk; the default auto-approve rules are designed to protect you against running dangerous commands.", `\`#${TerminalChatAgentToolsSettingId.AutoApprove}#\``),
 	},
+	[TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts]: {
+		restricted: true,
+		type: 'boolean',
+		default: true, // The workspace is trusted by default, so scripts it defines are also trusted
+		tags: ['experimental'],
+		markdownDescription: localize('autoApproveWorkspaceNpmScripts.description', "Whether to automatically approve npm, yarn, and pnpm run commands when the script is defined in a workspace package.json file. Since the workspace is trusted, scripts defined in package.json are considered safe to run without explicit approval."),
+	},
 	[TerminalChatAgentToolsSettingId.BlockDetectedFileWrites]: {
 		type: 'string',
 		enum: ['never', 'outsideWorkspace', 'all'],
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
new file mode 100644
index 0000000000000..045fffd5dea36
--- /dev/null
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
@@ -0,0 +1,329 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { strictEqual } from 'assert';
+import { VSBuffer } from '../../../../../../../base/common/buffer.js';
+import { Schemas } from '../../../../../../../base/common/network.js';
+import { isWindows, OperatingSystem } from '../../../../../../../base/common/platform.js';
+import { URI } from '../../../../../../../base/common/uri.js';
+import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../../../base/test/common/utils.js';
+import { ITreeSitterLibraryService } from '../../../../../../../editor/common/services/treeSitter/treeSitterLibraryService.js';
+import { TestConfigurationService } from '../../../../../../../platform/configuration/test/common/testConfigurationService.js';
+import { FileService } from '../../../../../../../platform/files/common/fileService.js';
+import { IFileService } from '../../../../../../../platform/files/common/files.js';
+import { InMemoryFileSystemProvider } from '../../../../../../../platform/files/common/inMemoryFilesystemProvider.js';
+import type { TestInstantiationService } from '../../../../../../../platform/instantiation/test/common/instantiationServiceMock.js';
+import { NullLogService } from '../../../../../../../platform/log/common/log.js';
+import { IStorageService, StorageScope } from '../../../../../../../platform/storage/common/storage.js';
+import { IWorkspaceContextService, toWorkspaceFolder } from '../../../../../../../platform/workspace/common/workspace.js';
+import { Workspace } from '../../../../../../../platform/workspace/test/common/testWorkspace.js';
+import { TerminalToolConfirmationStorageKeys } from '../../../../../chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
+import { TreeSitterLibraryService } from '../../../../../../services/treeSitter/browser/treeSitterLibraryService.js';
+import { workbenchInstantiationService } from '../../../../../../test/browser/workbenchTestServices.js';
+import { TestContextService, TestStorageService } from '../../../../../../test/common/workbenchTestServices.js';
+import type { ICommandLineAnalyzerOptions } from '../../../browser/tools/commandLineAnalyzer/commandLineAnalyzer.js';
+import { CommandLineNpmScriptAutoApproveAnalyzer } from '../../../browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.js';
+import { TreeSitterCommandParser, TreeSitterCommandParserLanguage } from '../../../browser/treeSitterCommandParser.js';
+import { TerminalChatAgentToolsSettingId } from '../../../common/terminalChatAgentToolsConfiguration.js';
+
+suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
+	const store = ensureNoDisposablesAreLeakedInTestSuite();
+
+	let instantiationService: TestInstantiationService;
+	let parser: TreeSitterCommandParser;
+	let analyzer: CommandLineNpmScriptAutoApproveAnalyzer;
+	let configurationService: TestConfigurationService;
+	let workspaceContextService: TestContextService;
+	let storageService: TestStorageService;
+	let fileService: FileService;
+	let fileSystemProvider: InMemoryFileSystemProvider;
+
+	const mockLog = (..._args: unknown[]) => { };
+
+	const cwd = URI.file('/workspace/project');
+
+	setup(() => {
+		fileService = store.add(new FileService(new NullLogService()));
+		fileSystemProvider = store.add(new InMemoryFileSystemProvider());
+		store.add(fileService.registerProvider(Schemas.file, fileSystemProvider));
+
+		configurationService = new TestConfigurationService();
+		workspaceContextService = new TestContextService();
+		storageService = new TestStorageService();
+
+		instantiationService = workbenchInstantiationService({
+			fileService: () => fileService,
+			configurationService: () => configurationService
+		}, store);
+
+		instantiationService.stub(IWorkspaceContextService, workspaceContextService);
+		instantiationService.stub(IStorageService, storageService);
+		instantiationService.stub(IFileService, fileService);
+
+		const treeSitterLibraryService = store.add(instantiationService.createInstance(TreeSitterLibraryService));
+		treeSitterLibraryService.isTest = true;
+		instantiationService.stub(ITreeSitterLibraryService, treeSitterLibraryService);
+
+		parser = store.add(instantiationService.createInstance(TreeSitterCommandParser));
+
+		analyzer = store.add(instantiationService.createInstance(
+			CommandLineNpmScriptAutoApproveAnalyzer,
+			parser,
+			mockLog
+		));
+
+		// Enable auto-approve by default for tests
+		configurationService.setUserConfiguration(TerminalChatAgentToolsSettingId.EnableAutoApprove, true);
+		configurationService.setUserConfiguration(TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts, true);
+		storageService.store(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, true, StorageScope.APPLICATION, 0);
+
+		// Setup workspace
+		const workspace = new Workspace('test', [toWorkspaceFolder(cwd)]);
+		workspaceContextService.setWorkspace(workspace);
+	});
+
+	async function writePackageJson(uri: URI, scripts: Record<string, string>) {
+		const packageJson = {
+			name: 'test-project',
+			version: '1.0.0',
+			scripts
+		};
+		await fileService.writeFile(uri, VSBuffer.fromString(JSON.stringify(packageJson, null, 2)));
+	}
+
+	async function t(commandLine: string, scripts: Record<string, string>, expectedAutoApproved: boolean | undefined) {
+		const packageJsonUri = URI.joinPath(cwd, 'package.json');
+		await writePackageJson(packageJsonUri, scripts);
+
+		const options: ICommandLineAnalyzerOptions = {
+			commandLine,
+			cwd,
+			shell: isWindows ? 'pwsh' : 'bash',
+			os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
+			treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+			terminalToolSessionId: 'test',
+			chatSessionId: 'test',
+		};
+
+		const result = await analyzer.analyze(options);
+		strictEqual(result.isAutoApproved, expectedAutoApproved, `Expected isAutoApproved to be ${expectedAutoApproved} for: ${commandLine}`);
+		strictEqual(result.isAutoApproveAllowed, true, 'isAutoApproveAllowed should always be true');
+	}
+
+	suite('npm run commands', () => {
+		test('npm run build - script exists', () => t('npm run build', { build: 'tsc' }, true));
+		test('npm run test - script exists', () => t('npm run test', { test: 'jest' }, true));
+		test('npm run dev - script exists', () => t('npm run dev', { dev: 'vite' }, true));
+		test('npm run start - script exists', () => t('npm run start', { start: 'node index.js' }, true));
+		test('npm run lint - script exists', () => t('npm run lint', { lint: 'eslint .' }, true));
+		test('npm run-script build - script exists', () => t('npm run-script build', { build: 'tsc' }, true));
+
+		test('npm run missing - script does not exist', () => t('npm run missing', { build: 'tsc' }, undefined));
+		test('npm run build - no scripts section', async () => {
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			await fileService.writeFile(packageJsonUri, VSBuffer.fromString(JSON.stringify({ name: 'test' })));
+
+			const options: ICommandLineAnalyzerOptions = {
+				commandLine: 'npm run build',
+				cwd,
+				shell: isWindows ? 'pwsh' : 'bash',
+				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
+				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				terminalToolSessionId: 'test',
+				chatSessionId: 'test',
+			};
+
+			const result = await analyzer.analyze(options);
+			strictEqual(result.isAutoApproved, undefined);
+		});
+	});
+
+	suite('yarn commands', () => {
+		test('yarn run build - script exists', () => t('yarn run build', { build: 'tsc' }, true));
+		test('yarn run test - script exists', () => t('yarn run test', { test: 'jest' }, true));
+
+		// Yarn shorthand (yarn <script>)
+		test('yarn build - script exists (shorthand)', () => t('yarn build', { build: 'tsc' }, true));
+		test('yarn test - script exists (shorthand)', () => t('yarn test', { test: 'jest' }, true));
+
+		// Yarn built-in commands should not match
+		test('yarn install - built-in command, not a script', () => t('yarn install', { install: 'echo should not match' }, undefined));
+		test('yarn add - built-in command, not a script', () => t('yarn add lodash', { add: 'echo should not match' }, undefined));
+
+		test('yarn run missing - script does not exist', () => t('yarn run missing', { build: 'tsc' }, undefined));
+	});
+
+	suite('pnpm commands', () => {
+		test('pnpm run build - script exists', () => t('pnpm run build', { build: 'tsc' }, true));
+		test('pnpm run test - script exists', () => t('pnpm run test', { test: 'jest' }, true));
+
+		// pnpm shorthand (pnpm <script>)
+		test('pnpm build - script exists (shorthand)', () => t('pnpm build', { build: 'tsc' }, true));
+		test('pnpm test - script exists (shorthand)', () => t('pnpm test', { test: 'jest' }, true));
+
+		// pnpm built-in commands should not match
+		test('pnpm install - built-in command, not a script', () => t('pnpm install', { install: 'echo should not match' }, undefined));
+		test('pnpm add - built-in command, not a script', () => t('pnpm add lodash', { add: 'echo should not match' }, undefined));
+
+		test('pnpm run missing - script does not exist', () => t('pnpm run missing', { build: 'tsc' }, undefined));
+	});
+
+	suite('chained commands', () => {
+		test('npm install && npm run build - both scripts exist', () => t('npm install && npm run build', { build: 'tsc' }, true));
+		test('npm run lint && npm run test - both scripts exist', () => t('npm run lint && npm run test', { lint: 'eslint .', test: 'jest' }, true));
+		test('npm run build && npm run missing - one script missing', () => t('npm run build && npm run missing', { build: 'tsc' }, undefined));
+	});
+
+	suite('no package.json', () => {
+		test('npm run build - no package.json file', async () => {
+			const options: ICommandLineAnalyzerOptions = {
+				commandLine: 'npm run build',
+				cwd: URI.file('/nonexistent/path'),
+				shell: isWindows ? 'pwsh' : 'bash',
+				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
+				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				terminalToolSessionId: 'test',
+				chatSessionId: 'test',
+			};
+
+			const result = await analyzer.analyze(options);
+			strictEqual(result.isAutoApproved, undefined);
+			strictEqual(result.isAutoApproveAllowed, true);
+		});
+	});
+
+	suite('non-npm commands', () => {
+		test('git status - not an npm command', () => t('git status', { build: 'tsc' }, undefined));
+		test('ls -la - not an npm command', () => t('ls -la', { build: 'tsc' }, undefined));
+		test('echo hello - not an npm command', () => t('echo hello', { build: 'tsc' }, undefined));
+	});
+
+	suite('auto-approve disabled', () => {
+		test('npm run build - npm script auto-approve setting disabled', async () => {
+			configurationService.setUserConfiguration(TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts, false);
+
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			await writePackageJson(packageJsonUri, { build: 'tsc' });
+
+			const options: ICommandLineAnalyzerOptions = {
+				commandLine: 'npm run build',
+				cwd,
+				shell: isWindows ? 'pwsh' : 'bash',
+				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
+				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				terminalToolSessionId: 'test',
+				chatSessionId: 'test',
+			};
+
+			const result = await analyzer.analyze(options);
+			strictEqual(result.isAutoApproved, undefined);
+			strictEqual(result.isAutoApproveAllowed, true);
+		});
+
+		test('npm run build - auto-approve setting disabled', async () => {
+			configurationService.setUserConfiguration(TerminalChatAgentToolsSettingId.EnableAutoApprove, false);
+
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			await writePackageJson(packageJsonUri, { build: 'tsc' });
+
+			const options: ICommandLineAnalyzerOptions = {
+				commandLine: 'npm run build',
+				cwd,
+				shell: isWindows ? 'pwsh' : 'bash',
+				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
+				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				terminalToolSessionId: 'test',
+				chatSessionId: 'test',
+			};
+
+			const result = await analyzer.analyze(options);
+			strictEqual(result.isAutoApproved, undefined);
+			strictEqual(result.isAutoApproveAllowed, true);
+		});
+
+		test('npm run build - warning not accepted', async () => {
+			storageService.store(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, false, StorageScope.APPLICATION, 0);
+
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			await writePackageJson(packageJsonUri, { build: 'tsc' });
+
+			const options: ICommandLineAnalyzerOptions = {
+				commandLine: 'npm run build',
+				cwd,
+				shell: isWindows ? 'pwsh' : 'bash',
+				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
+				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				terminalToolSessionId: 'test',
+				chatSessionId: 'test',
+			};
+
+			const result = await analyzer.analyze(options);
+			strictEqual(result.isAutoApproved, undefined);
+			strictEqual(result.isAutoApproveAllowed, true);
+		});
+	});
+
+	suite('autoApproveInfo message', () => {
+		test('single script - message contains script name', async () => {
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			await writePackageJson(packageJsonUri, { build: 'tsc' });
+
+			const options: ICommandLineAnalyzerOptions = {
+				commandLine: 'npm run build',
+				cwd,
+				shell: isWindows ? 'pwsh' : 'bash',
+				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
+				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				terminalToolSessionId: 'test',
+				chatSessionId: 'test',
+			};
+
+			const result = await analyzer.analyze(options);
+			strictEqual(result.isAutoApproved, true);
+			strictEqual(result.autoApproveInfo?.value.includes('build'), true, 'Should mention script name');
+			strictEqual(result.autoApproveInfo?.value.includes('package.json'), true, 'Should mention package.json');
+		});
+
+		test('multiple scripts - message contains all script names', async () => {
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			await writePackageJson(packageJsonUri, { lint: 'eslint .', test: 'jest' });
+
+			const options: ICommandLineAnalyzerOptions = {
+				commandLine: 'npm run lint && npm run test',
+				cwd,
+				shell: isWindows ? 'pwsh' : 'bash',
+				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
+				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				terminalToolSessionId: 'test',
+				chatSessionId: 'test',
+			};
+
+			const result = await analyzer.analyze(options);
+			strictEqual(result.isAutoApproved, true);
+			strictEqual(result.autoApproveInfo?.value.includes('lint'), true, 'Should mention lint script');
+			strictEqual(result.autoApproveInfo?.value.includes('test'), true, 'Should mention test script');
+		});
+	});
+
+	suite('workspace folder fallback', () => {
+		test('no cwd - falls back to workspace folder root', async () => {
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			await writePackageJson(packageJsonUri, { build: 'tsc' });
+
+			const options: ICommandLineAnalyzerOptions = {
+				commandLine: 'npm run build',
+				cwd: undefined, // No cwd
+				shell: isWindows ? 'pwsh' : 'bash',
+				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
+				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				terminalToolSessionId: 'test',
+				chatSessionId: 'test',
+			};
+
+			const result = await analyzer.analyze(options);
+			strictEqual(result.isAutoApproved, true);
+		});
+	});
+});

From 6b9ac5174602b189d5d1df29e9cf90b2a15db429 Mon Sep 17 00:00:00 2001
From: Daniel Imms <2193314+Tyriar@users.noreply.github.com>
Date: Wed, 31 Dec 2025 08:28:42 -0800
Subject: [PATCH 02/10] Fix tests

---
 ...commandLineNpmScriptAutoApproveAnalyzer.ts |  8 +-
 ...ndLineNpmScriptAutoApproveAnalyzer.test.ts | 76 +++++++++++--------
 2 files changed, 49 insertions(+), 35 deletions(-)

diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
index 6b913ce3716a0..12ee8af9b2a08 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
@@ -36,6 +36,8 @@ const npmRunPatterns = [
 
 /**
  * Yarn built-in commands that should not be treated as script names.
+ * Note: 'test' is omitted since it's commonly a user script, and 'yarn test'
+ * is often used to run the 'test' script from package.json.
  */
 const yarnBuiltinCommands = new Set([
 	'add', 'audit', 'autoclean', 'bin', 'cache', 'check', 'config',
@@ -44,19 +46,21 @@ const yarnBuiltinCommands = new Set([
 	'link', 'list', 'login', 'logout', 'node', 'outdated', 'owner',
 	'pack', 'patch', 'patch-commit', 'plugin', 'policies', 'publish',
 	'rebuild', 'remove', 'run', 'search', 'set', 'stage', 'tag', 'team',
-	'test', 'unlink', 'unplug', 'up', 'upgrade', 'upgrade-interactive',
+	'unlink', 'unplug', 'up', 'upgrade', 'upgrade-interactive',
 	'version', 'versions', 'why', 'workspace', 'workspaces',
 ]);
 
 /**
  * pnpm built-in commands that should not be treated as script names.
+ * Note: 'test' is omitted since it's commonly a user script, and 'pnpm test'
+ * is often used to run the 'test' script from package.json.
  */
 const pnpmBuiltinCommands = new Set([
 	'add', 'audit', 'bin', 'config', 'dedupe', 'deploy', 'dlx', 'doctor',
 	'env', 'exec', 'fetch', 'import', 'init', 'install', 'install-test',
 	'licenses', 'link', 'list', 'ln', 'ls', 'outdated', 'pack', 'patch',
 	'patch-commit', 'patch-remove', 'prune', 'publish', 'rb', 'rebuild',
-	'remove', 'rm', 'root', 'run', 'server', 'setup', 'store', 'test',
+	'remove', 'rm', 'root', 'run', 'server', 'setup', 'store',
 	'un', 'uninstall', 'unlink', 'up', 'update', 'why',
 ]);
 
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
index 045fffd5dea36..70edec9efdc78 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
@@ -6,7 +6,7 @@
 import { strictEqual } from 'assert';
 import { VSBuffer } from '../../../../../../../base/common/buffer.js';
 import { Schemas } from '../../../../../../../base/common/network.js';
-import { isWindows, OperatingSystem } from '../../../../../../../base/common/platform.js';
+import { OperatingSystem } from '../../../../../../../base/common/platform.js';
 import { URI } from '../../../../../../../base/common/uri.js';
 import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../../../base/test/common/utils.js';
 import { ITreeSitterLibraryService } from '../../../../../../../editor/common/services/treeSitter/treeSitterLibraryService.js';
@@ -22,6 +22,7 @@ import { Workspace } from '../../../../../../../platform/workspace/test/common/t
 import { TerminalToolConfirmationStorageKeys } from '../../../../../chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
 import { TreeSitterLibraryService } from '../../../../../../services/treeSitter/browser/treeSitterLibraryService.js';
 import { workbenchInstantiationService } from '../../../../../../test/browser/workbenchTestServices.js';
+import { TestIPCFileSystemProvider } from '../../../../../../test/electron-browser/workbenchTestServices.js';
 import { TestContextService, TestStorageService } from '../../../../../../test/common/workbenchTestServices.js';
 import type { ICommandLineAnalyzerOptions } from '../../../browser/tools/commandLineAnalyzer/commandLineAnalyzer.js';
 import { CommandLineNpmScriptAutoApproveAnalyzer } from '../../../browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.js';
@@ -42,16 +43,25 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 
 	const mockLog = (..._args: unknown[]) => { };
 
-	const cwd = URI.file('/workspace/project');
+	// Use inMemory scheme to avoid platform-specific path issues
+	const cwd = URI.from({ scheme: Schemas.inMemory, path: '/workspace/project' });
 
-	setup(() => {
+	setup(async () => {
 		fileService = store.add(new FileService(new NullLogService()));
+
+		// Register file: scheme provider for tree-sitter WASM grammar loading
+		store.add(fileService.registerProvider(Schemas.file, new TestIPCFileSystemProvider()));
+
+		// Register inMemory: scheme provider for test package.json files
 		fileSystemProvider = store.add(new InMemoryFileSystemProvider());
-		store.add(fileService.registerProvider(Schemas.file, fileSystemProvider));
+		store.add(fileService.registerProvider(Schemas.inMemory, fileSystemProvider));
+
+		// Create workspace directory structure
+		await fileService.createFolder(cwd);
 
 		configurationService = new TestConfigurationService();
 		workspaceContextService = new TestContextService();
-		storageService = new TestStorageService();
+		storageService = store.add(new TestStorageService());
 
 		instantiationService = workbenchInstantiationService({
 			fileService: () => fileService,
@@ -100,9 +110,9 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 		const options: ICommandLineAnalyzerOptions = {
 			commandLine,
 			cwd,
-			shell: isWindows ? 'pwsh' : 'bash',
-			os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
-			treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+			shell: 'bash',
+			os: OperatingSystem.Linux,
+			treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
 			terminalToolSessionId: 'test',
 			chatSessionId: 'test',
 		};
@@ -128,9 +138,9 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 			const options: ICommandLineAnalyzerOptions = {
 				commandLine: 'npm run build',
 				cwd,
-				shell: isWindows ? 'pwsh' : 'bash',
-				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
-				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				shell: 'bash',
+				os: OperatingSystem.Linux,
+				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
 				terminalToolSessionId: 'test',
 				chatSessionId: 'test',
 			};
@@ -180,10 +190,10 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 		test('npm run build - no package.json file', async () => {
 			const options: ICommandLineAnalyzerOptions = {
 				commandLine: 'npm run build',
-				cwd: URI.file('/nonexistent/path'),
-				shell: isWindows ? 'pwsh' : 'bash',
-				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
-				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				cwd: URI.from({ scheme: Schemas.inMemory, path: '/nonexistent/path' }),
+				shell: 'bash',
+				os: OperatingSystem.Linux,
+				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
 				terminalToolSessionId: 'test',
 				chatSessionId: 'test',
 			};
@@ -210,9 +220,9 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 			const options: ICommandLineAnalyzerOptions = {
 				commandLine: 'npm run build',
 				cwd,
-				shell: isWindows ? 'pwsh' : 'bash',
-				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
-				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				shell: 'bash',
+				os: OperatingSystem.Linux,
+				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
 				terminalToolSessionId: 'test',
 				chatSessionId: 'test',
 			};
@@ -231,9 +241,9 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 			const options: ICommandLineAnalyzerOptions = {
 				commandLine: 'npm run build',
 				cwd,
-				shell: isWindows ? 'pwsh' : 'bash',
-				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
-				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				shell: 'bash',
+				os: OperatingSystem.Linux,
+				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
 				terminalToolSessionId: 'test',
 				chatSessionId: 'test',
 			};
@@ -252,9 +262,9 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 			const options: ICommandLineAnalyzerOptions = {
 				commandLine: 'npm run build',
 				cwd,
-				shell: isWindows ? 'pwsh' : 'bash',
-				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
-				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				shell: 'bash',
+				os: OperatingSystem.Linux,
+				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
 				terminalToolSessionId: 'test',
 				chatSessionId: 'test',
 			};
@@ -273,9 +283,9 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 			const options: ICommandLineAnalyzerOptions = {
 				commandLine: 'npm run build',
 				cwd,
-				shell: isWindows ? 'pwsh' : 'bash',
-				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
-				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				shell: 'bash',
+				os: OperatingSystem.Linux,
+				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
 				terminalToolSessionId: 'test',
 				chatSessionId: 'test',
 			};
@@ -293,9 +303,9 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 			const options: ICommandLineAnalyzerOptions = {
 				commandLine: 'npm run lint && npm run test',
 				cwd,
-				shell: isWindows ? 'pwsh' : 'bash',
-				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
-				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				shell: 'bash',
+				os: OperatingSystem.Linux,
+				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
 				terminalToolSessionId: 'test',
 				chatSessionId: 'test',
 			};
@@ -315,9 +325,9 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 			const options: ICommandLineAnalyzerOptions = {
 				commandLine: 'npm run build',
 				cwd: undefined, // No cwd
-				shell: isWindows ? 'pwsh' : 'bash',
-				os: isWindows ? OperatingSystem.Windows : OperatingSystem.Linux,
-				treeSitterLanguage: isWindows ? TreeSitterCommandParserLanguage.PowerShell : TreeSitterCommandParserLanguage.Bash,
+				shell: 'bash',
+				os: OperatingSystem.Linux,
+				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
 				terminalToolSessionId: 'test',
 				chatSessionId: 'test',
 			};

From 3870c64fdbfec8aa52327fb427fbe6a4ff144b79 Mon Sep 17 00:00:00 2001
From: Daniel Imms <2193314+Tyriar@users.noreply.github.com>
Date: Wed, 31 Dec 2025 08:33:30 -0800
Subject: [PATCH 03/10] Ensure colon is handled

---
 ...commandLineNpmScriptAutoApproveAnalyzer.ts | 33 ++++++++-----------
 ...ndLineNpmScriptAutoApproveAnalyzer.test.ts |  5 +++
 2 files changed, 19 insertions(+), 19 deletions(-)

diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
index 12ee8af9b2a08..686ca4fc3815d 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
@@ -19,19 +19,18 @@ import { TerminalToolConfirmationStorageKeys } from '../../../../../chat/browser
 
 /**
  * Regex patterns to match npm/yarn/pnpm run commands and extract the script name.
- * Captures the script name in group 1.
+ * Uses named capture groups: 'command' for the package manager, 'scriptName' for the script.
  */
 const npmRunPatterns = [
-	// npm run <script>, npm run-script <script>
-	/^npm\s+(?:run(?:-script)?)\s+([^\s&|;]+)/i,
+	// npm run <script>
+	// npm run-script <script>
+	/^(?<command>npm)\s+(?:run(?:-script)?)\s+(?<scriptName>[^\s&|;]+)/i,
+	// yarn <script>
 	// yarn run <script>
-	/^yarn\s+run\s+([^\s&|;]+)/i,
-	// yarn <script> (shorthand, but exclude yarn built-in commands)
-	/^yarn\s+([^\s&|;]+)/i,
+	/^(?<command>yarn)\s+(?:run\s+)?(?<scriptName>[^\s&|;]+)/i,
+	// pnpm <script>
 	// pnpm run <script>
-	/^pnpm\s+run\s+([^\s&|;]+)/i,
-	// pnpm <script> (shorthand)
-	/^pnpm\s+([^\s&|;]+)/i,
+	/^(?<command>pnpm)\s+(?:run\s+)?(?<scriptName>[^\s&|;]+)/i,
 ];
 
 /**
@@ -162,19 +161,15 @@ export class CommandLineNpmScriptAutoApproveAnalyzer extends Disposable implemen
 
 			for (const pattern of npmRunPatterns) {
 				const match = trimmedCommand.match(pattern);
-				if (match && match[1]) {
-					const scriptName = match[1];
+				if (match?.groups?.scriptName) {
+					const { command, scriptName } = match.groups;
 
 					// Check if this is a yarn/pnpm shorthand that matches a built-in command
-					if (pattern.source.includes('yarn\\s+([^')) {
-						if (yarnBuiltinCommands.has(scriptName.toLowerCase())) {
-							continue;
-						}
+					if (command.toLowerCase() === 'yarn' && yarnBuiltinCommands.has(scriptName.toLowerCase())) {
+						continue;
 					}
-					if (pattern.source.includes('pnpm\\s+([^')) {
-						if (pnpmBuiltinCommands.has(scriptName.toLowerCase())) {
-							continue;
-						}
+					if (command.toLowerCase() === 'pnpm' && pnpmBuiltinCommands.has(scriptName.toLowerCase())) {
+						continue;
 					}
 
 					scriptNames.push(scriptName);
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
index 70edec9efdc78..5f0b1a435574b 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
@@ -130,6 +130,11 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 		test('npm run lint - script exists', () => t('npm run lint', { lint: 'eslint .' }, true));
 		test('npm run-script build - script exists', () => t('npm run-script build', { build: 'tsc' }, true));
 
+		// Scripts with colons (namespaced scripts)
+		test('npm run build:prod - script with colon exists', () => t('npm run build:prod', { 'build:prod': 'tsc --build' }, true));
+		test('npm run test:unit - script with colon exists', () => t('npm run test:unit', { 'test:unit': 'jest --testPathPattern=unit' }, true));
+		test('npm run lint:fix - script with colon exists', () => t('npm run lint:fix', { 'lint:fix': 'eslint . --fix' }, true));
+
 		test('npm run missing - script does not exist', () => t('npm run missing', { build: 'tsc' }, undefined));
 		test('npm run build - no scripts section', async () => {
 			const packageJsonUri = URI.joinPath(cwd, 'package.json');

From 8971b20cee1b501c839b4acc25222439cd934560 Mon Sep 17 00:00:00 2001
From: Daniel Imms <2193314+Tyriar@users.noreply.github.com>
Date: Wed, 31 Dec 2025 08:34:54 -0800
Subject: [PATCH 04/10] Clarify default comment

---
 .../common/terminalChatAgentToolsConfiguration.ts             | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration.ts
index 2f3ce57c5397b..fbff39fd80a42 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/common/terminalChatAgentToolsConfiguration.ts
@@ -359,7 +359,9 @@ export const terminalChatAgentToolsConfiguration: IStringDictionary<IConfigurati
 	[TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts]: {
 		restricted: true,
 		type: 'boolean',
-		default: true, // The workspace is trusted by default, so scripts it defines are also trusted
+		// In order to use agent mode the workspace must be trusted, this plus the fact that
+		// modifying package.json is protected means this is safe to enable by default.
+		default: true,
 		tags: ['experimental'],
 		markdownDescription: localize('autoApproveWorkspaceNpmScripts.description', "Whether to automatically approve npm, yarn, and pnpm run commands when the script is defined in a workspace package.json file. Since the workspace is trusted, scripts defined in package.json are considered safe to run without explicit approval."),
 	},

From 32db1c7f73d00333676fd5f629b78081ca7b9102 Mon Sep 17 00:00:00 2001
From: Daniel Imms <2193314+Tyriar@users.noreply.github.com>
Date: Thu, 1 Jan 2026 03:17:41 -0800
Subject: [PATCH 05/10] Only allow npm package.json approval within workspace

---
 ...commandLineNpmScriptAutoApproveAnalyzer.ts | 14 +++++++++++--
 ...ndLineNpmScriptAutoApproveAnalyzer.test.ts | 21 +++++++++++++++++++
 2 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
index 686ca4fc3815d..a76107c4bc041 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
@@ -5,6 +5,7 @@
 
 import { visit, type JSONVisitor } from '../../../../../../../base/common/json.js';
 import { Disposable } from '../../../../../../../base/common/lifecycle.js';
+import { extUri } from '../../../../../../../base/common/resources.js';
 import { URI } from '../../../../../../../base/common/uri.js';
 import { IConfigurationService } from '../../../../../../../platform/configuration/common/configuration.js';
 import { IFileService } from '../../../../../../../platform/files/common/files.js';
@@ -181,12 +182,21 @@ export class CommandLineNpmScriptAutoApproveAnalyzer extends Disposable implemen
 		return scriptNames;
 	}
 
+	/**
+	 * Checks if a URI is within any workspace folder.
+	 */
+	private _isWithinWorkspace(uri: URI): boolean {
+		const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
+		return workspaceFolders.some(folder => extUri.isEqualOrParent(uri, folder.uri));
+	}
+
 	/**
 	 * Finds and parses package.json to get the scripts section.
+	 * Only looks within the workspace for security.
 	 */
 	private async _getPackageJsonScripts(cwd: URI | undefined): Promise<IPackageJsonScripts | undefined> {
-		// Try cwd first
-		if (cwd) {
+		// Try cwd first, but only if it's within the workspace
+		if (cwd && this._isWithinWorkspace(cwd)) {
 			const packageJsonUri = URI.joinPath(cwd, 'package.json');
 			const scripts = await this._readPackageJsonScripts(packageJsonUri);
 			if (scripts) {
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
index 5f0b1a435574b..5c3e73e85df83 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
@@ -340,5 +340,26 @@ suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
 			const result = await analyzer.analyze(options);
 			strictEqual(result.isAutoApproved, true);
 		});
+
+		test('cwd outside workspace - does not auto-approve', async () => {
+			// Create package.json outside workspace
+			const outsideCwd = URI.from({ scheme: Schemas.inMemory, path: '/outside/project' });
+			await fileService.createFolder(outsideCwd);
+			const outsidePackageJsonUri = URI.joinPath(outsideCwd, 'package.json');
+			await writePackageJson(outsidePackageJsonUri, { build: 'tsc' });
+
+			const options: ICommandLineAnalyzerOptions = {
+				commandLine: 'npm run build',
+				cwd: outsideCwd, // cwd is outside workspace
+				shell: 'bash',
+				os: OperatingSystem.Linux,
+				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
+				terminalToolSessionId: 'test',
+				chatSessionId: 'test',
+			};
+
+			const result = await analyzer.analyze(options);
+			strictEqual(result.isAutoApproved !== true, true, 'Should not auto-approve when cwd is outside workspace');
+		});
 	});
 });

From f6e1d2047ef9c40735342b071143ba4bca41945c Mon Sep 17 00:00:00 2001
From: Daniel Imms <2193314+Tyriar@users.noreply.github.com>
Date: Thu, 1 Jan 2026 03:19:36 -0800
Subject: [PATCH 06/10] Don't support package.json when cwd isn't available

---
 ...commandLineNpmScriptAutoApproveAnalyzer.ts | 22 ++++++-------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
index a76107c4bc041..c27dc45d0ba65 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
@@ -195,23 +195,15 @@ export class CommandLineNpmScriptAutoApproveAnalyzer extends Disposable implemen
 	 * Only looks within the workspace for security.
 	 */
 	private async _getPackageJsonScripts(cwd: URI | undefined): Promise<IPackageJsonScripts | undefined> {
-		// Try cwd first, but only if it's within the workspace
-		if (cwd && this._isWithinWorkspace(cwd)) {
-			const packageJsonUri = URI.joinPath(cwd, 'package.json');
-			const scripts = await this._readPackageJsonScripts(packageJsonUri);
-			if (scripts) {
-				return { uri: packageJsonUri, scripts };
-			}
+		// Only look in cwd if it's within the workspace
+		if (!cwd || !this._isWithinWorkspace(cwd)) {
+			return undefined;
 		}
 
-		// Fall back to workspace folder roots
-		const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
-		for (const folder of workspaceFolders) {
-			const packageJsonUri = URI.joinPath(folder.uri, 'package.json');
-			const scripts = await this._readPackageJsonScripts(packageJsonUri);
-			if (scripts) {
-				return { uri: packageJsonUri, scripts };
-			}
+		const packageJsonUri = URI.joinPath(cwd, 'package.json');
+		const scripts = await this._readPackageJsonScripts(packageJsonUri);
+		if (scripts) {
+			return { uri: packageJsonUri, scripts };
 		}
 
 		return undefined;

From f555cebf3f72a5fb8618936b381655fc1a0dfd53 Mon Sep 17 00:00:00 2001
From: Daniel Imms <2193314+Tyriar@users.noreply.github.com>
Date: Thu, 1 Jan 2026 04:33:49 -0800
Subject: [PATCH 07/10] Move files around, have npm script auto approve apply
 per sub-command

---
 .../browser/runInTerminalHelpers.ts           |   2 +-
 .../browser/runInTerminalToolTelemetry.ts     |   2 +-
 .../autoApprove}/commandLineAutoApprover.ts   |  35 +-
 .../npmScriptAutoApprover.ts}                 | 144 ++---
 .../commandLineAutoApproveAnalyzer.ts         |  34 +-
 .../browser/tools/runInTerminalTool.ts        |   2 -
 .../browser/commandLineAutoApprover.test.ts   | 582 +++++++++---------
 .../test/browser/runInTerminalHelpers.test.ts |   2 +-
 ...ndLineNpmScriptAutoApproveAnalyzer.test.ts | 365 -----------
 .../npmScriptAutoApprover.test.ts             | 192 ++++++
 10 files changed, 587 insertions(+), 773 deletions(-)
 rename src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/{ => tools/commandLineAnalyzer/autoApprove}/commandLineAutoApprover.ts (86%)
 rename src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/{commandLineNpmScriptAutoApproveAnalyzer.ts => autoApprove/npmScriptAutoApprover.ts} (50%)
 delete mode 100644 src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
 create mode 100644 src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/npmScriptAutoApprover.test.ts

diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers.ts
index d36d891f74cb8..7cc372df76019 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers.ts
@@ -11,7 +11,7 @@ import { escapeRegExpCharacters, removeAnsiEscapeCodes } from '../../../../../ba
 import { localize } from '../../../../../nls.js';
 import type { TerminalNewAutoApproveButtonData } from '../../../chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
 import type { ToolConfirmationAction } from '../../../chat/common/languageModelToolsService.js';
-import type { ICommandApprovalResultWithReason } from './commandLineAutoApprover.js';
+import type { ICommandApprovalResultWithReason } from './tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.js';
 
 export function isPowerShell(envShell: string, os: OperatingSystem): boolean {
 	if (os === OperatingSystem.Windows) {
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalToolTelemetry.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalToolTelemetry.ts
index 047c59fab3975..81afe7193b747 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalToolTelemetry.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalToolTelemetry.ts
@@ -19,7 +19,7 @@ export class RunInTerminalToolTelemetry {
 		subCommands: string[];
 		autoApproveAllowed: 'allowed' | 'needsOptIn' | 'off';
 		autoApproveResult: 'approved' | 'denied' | 'manual';
-		autoApproveReason: 'subCommand' | 'commandLine' | undefined;
+		autoApproveReason: 'subCommand' | 'commandLine' | 'npmScript' | undefined;
 		autoApproveDefault: boolean | undefined;
 	}) {
 		const subCommandsSanitized = state.subCommands.map(e => {
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/commandLineAutoApprover.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
similarity index 86%
rename from src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/commandLineAutoApprover.ts
rename to src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
index fd0be4041a11f..d8a8bba3740d5 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/commandLineAutoApprover.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
@@ -3,14 +3,17 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Disposable } from '../../../../../base/common/lifecycle.js';
-import type { OperatingSystem } from '../../../../../base/common/platform.js';
-import { escapeRegExpCharacters, regExpLeadsToEndlessLoop } from '../../../../../base/common/strings.js';
-import { isObject } from '../../../../../base/common/types.js';
-import { structuralEquals } from '../../../../../base/common/equals.js';
-import { ConfigurationTarget, IConfigurationService, type IConfigurationValue } from '../../../../../platform/configuration/common/configuration.js';
-import { TerminalChatAgentToolsSettingId } from '../common/terminalChatAgentToolsConfiguration.js';
-import { isPowerShell } from './runInTerminalHelpers.js';
+import { structuralEquals } from '../../../../../../../../base/common/equals.js';
+import { Disposable } from '../../../../../../../../base/common/lifecycle.js';
+import type { OperatingSystem } from '../../../../../../../../base/common/platform.js';
+import { escapeRegExpCharacters, regExpLeadsToEndlessLoop } from '../../../../../../../../base/common/strings.js';
+import { isObject } from '../../../../../../../../base/common/types.js';
+import type { URI } from '../../../../../../../../base/common/uri.js';
+import { ConfigurationTarget, IConfigurationService, type IConfigurationValue } from '../../../../../../../../platform/configuration/common/configuration.js';
+import { IInstantiationService } from '../../../../../../../../platform/instantiation/common/instantiation.js';
+import { TerminalChatAgentToolsSettingId } from '../../../../common/terminalChatAgentToolsConfiguration.js';
+import { isPowerShell } from '../../../runInTerminalHelpers.js';
+import { INpmScriptAutoApproveResult, NpmScriptAutoApprover } from './npmScriptAutoApprover.js';
 
 export interface IAutoApproveRule {
 	regex: RegExp;
@@ -24,6 +27,7 @@ export interface ICommandApprovalResultWithReason {
 	result: ICommandApprovalResult;
 	reason: string;
 	rule?: IAutoApproveRule;
+	npmScriptResult?: INpmScriptAutoApproveResult;
 }
 
 export type ICommandApprovalResult = 'approved' | 'denied' | 'noMatch';
@@ -36,11 +40,14 @@ export class CommandLineAutoApprover extends Disposable {
 	private _allowListRules: IAutoApproveRule[] = [];
 	private _allowListCommandLineRules: IAutoApproveRule[] = [];
 	private _denyListCommandLineRules: IAutoApproveRule[] = [];
+	private readonly _npmScriptAutoApprover: NpmScriptAutoApprover;
 
 	constructor(
 		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@IInstantiationService instantiationService: IInstantiationService,
 	) {
 		super();
+		this._npmScriptAutoApprover = this._register(instantiationService.createInstance(NpmScriptAutoApprover));
 		this.updateConfiguration();
 		this._register(this._configurationService.onDidChangeConfiguration(e => {
 			if (
@@ -76,7 +83,7 @@ export class CommandLineAutoApprover extends Disposable {
 		this._denyListCommandLineRules = denyListCommandLineRules;
 	}
 
-	isCommandAutoApproved(command: string, shell: string, os: OperatingSystem): ICommandApprovalResultWithReason {
+	async isCommandAutoApproved(command: string, shell: string, os: OperatingSystem, cwd: URI | undefined): Promise<ICommandApprovalResultWithReason> {
 		// Check if the command has a transient environment variable assignment prefix which we
 		// always deny for now as it can easily lead to execute other commands
 		if (transientEnvVarRegex.test(command)) {
@@ -108,6 +115,16 @@ export class CommandLineAutoApprover extends Disposable {
 			}
 		}
 
+		// Check if this is an npm/yarn/pnpm script defined in package.json
+		const npmScriptResult = await this._npmScriptAutoApprover.isCommandAutoApproved(command, cwd);
+		if (npmScriptResult.isAutoApproved) {
+			return {
+				result: 'approved',
+				npmScriptResult,
+				reason: `Command '${command}' is approved as npm script '${npmScriptResult.scriptName}' is defined in package.json`
+			};
+		}
+
 		// TODO: LLM-based auto-approval https://github.com/microsoft/vscode/issues/253267
 
 		// Fallback is always to require approval
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts
similarity index 50%
rename from src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
rename to src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts
index c27dc45d0ba65..ce89f551a01eb 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts
@@ -3,20 +3,16 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { visit, type JSONVisitor } from '../../../../../../../base/common/json.js';
-import { Disposable } from '../../../../../../../base/common/lifecycle.js';
-import { extUri } from '../../../../../../../base/common/resources.js';
-import { URI } from '../../../../../../../base/common/uri.js';
-import { IConfigurationService } from '../../../../../../../platform/configuration/common/configuration.js';
-import { IFileService } from '../../../../../../../platform/files/common/files.js';
-import { IWorkspaceContextService } from '../../../../../../../platform/workspace/common/workspace.js';
-import { TerminalChatAgentToolsSettingId } from '../../../common/terminalChatAgentToolsConfiguration.js';
-import type { TreeSitterCommandParser } from '../../treeSitterCommandParser.js';
-import type { ICommandLineAnalyzer, ICommandLineAnalyzerOptions, ICommandLineAnalyzerResult } from './commandLineAnalyzer.js';
-import { MarkdownString } from '../../../../../../../base/common/htmlContent.js';
-import { localize } from '../../../../../../../nls.js';
-import { IStorageService, StorageScope } from '../../../../../../../platform/storage/common/storage.js';
-import { TerminalToolConfirmationStorageKeys } from '../../../../../chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
+import { MarkdownString, type IMarkdownString } from '../../../../../../../../base/common/htmlContent.js';
+import { visit, type JSONVisitor } from '../../../../../../../../base/common/json.js';
+import { Disposable } from '../../../../../../../../base/common/lifecycle.js';
+import { extUri } from '../../../../../../../../base/common/resources.js';
+import { URI } from '../../../../../../../../base/common/uri.js';
+import { localize } from '../../../../../../../../nls.js';
+import { IConfigurationService } from '../../../../../../../../platform/configuration/common/configuration.js';
+import { IFileService } from '../../../../../../../../platform/files/common/files.js';
+import { IWorkspaceContextService, type IWorkspaceFolder } from '../../../../../../../../platform/workspace/common/workspace.js';
+import { TerminalChatAgentToolsSettingId } from '../../../../common/terminalChatAgentToolsConfiguration.js';
 
 /**
  * Regex patterns to match npm/yarn/pnpm run commands and extract the script name.
@@ -69,117 +65,84 @@ interface IPackageJsonScripts {
 	scripts: Set<string>;
 }
 
-export class CommandLineNpmScriptAutoApproveAnalyzer extends Disposable implements ICommandLineAnalyzer {
+export interface INpmScriptAutoApproveResult {
+	isAutoApproved: boolean;
+	scriptName?: string;
+	autoApproveInfo?: IMarkdownString;
+}
+
+export class NpmScriptAutoApprover extends Disposable {
 
 	constructor(
-		private readonly _treeSitterCommandParser: TreeSitterCommandParser,
-		private readonly _log: (message: string, ...args: unknown[]) => void,
 		@IConfigurationService private readonly _configurationService: IConfigurationService,
 		@IFileService private readonly _fileService: IFileService,
-		@IStorageService private readonly _storageService: IStorageService,
 		@IWorkspaceContextService private readonly _workspaceContextService: IWorkspaceContextService,
 	) {
 		super();
 	}
 
-	async analyze(options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult> {
+	/**
+	 * Checks if a single command is an npm/yarn/pnpm script that exists in package.json.
+	 * Returns auto-approve result if the command is a valid script.
+	 */
+	async isCommandAutoApproved(command: string, cwd: URI | undefined): Promise<INpmScriptAutoApproveResult> {
 		// Check if the feature is enabled
 		const isNpmScriptAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts) === true;
 		if (!isNpmScriptAutoApproveEnabled) {
-			return { isAutoApproveAllowed: true };
-		}
-
-		// Check if auto-approve is enabled
-		const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
-		const isAutoApproveWarningAccepted = this._storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
-		if (!isAutoApproveEnabled || !isAutoApproveWarningAccepted) {
-			return { isAutoApproveAllowed: true };
-		}
-
-		// Parse sub-commands
-		let subCommands: string[] | undefined;
-		try {
-			subCommands = await this._treeSitterCommandParser.extractSubCommands(options.treeSitterLanguage, options.commandLine);
-			this._log('Parsed sub-commands for npm script check', subCommands);
-		} catch (e) {
-			this._log('Failed to parse sub-commands for npm script check');
-			return { isAutoApproveAllowed: true };
-		}
-
-		if (!subCommands || subCommands.length === 0) {
-			return { isAutoApproveAllowed: true };
+			return { isAutoApproved: false };
 		}
 
-		// Extract script names from npm/yarn/pnpm run commands
-		const scriptNamesToCheck = this._extractScriptNames(subCommands);
-		if (scriptNamesToCheck.length === 0) {
-			return { isAutoApproveAllowed: true };
+		// Extract script name from the command
+		const scriptName = this._extractScriptName(command);
+		if (!scriptName) {
+			return { isAutoApproved: false };
 		}
 
-		this._log('Script names to check', scriptNamesToCheck);
-
 		// Find and parse package.json
-		const packageJsonScripts = await this._getPackageJsonScripts(options.cwd);
+		const packageJsonScripts = await this._getPackageJsonScripts(cwd);
 		if (!packageJsonScripts) {
-			this._log('No package.json found or no scripts section');
-			return { isAutoApproveAllowed: true };
+			return { isAutoApproved: false };
 		}
 
-		this._log('Found package.json scripts', Array.from(packageJsonScripts.scripts));
-
-		// Check if all script names exist in package.json
-		const allScriptsExist = scriptNamesToCheck.every(script => packageJsonScripts.scripts.has(script));
-		if (!allScriptsExist) {
-			const missingScripts = scriptNamesToCheck.filter(script => !packageJsonScripts.scripts.has(script));
-			this._log('Some scripts not found in package.json', missingScripts);
-			return { isAutoApproveAllowed: true };
+		// Check if script exists in package.json
+		if (!packageJsonScripts.scripts.has(scriptName)) {
+			return { isAutoApproved: false };
 		}
 
-		this._log('All scripts found in package.json, auto-approving');
-
-		// All scripts exist - auto approve
-		const scriptsList = scriptNamesToCheck.length === 1
-			? `\`${scriptNamesToCheck[0]}\``
-			: scriptNamesToCheck.map(s => `\`${s}\``).join(', ');
-
+		// Script exists - auto approve
 		return {
 			isAutoApproved: true,
-			isAutoApproveAllowed: true,
+			scriptName,
 			autoApproveInfo: new MarkdownString(
-				localize('autoApprove.npmScript', 'Auto approved as {0} is defined in package.json', scriptsList)
+				localize('autoApprove.npmScript', 'Auto approved as {0} is defined in package.json', `\`${scriptName}\``)
 			),
 		};
 	}
 
 	/**
-	 * Extracts script names from npm/yarn/pnpm run commands.
+	 * Extracts script name from an npm/yarn/pnpm run command.
 	 */
-	private _extractScriptNames(subCommands: string[]): string[] {
-		const scriptNames: string[] = [];
+	private _extractScriptName(command: string): string | undefined {
+		const trimmedCommand = command.trim();
 
-		for (const subCommand of subCommands) {
-			const trimmedCommand = subCommand.trim();
+		for (const pattern of npmRunPatterns) {
+			const match = trimmedCommand.match(pattern);
+			if (match?.groups?.scriptName) {
+				const { command: pkgManager, scriptName } = match.groups;
 
-			for (const pattern of npmRunPatterns) {
-				const match = trimmedCommand.match(pattern);
-				if (match?.groups?.scriptName) {
-					const { command, scriptName } = match.groups;
-
-					// Check if this is a yarn/pnpm shorthand that matches a built-in command
-					if (command.toLowerCase() === 'yarn' && yarnBuiltinCommands.has(scriptName.toLowerCase())) {
-						continue;
-					}
-					if (command.toLowerCase() === 'pnpm' && pnpmBuiltinCommands.has(scriptName.toLowerCase())) {
-						continue;
-					}
-
-					scriptNames.push(scriptName);
-					break; // Only match one pattern per sub-command
+				// Check if this is a yarn/pnpm shorthand that matches a built-in command
+				if (pkgManager.toLowerCase() === 'yarn' && yarnBuiltinCommands.has(scriptName.toLowerCase())) {
+					continue;
+				}
+				if (pkgManager.toLowerCase() === 'pnpm' && pnpmBuiltinCommands.has(scriptName.toLowerCase())) {
+					continue;
 				}
+
+				return scriptName;
 			}
 		}
 
-		return scriptNames;
+		return undefined;
 	}
 
 	/**
@@ -187,7 +150,7 @@ export class CommandLineNpmScriptAutoApproveAnalyzer extends Disposable implemen
 	 */
 	private _isWithinWorkspace(uri: URI): boolean {
 		const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
-		return workspaceFolders.some(folder => extUri.isEqualOrParent(uri, folder.uri));
+		return workspaceFolders.some((folder: IWorkspaceFolder) => extUri.isEqualOrParent(uri, folder.uri));
 	}
 
 	/**
@@ -223,8 +186,7 @@ export class CommandLineNpmScriptAutoApproveAnalyzer extends Disposable implemen
 			const text = content.value.toString();
 
 			return this._parsePackageJsonScripts(text);
-		} catch (e) {
-			this._log('Failed to read package.json', packageJsonUri.toString(), e);
+		} catch {
 			return undefined;
 		}
 	}
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
index cb8181c67df77..e5a48a4a0e046 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
@@ -16,12 +16,12 @@ import { TerminalToolConfirmationStorageKeys } from '../../../../../chat/browser
 import { ChatConfiguration } from '../../../../../chat/common/constants.js';
 import type { ToolConfirmationAction } from '../../../../../chat/common/languageModelToolsService.js';
 import { TerminalChatAgentToolsSettingId } from '../../../common/terminalChatAgentToolsConfiguration.js';
-import { CommandLineAutoApprover, type IAutoApproveRule, type ICommandApprovalResult, type ICommandApprovalResultWithReason } from '../../commandLineAutoApprover.js';
 import { dedupeRules, generateAutoApproveActions, isPowerShell } from '../../runInTerminalHelpers.js';
 import type { RunInTerminalToolTelemetry } from '../../runInTerminalToolTelemetry.js';
 import { type TreeSitterCommandParser } from '../../treeSitterCommandParser.js';
 import type { ICommandLineAnalyzer, ICommandLineAnalyzerOptions, ICommandLineAnalyzerResult } from './commandLineAnalyzer.js';
 import { TerminalChatCommandId } from '../../../../chat/browser/terminalChat.js';
+import { CommandLineAutoApprover, type IAutoApproveRule, type ICommandApprovalResult, type ICommandApprovalResultWithReason } from './autoApprove/commandLineAutoApprover.js';
 
 const promptInjectionWarningCommandsLower = [
 	'curl',
@@ -87,7 +87,7 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 			};
 		}
 
-		const subCommandResults = subCommands.map(e => this._commandLineAutoApprover.isCommandAutoApproved(e, options.shell, options.os));
+		const subCommandResults = await Promise.all(subCommands.map(e => this._commandLineAutoApprover.isCommandAutoApproved(e, options.shell, options.os, options.cwd)));
 		const commandLineResult = this._commandLineAutoApprover.isCommandLineAutoApproved(options.commandLine);
 		const autoApproveReasons: string[] = [
 			...subCommandResults.map(e => e.reason),
@@ -95,8 +95,9 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 		];
 
 		let isDenied = false;
-		let autoApproveReason: 'subCommand' | 'commandLine' | undefined;
+		let autoApproveReason: 'subCommand' | 'commandLine' | 'npmScript' | undefined;
 		let autoApproveDefault: boolean | undefined;
+		let npmScriptAutoApproveInfo: IMarkdownString | undefined;
 
 		const deniedSubCommandResult = subCommandResults.find(e => e.result === 'denied');
 		if (deniedSubCommandResult) {
@@ -112,7 +113,14 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 		} else {
 			if (subCommandResults.every(e => e.result === 'approved')) {
 				this._log('All sub-commands auto-approved');
-				autoApproveReason = 'subCommand';
+				// Check if any sub-command was approved via npm script
+				const npmScriptApprovedResult = subCommandResults.find(e => e.npmScriptResult?.isAutoApproved);
+				if (npmScriptApprovedResult) {
+					autoApproveReason = 'npmScript';
+					npmScriptAutoApproveInfo = npmScriptApprovedResult.npmScriptResult?.autoApproveInfo;
+				} else {
+					autoApproveReason = 'subCommand';
+				}
 				isAutoApproved = true;
 				autoApproveDefault = subCommandResults.every(e => e.rule?.isDefaultRule);
 			} else {
@@ -137,13 +145,15 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 		const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
 		const isAutoApproveWarningAccepted = this._storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
 		if (isAutoApproveEnabled && isAutoApproved) {
-			autoApproveInfo = this._createAutoApproveInfo(
-				isAutoApproved,
-				isDenied,
-				autoApproveReason,
-				subCommandResults,
-				commandLineResult,
-			);
+			autoApproveInfo = autoApproveReason === 'npmScript' && npmScriptAutoApproveInfo
+				? npmScriptAutoApproveInfo
+				: this._createAutoApproveInfo(
+					isAutoApproved,
+					isDenied,
+					autoApproveReason,
+					subCommandResults,
+					commandLineResult,
+				);
 		} else {
 			isAutoApproved = false;
 		}
@@ -185,7 +195,7 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 	private _createAutoApproveInfo(
 		isAutoApproved: boolean,
 		isDenied: boolean,
-		autoApproveReason: 'subCommand' | 'commandLine' | undefined,
+		autoApproveReason: 'subCommand' | 'commandLine' | 'npmScript' | undefined,
 		subCommandResults: ICommandApprovalResultWithReason[],
 		commandLineResult: ICommandApprovalResultWithReason,
 	): IMarkdownString | undefined {
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool.ts
index db685d506c8ac..82864a5b18660 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/runInTerminalTool.ts
@@ -42,7 +42,6 @@ import { TreeSitterCommandParser, TreeSitterCommandParserLanguage } from '../tre
 import { type ICommandLineAnalyzer, type ICommandLineAnalyzerOptions } from './commandLineAnalyzer/commandLineAnalyzer.js';
 import { CommandLineAutoApproveAnalyzer } from './commandLineAnalyzer/commandLineAutoApproveAnalyzer.js';
 import { CommandLineFileWriteAnalyzer } from './commandLineAnalyzer/commandLineFileWriteAnalyzer.js';
-import { CommandLineNpmScriptAutoApproveAnalyzer } from './commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.js';
 import { OutputMonitor } from './monitoring/outputMonitor.js';
 import { IPollingResult, OutputMonitorState } from './monitoring/types.js';
 import { LocalChatSessionUri } from '../../../../chat/common/chatUri.js';
@@ -317,7 +316,6 @@ export class RunInTerminalTool extends Disposable implements IToolImpl {
 		this._commandLineAnalyzers = [
 			this._register(this._instantiationService.createInstance(CommandLineFileWriteAnalyzer, this._treeSitterCommandParser, (message, args) => this._logService.info(`RunInTerminalTool#CommandLineFileWriteAnalyzer: ${message}`, args))),
 			this._register(this._instantiationService.createInstance(CommandLineAutoApproveAnalyzer, this._treeSitterCommandParser, this._telemetry, (message, args) => this._logService.info(`RunInTerminalTool#CommandLineAutoApproveAnalyzer: ${message}`, args))),
-			this._register(this._instantiationService.createInstance(CommandLineNpmScriptAutoApproveAnalyzer, this._treeSitterCommandParser, (message, args) => this._logService.info(`RunInTerminalTool#CommandLineNpmScriptAutoApproveAnalyzer: ${message}`, args))),
 		];
 
 		// Clear out warning accepted state if the setting is disabled
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/commandLineAutoApprover.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/commandLineAutoApprover.test.ts
index 3ef59e0787757..41709cf2bae4c 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/commandLineAutoApprover.test.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/commandLineAutoApprover.test.ts
@@ -9,9 +9,9 @@ import { TestConfigurationService } from '../../../../../../platform/configurati
 import type { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
 import { workbenchInstantiationService } from '../../../../../test/browser/workbenchTestServices.js';
 import { TerminalChatAgentToolsSettingId } from '../../common/terminalChatAgentToolsConfiguration.js';
-import { CommandLineAutoApprover } from '../../browser/commandLineAutoApprover.js';
 import { ConfigurationTarget } from '../../../../../../platform/configuration/common/configuration.js';
 import { ok, strictEqual } from 'assert';
+import { CommandLineAutoApprover } from '../../browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.js';
 
 suite('CommandLineAutoApprover', () => {
 	const store = ensureNoDisposablesAreLeakedInTestSuite();
@@ -52,8 +52,8 @@ suite('CommandLineAutoApprover', () => {
 		});
 	}
 
-	function isAutoApproved(commandLine: string): boolean {
-		return commandLineAutoApprover.isCommandAutoApproved(commandLine, shell, os).result === 'approved';
+	async function isAutoApproved(commandLine: string): Promise<boolean> {
+		return (await commandLineAutoApprover.isCommandAutoApproved(commandLine, shell, os, undefined)).result === 'approved';
 	}
 
 	function isCommandLineAutoApproved(commandLine: string): boolean {
@@ -61,77 +61,77 @@ suite('CommandLineAutoApprover', () => {
 	}
 
 	suite('autoApprove with allow patterns only', () => {
-		test('should auto-approve exact command match', () => {
+		test('should auto-approve exact command match', async () => {
 			setAutoApprove({
 				'echo': true
 			});
-			ok(isAutoApproved('echo'));
+			ok(await isAutoApproved('echo'));
 		});
 
-		test('should auto-approve command with arguments', () => {
+		test('should auto-approve command with arguments', async () => {
 			setAutoApprove({
 				'echo': true
 			});
-			ok(isAutoApproved('echo hello world'));
+			ok(await isAutoApproved('echo hello world'));
 		});
 
-		test('should not auto-approve when there is no match', () => {
+		test('should not auto-approve when there is no match', async () => {
 			setAutoApprove({
 				'echo': true
 			});
-			ok(!isAutoApproved('ls'));
+			ok(!await isAutoApproved('ls'));
 		});
 
-		test('should not auto-approve partial command matches', () => {
+		test('should not auto-approve partial command matches', async () => {
 			setAutoApprove({
 				'echo': true
 			});
-			ok(!isAutoApproved('echotest'));
+			ok(!await isAutoApproved('echotest'));
 		});
 
-		test('should handle multiple commands in autoApprove', () => {
+		test('should handle multiple commands in autoApprove', async () => {
 			setAutoApprove({
 				'echo': true,
 				'ls': true,
 				'pwd': true
 			});
-			ok(isAutoApproved('echo'));
-			ok(isAutoApproved('ls -la'));
-			ok(isAutoApproved('pwd'));
-			ok(!isAutoApproved('rm'));
+			ok(await isAutoApproved('echo'));
+			ok(await isAutoApproved('ls -la'));
+			ok(await isAutoApproved('pwd'));
+			ok(!await isAutoApproved('rm'));
 		});
 	});
 
 	suite('autoApprove with deny patterns only', () => {
-		test('should deny commands in autoApprove', () => {
+		test('should deny commands in autoApprove', async () => {
 			setAutoApprove({
 				'rm': false,
 				'del': false
 			});
-			ok(!isAutoApproved('rm file.txt'));
-			ok(!isAutoApproved('del file.txt'));
+			ok(!await isAutoApproved('rm file.txt'));
+			ok(!await isAutoApproved('del file.txt'));
 		});
 
-		test('should not auto-approve safe commands when no allow patterns are present', () => {
+		test('should not auto-approve safe commands when no allow patterns are present', async () => {
 			setAutoApprove({
 				'rm': false
 			});
-			ok(!isAutoApproved('echo hello'));
-			ok(!isAutoApproved('ls'));
+			ok(!await isAutoApproved('echo hello'));
+			ok(!await isAutoApproved('ls'));
 		});
 	});
 
 	suite('autoApprove with mixed allow and deny patterns', () => {
-		test('should deny commands set to false even if other commands are set to true', () => {
+		test('should deny commands set to false even if other commands are set to true', async () => {
 			setAutoApprove({
 				'echo': true,
 				'rm': false
 			});
-			ok(isAutoApproved('echo hello'));
-			ok(!isAutoApproved('rm file.txt'));
+			ok(await isAutoApproved('echo hello'));
+			ok(!await isAutoApproved('rm file.txt'));
 		});
 
-		test('should auto-approve allow patterns not set to false', () => {
+		test('should auto-approve allow patterns not set to false', async () => {
 			setAutoApprove({
 				'echo': true,
 				'ls': true,
@@ -139,37 +139,37 @@ suite('CommandLineAutoApprover', () => {
 				'rm': false,
 				'del': false
 			});
-			ok(isAutoApproved('echo'));
-			ok(isAutoApproved('ls'));
-			ok(isAutoApproved('pwd'));
-			ok(!isAutoApproved('rm'));
-			ok(!isAutoApproved('del'));
+			ok(await isAutoApproved('echo'));
+			ok(await isAutoApproved('ls'));
+			ok(await isAutoApproved('pwd'));
+			ok(!await isAutoApproved('rm'));
+			ok(!await isAutoApproved('del'));
 		});
 	});
 
 	suite('regex patterns', () => {
-		test('should handle /.*/', () => {
+		test('should handle /.*/', async () => {
 			setAutoApprove({
 				'/.*/': true,
 			});
 
-			ok(isAutoApproved('echo hello'));
+			ok(await isAutoApproved('echo hello'));
 		});
 
-		test('should handle regex patterns in autoApprove', () => {
+		test('should handle regex patterns in autoApprove', async () => {
 			setAutoApprove({
 				'/^echo/': true,
 				'/^ls/': true,
 				'pwd': true
 			});
 
-			ok(isAutoApproved('echo hello'));
-			ok(isAutoApproved('ls -la'));
-			ok(isAutoApproved('pwd'));
-			ok(!isAutoApproved('rm file'));
+			ok(await isAutoApproved('echo hello'));
+			ok(await isAutoApproved('ls -la'));
+			ok(await isAutoApproved('pwd'));
+			ok(!await isAutoApproved('rm file'));
 		});
 
-		test('should handle regex patterns for deny', () => {
+		test('should handle regex patterns for deny', async () => {
 			setAutoApprove({
 				'echo': true,
 				'rm': true,
@@ -177,146 +177,146 @@ suite('CommandLineAutoApprover', () => {
 				'/^del\\s+/': false
 			});
 
-			ok(isAutoApproved('echo hello'));
-			ok(isAutoApproved('rm'));
-			ok(!isAutoApproved('rm file.txt'));
-			ok(!isAutoApproved('del file.txt'));
+			ok(await isAutoApproved('echo hello'));
+			ok(await isAutoApproved('rm'));
+			ok(!await isAutoApproved('rm file.txt'));
+			ok(!await isAutoApproved('del file.txt'));
 		});
 
-		test('should handle complex regex patterns', () => {
+		test('should handle complex regex patterns', async () => {
 			setAutoApprove({
 				'/^(echo|ls|pwd)\\b/': true,
 				'/^git (status|show\\b.*)$/': true,
 				'/rm|del|kill/': false
 			});
 
-			ok(isAutoApproved('echo test'));
-			ok(isAutoApproved('ls -la'));
-			ok(isAutoApproved('pwd'));
-			ok(isAutoApproved('git status'));
-			ok(isAutoApproved('git show'));
-			ok(isAutoApproved('git show HEAD'));
-			ok(!isAutoApproved('rm file'));
-			ok(!isAutoApproved('del file'));
-			ok(!isAutoApproved('kill process'));
+			ok(await isAutoApproved('echo test'));
+			ok(await isAutoApproved('ls -la'));
+			ok(await isAutoApproved('pwd'));
+			ok(await isAutoApproved('git status'));
+			ok(await isAutoApproved('git show'));
+			ok(await isAutoApproved('git show HEAD'));
+			ok(!await isAutoApproved('rm file'));
+			ok(!await isAutoApproved('del file'));
+			ok(!await isAutoApproved('kill process'));
 		});
 
 		suite('flags', () => {
-			test('should handle case-insensitive regex patterns with i flag', () => {
+			test('should handle case-insensitive regex patterns with i flag', async () => {
 				setAutoApprove({
 					'/^echo/i': true,
 					'/^ls/i': true,
 					'/rm|del/i': false
 				});
 
-				ok(isAutoApproved('echo hello'));
-				ok(isAutoApproved('ECHO hello'));
-				ok(isAutoApproved('Echo hello'));
-				ok(isAutoApproved('ls -la'));
-				ok(isAutoApproved('LS -la'));
-				ok(isAutoApproved('Ls -la'));
-				ok(!isAutoApproved('rm file'));
-				ok(!isAutoApproved('RM file'));
-				ok(!isAutoApproved('del file'));
-				ok(!isAutoApproved('DEL file'));
+				ok(await isAutoApproved('echo hello'));
+				ok(await isAutoApproved('ECHO hello'));
+				ok(await isAutoApproved('Echo hello'));
+				ok(await isAutoApproved('ls -la'));
+				ok(await isAutoApproved('LS -la'));
+				ok(await isAutoApproved('Ls -la'));
+				ok(!await isAutoApproved('rm file'));
+				ok(!await isAutoApproved('RM file'));
+				ok(!await isAutoApproved('del file'));
+				ok(!await isAutoApproved('DEL file'));
 			});
 
-			test('should handle multiple regex flags', () => {
+			test('should handle multiple regex flags', async () => {
 				setAutoApprove({
 					'/^git\\s+/gim': true,
 					'/dangerous/gim': false
 				});
 
-				ok(isAutoApproved('git status'));
-				ok(isAutoApproved('GIT status'));
-				ok(isAutoApproved('Git status'));
-				ok(!isAutoApproved('dangerous command'));
-				ok(!isAutoApproved('DANGEROUS command'));
+				ok(await isAutoApproved('git status'));
+				ok(await isAutoApproved('GIT status'));
+				ok(await isAutoApproved('Git status'));
+				ok(!await isAutoApproved('dangerous command'));
+				ok(!await isAutoApproved('DANGEROUS command'));
 			});
 
-			test('should handle various regex flags', () => {
+			test('should handle various regex flags', async () => {
 				setAutoApprove({
 					'/^echo.*/s': true,  // dotall flag
 					'/^git\\s+/i': true, // case-insensitive flag
 					'/rm|del/g': false   // global flag
 				});
 
-				ok(isAutoApproved('echo hello\nworld'));
-				ok(isAutoApproved('git status'));
-				ok(isAutoApproved('GIT status'));
-				ok(!isAutoApproved('rm file'));
-				ok(!isAutoApproved('del file'));
+				ok(await isAutoApproved('echo hello\nworld'));
+				ok(await isAutoApproved('git status'));
+				ok(await isAutoApproved('GIT status'));
+				ok(!await isAutoApproved('rm file'));
+				ok(!await isAutoApproved('del file'));
 			});
 
-			test('should handle regex patterns without flags', () => {
+			test('should handle regex patterns without flags', async () => {
 				setAutoApprove({
 					'/^echo/': true,
 					'/rm|del/': false
 				});
 
-				ok(isAutoApproved('echo hello'));
-				ok(!isAutoApproved('ECHO hello'), 'Should be case-sensitive without i flag');
-				ok(!isAutoApproved('rm file'));
-				ok(!isAutoApproved('RM file'), 'Should be case-sensitive without i flag');
+				ok(await isAutoApproved('echo hello'));
+				ok(!await isAutoApproved('ECHO hello'), 'Should be case-sensitive without i flag');
+				ok(!await isAutoApproved('rm file'));
+				ok(!await isAutoApproved('RM file'), 'Should be case-sensitive without i flag');
 			});
 		});
 	});
 
 	suite('edge cases', () => {
-		test('should handle empty autoApprove', () => {
+		test('should handle empty autoApprove', async () => {
 			setAutoApprove({});
 
-			ok(!isAutoApproved('echo hello'));
-			ok(!isAutoApproved('ls'));
-			ok(!isAutoApproved('rm file'));
+			ok(!await isAutoApproved('echo hello'));
+			ok(!await isAutoApproved('ls'));
+			ok(!await isAutoApproved('rm file'));
 		});
 
-		test('should handle empty command strings', () => {
+		test('should handle empty command strings', async () => {
 			setAutoApprove({
 				'echo': true
 			});
 
-			ok(!isAutoApproved(''));
-			ok(!isAutoApproved('   '));
+			ok(!await isAutoApproved(''));
+			ok(!await isAutoApproved('   '));
 		});
 
-		test('should handle whitespace in commands', () => {
+		test('should handle whitespace in commands', async () => {
 			setAutoApprove({
 				'echo': true
 			});
 
-			ok(isAutoApproved('echo   hello   world'));
+			ok(await isAutoApproved('echo   hello   world'));
 		});
 
-		test('should be case-sensitive by default', () => {
+		test('should be case-sensitive by default', async () => {
 			setAutoApprove({
 				'echo': true
 			});
 
-			ok(isAutoApproved('echo hello'));
-			ok(!isAutoApproved('ECHO hello'));
-			ok(!isAutoApproved('Echo hello'));
+			ok(await isAutoApproved('echo hello'));
+			ok(!await isAutoApproved('ECHO hello'));
+			ok(!await isAutoApproved('Echo hello'));
 		});
 
 		// https://github.com/microsoft/vscode/issues/252411
-		test('should handle string-based values with special regex characters', () => {
+		test('should handle string-based values with special regex characters', async () => {
 			setAutoApprove({
 				'pwsh.exe -File D:\\foo.bar\\a-script.ps1': true
 			});
 
-			ok(isAutoApproved('pwsh.exe -File D:\\foo.bar\\a-script.ps1'));
-			ok(isAutoApproved('pwsh.exe -File D:\\foo.bar\\a-script.ps1 -AnotherArg'));
+			ok(await isAutoApproved('pwsh.exe -File D:\\foo.bar\\a-script.ps1'));
+			ok(await isAutoApproved('pwsh.exe -File D:\\foo.bar\\a-script.ps1 -AnotherArg'));
 		});
 
-		test('should ignore the empty string key', () => {
+		test('should ignore the empty string key', async () => {
 			setAutoApprove({
 				'': true
 			});
 
-			ok(!isAutoApproved('echo hello'));
+			ok(!await isAutoApproved('echo hello'));
 		});
 
-		test('should handle empty regex patterns that could cause endless loops', () => {
+		test('should handle empty regex patterns that could cause endless loops', async () => {
 			setAutoApprove({
 				'//': true,
 				'/(?:)/': true,
@@ -326,12 +326,12 @@ suite('CommandLineAutoApprover', () => {
 
 			// These patterns should not cause endless loops and should not match any commands
 			// Invalid patterns should be handled gracefully and not match anything
-			ok(!isAutoApproved('echo hello'));
-			ok(!isAutoApproved('ls'));
-			ok(!isAutoApproved(''));
+			ok(!await isAutoApproved('echo hello'));
+			ok(!await isAutoApproved('ls'));
+			ok(!await isAutoApproved(''));
 		});
 
-		test('should handle regex patterns that would cause endless loops', () => {
+		test('should handle regex patterns that would cause endless loops', async () => {
 			setAutoApprove({
 				'/a*/': true,
 				'/b?/': true,
@@ -340,13 +340,13 @@ suite('CommandLineAutoApprover', () => {
 			});
 
 			// Commands should still work normally, endless loop patterns should be safely handled
-			ok(!isAutoApproved('echo hello'));
-			ok(!isAutoApproved('ls'));
-			ok(!isAutoApproved('a'));
-			ok(!isAutoApproved('b'));
+			ok(!await isAutoApproved('echo hello'));
+			ok(!await isAutoApproved('ls'));
+			ok(!await isAutoApproved('a'));
+			ok(!await isAutoApproved('b'));
 		});
 
-		test('should handle mixed valid and problematic regex patterns', () => {
+		test('should handle mixed valid and problematic regex patterns', async () => {
 			setAutoApprove({
 				'/^echo/': true,        // Valid pattern
 				'//': true,             // Empty pattern
@@ -355,13 +355,13 @@ suite('CommandLineAutoApprover', () => {
 				'pwd': true             // Valid string pattern
 			});
 
-			ok(isAutoApproved('echo hello'));
-			ok(isAutoApproved('ls -la'));
-			ok(isAutoApproved('pwd'));
-			ok(!isAutoApproved('rm file'));
+			ok(await isAutoApproved('echo hello'));
+			ok(await isAutoApproved('ls -la'));
+			ok(await isAutoApproved('pwd'));
+			ok(!await isAutoApproved('rm file'));
 		});
 
-		test('should handle invalid regex patterns gracefully', () => {
+		test('should handle invalid regex patterns gracefully', async () => {
 			setAutoApprove({
 				'/*/': true,                    // Invalid regex - nothing to repeat
 				'/(?:+/': true,                 // Invalid regex - incomplete quantifier
@@ -371,72 +371,72 @@ suite('CommandLineAutoApprover', () => {
 			});
 
 			// Valid patterns should still work
-			ok(isAutoApproved('echo hello'));
-			ok(isAutoApproved('ls -la'));
+			ok(await isAutoApproved('echo hello'));
+			ok(await isAutoApproved('ls -la'));
 			// Invalid patterns should not match anything and not cause crashes
-			ok(!isAutoApproved('random command'));
+			ok(!await isAutoApproved('random command'));
 		});
 	});
 
 	suite('path-aware auto approval', () => {
-		test('should handle path variations with forward slashes', () => {
+		test('should handle path variations with forward slashes', async () => {
 			setAutoApprove({
 				'bin/foo': true
 			});
 
 			// Should approve the exact match
-			ok(isAutoApproved('bin/foo'));
-			ok(isAutoApproved('bin/foo --arg'));
+			ok(await isAutoApproved('bin/foo'));
+			ok(await isAutoApproved('bin/foo --arg'));
 
 			// Should approve with Windows backslashes
-			ok(isAutoApproved('bin\\foo'));
-			ok(isAutoApproved('bin\\foo --arg'));
+			ok(await isAutoApproved('bin\\foo'));
+			ok(await isAutoApproved('bin\\foo --arg'));
 
 			// Should approve with current directory prefixes
-			ok(isAutoApproved('./bin/foo'));
-			ok(isAutoApproved('.\\bin/foo'));
-			ok(isAutoApproved('./bin\\foo'));
-			ok(isAutoApproved('.\\bin\\foo'));
+			ok(await isAutoApproved('./bin/foo'));
+			ok(await isAutoApproved('.\\bin/foo'));
+			ok(await isAutoApproved('./bin\\foo'));
+			ok(await isAutoApproved('.\\bin\\foo'));
 
 			// Should not approve partial matches
-			ok(!isAutoApproved('bin/foobar'));
-			ok(!isAutoApproved('notbin/foo'));
+			ok(!await isAutoApproved('bin/foobar'));
+			ok(!await isAutoApproved('notbin/foo'));
 		});
 
-		test('should handle path variations with backslashes', () => {
+		test('should handle path variations with backslashes', async () => {
 			setAutoApprove({
 				'bin\\script.bat': true
 			});
 
 			// Should approve the exact match
-			ok(isAutoApproved('bin\\script.bat'));
-			ok(isAutoApproved('bin\\script.bat --help'));
+			ok(await isAutoApproved('bin\\script.bat'));
+			ok(await isAutoApproved('bin\\script.bat --help'));
 
 			// Should approve with forward slashes
-			ok(isAutoApproved('bin/script.bat'));
-			ok(isAutoApproved('bin/script.bat --help'));
+			ok(await isAutoApproved('bin/script.bat'));
+			ok(await isAutoApproved('bin/script.bat --help'));
 
 			// Should approve with current directory prefixes
-			ok(isAutoApproved('./bin\\script.bat'));
-			ok(isAutoApproved('.\\bin\\script.bat'));
-			ok(isAutoApproved('./bin/script.bat'));
-			ok(isAutoApproved('.\\bin/script.bat'));
+			ok(await isAutoApproved('./bin\\script.bat'));
+			ok(await isAutoApproved('.\\bin\\script.bat'));
+			ok(await isAutoApproved('./bin/script.bat'));
+			ok(await isAutoApproved('.\\bin/script.bat'));
 		});
 
-		test('should handle deep paths', () => {
+		test('should handle deep paths', async () => {
 			setAutoApprove({
 				'src/utils/helper.js': true
 			});
 
-			ok(isAutoApproved('src/utils/helper.js'));
-			ok(isAutoApproved('src\\utils\\helper.js'));
-			ok(isAutoApproved('src/utils\\helper.js'));
-			ok(isAutoApproved('src\\utils/helper.js'));
-			ok(isAutoApproved('./src/utils/helper.js'));
-			ok(isAutoApproved('.\\src\\utils\\helper.js'));
+			ok(await isAutoApproved('src/utils/helper.js'));
+			ok(await isAutoApproved('src\\utils\\helper.js'));
+			ok(await isAutoApproved('src/utils\\helper.js'));
+			ok(await isAutoApproved('src\\utils/helper.js'));
+			ok(await isAutoApproved('./src/utils/helper.js'));
+			ok(await isAutoApproved('.\\src\\utils\\helper.js'));
 		});
 
-		test('should not treat non-paths as paths', () => {
+		test('should not treat non-paths as paths', async () => {
 			setAutoApprove({
 				'echo': true,  // Not a path
 				'ls': true,    // Not a path
@@ -444,29 +444,29 @@ suite('CommandLineAutoApprover', () => {
 			});
 
 			// These should work as normal command matching, not path matching
-			ok(isAutoApproved('echo'));
-			ok(isAutoApproved('ls'));
-			ok(isAutoApproved('git'));
+			ok(await isAutoApproved('echo'));
+			ok(await isAutoApproved('ls'));
+			ok(await isAutoApproved('git'));
 
 			// Should not be treated as paths, so these prefixes shouldn't work
-			ok(!isAutoApproved('./echo'));
-			ok(!isAutoApproved('.\\ls'));
+			ok(!await isAutoApproved('./echo'));
+			ok(!await isAutoApproved('.\\ls'));
 		});
 
-		test('should handle paths with mixed separators in config', () => {
+		test('should handle paths with mixed separators in config', async () => {
 			setAutoApprove({
 				'bin/foo\\bar': true  // Mixed separators in config
 			});
 
-			ok(isAutoApproved('bin/foo\\bar'));
-			ok(isAutoApproved('bin\\foo/bar'));
-			ok(isAutoApproved('bin/foo/bar'));
-			ok(isAutoApproved('bin\\foo\\bar'));
-			ok(isAutoApproved('./bin/foo\\bar'));
-			ok(isAutoApproved('.\\bin\\foo\\bar'));
+			ok(await isAutoApproved('bin/foo\\bar'));
+			ok(await isAutoApproved('bin\\foo/bar'));
+			ok(await isAutoApproved('bin/foo/bar'));
+			ok(await isAutoApproved('bin\\foo\\bar'));
+			ok(await isAutoApproved('./bin/foo\\bar'));
+			ok(await isAutoApproved('.\\bin\\foo\\bar'));
 		});
 
-		test('should work with command line auto approval for paths', () => {
+		test('should work with command line auto approval for paths', async () => {
 			setAutoApproveWithCommandLine({
 				'bin/deploy': { approve: true, matchCommandLine: true }
 			});
@@ -477,22 +477,22 @@ suite('CommandLineAutoApprover', () => {
 			ok(isCommandLineAutoApproved('.\\bin\\deploy --prod'));
 		});
 
-		test('should handle special characters in paths', () => {
+		test('should handle special characters in paths', async () => {
 			setAutoApprove({
 				'bin/my-script.sh': true,
 				'scripts/build_all.py': true,
 				'tools/run (debug).exe': true
 			});
 
-			ok(isAutoApproved('bin/my-script.sh'));
-			ok(isAutoApproved('bin\\my-script.sh'));
-			ok(isAutoApproved('./bin/my-script.sh'));
+			ok(await isAutoApproved('bin/my-script.sh'));
+			ok(await isAutoApproved('bin\\my-script.sh'));
+			ok(await isAutoApproved('./bin/my-script.sh'));
 
-			ok(isAutoApproved('scripts/build_all.py'));
-			ok(isAutoApproved('scripts\\build_all.py'));
+			ok(await isAutoApproved('scripts/build_all.py'));
+			ok(await isAutoApproved('scripts\\build_all.py'));
 
-			ok(isAutoApproved('tools/run (debug).exe'));
-			ok(isAutoApproved('tools\\run (debug).exe'));
+			ok(await isAutoApproved('tools/run (debug).exe'));
+			ok(await isAutoApproved('tools\\run (debug).exe'));
 		});
 	});
 
@@ -501,7 +501,7 @@ suite('CommandLineAutoApprover', () => {
 			shell = 'pwsh';
 		});
 
-		test('should handle Windows PowerShell commands', () => {
+		test('should handle Windows PowerShell commands', async () => {
 			setAutoApprove({
 				'Get-ChildItem': true,
 				'Get-Content': true,
@@ -510,48 +510,48 @@ suite('CommandLineAutoApprover', () => {
 				'del': false
 			});
 
-			ok(isAutoApproved('Get-ChildItem'));
-			ok(isAutoApproved('Get-Content file.txt'));
-			ok(isAutoApproved('Get-Location'));
-			ok(!isAutoApproved('Remove-Item file.txt'));
+			ok(await isAutoApproved('Get-ChildItem'));
+			ok(await isAutoApproved('Get-Content file.txt'));
+			ok(await isAutoApproved('Get-Location'));
+			ok(!await isAutoApproved('Remove-Item file.txt'));
 		});
 
-		test('should handle ( prefixes', () => {
+		test('should handle ( prefixes', async () => {
 			setAutoApprove({
 				'Get-Content': true
 			});
 
-			ok(isAutoApproved('Get-Content file.txt'));
-			ok(isAutoApproved('(Get-Content file.txt'));
-			ok(!isAutoApproved('[Get-Content'));
-			ok(!isAutoApproved('foo'));
+			ok(await isAutoApproved('Get-Content file.txt'));
+			ok(await isAutoApproved('(Get-Content file.txt'));
+			ok(!await isAutoApproved('[Get-Content'));
+			ok(!await isAutoApproved('foo'));
 		});
 
-		test('should be case-insensitive for PowerShell commands', () => {
+		test('should be case-insensitive for PowerShell commands', async () => {
 			setAutoApprove({
 				'Get-ChildItem': true,
 				'Get-Content': true,
 				'Remove-Item': false
 			});
 
-			ok(isAutoApproved('Get-ChildItem'));
-			ok(isAutoApproved('get-childitem'));
-			ok(isAutoApproved('GET-CHILDITEM'));
-			ok(isAutoApproved('Get-childitem'));
-			ok(isAutoApproved('get-ChildItem'));
+			ok(await isAutoApproved('Get-ChildItem'));
+			ok(await isAutoApproved('get-childitem'));
+			ok(await isAutoApproved('GET-CHILDITEM'));
+			ok(await isAutoApproved('Get-childitem'));
+			ok(await isAutoApproved('get-ChildItem'));
 
-			ok(isAutoApproved('Get-Content file.txt'));
-			ok(isAutoApproved('get-content file.txt'));
-			ok(isAutoApproved('GET-CONTENT file.txt'));
-			ok(isAutoApproved('Get-content file.txt'));
+			ok(await isAutoApproved('Get-Content file.txt'));
+			ok(await isAutoApproved('get-content file.txt'));
+			ok(await isAutoApproved('GET-CONTENT file.txt'));
+			ok(await isAutoApproved('Get-content file.txt'));
 
-			ok(!isAutoApproved('Remove-Item file.txt'));
-			ok(!isAutoApproved('remove-item file.txt'));
-			ok(!isAutoApproved('REMOVE-ITEM file.txt'));
-			ok(!isAutoApproved('Remove-item file.txt'));
+			ok(!await isAutoApproved('Remove-Item file.txt'));
+			ok(!await isAutoApproved('remove-item file.txt'));
+			ok(!await isAutoApproved('REMOVE-ITEM file.txt'));
+			ok(!await isAutoApproved('Remove-item file.txt'));
 		});
 
-		test('should be case-insensitive for PowerShell aliases', () => {
+		test('should be case-insensitive for PowerShell aliases', async () => {
 			setAutoApprove({
 				'ls': true,
 				'dir': true,
@@ -560,41 +560,41 @@ suite('CommandLineAutoApprover', () => {
 			});
 
 			// Test case-insensitive matching for aliases
-			ok(isAutoApproved('ls'));
-			ok(isAutoApproved('LS'));
-			ok(isAutoApproved('Ls'));
+			ok(await isAutoApproved('ls'));
+			ok(await isAutoApproved('LS'));
+			ok(await isAutoApproved('Ls'));
 
-			ok(isAutoApproved('dir'));
-			ok(isAutoApproved('DIR'));
-			ok(isAutoApproved('Dir'));
+			ok(await isAutoApproved('dir'));
+			ok(await isAutoApproved('DIR'));
+			ok(await isAutoApproved('Dir'));
 
-			ok(!isAutoApproved('rm file.txt'));
-			ok(!isAutoApproved('RM file.txt'));
-			ok(!isAutoApproved('Rm file.txt'));
+			ok(!await isAutoApproved('rm file.txt'));
+			ok(!await isAutoApproved('RM file.txt'));
+			ok(!await isAutoApproved('Rm file.txt'));
 
-			ok(!isAutoApproved('del file.txt'));
-			ok(!isAutoApproved('DEL file.txt'));
-			ok(!isAutoApproved('Del file.txt'));
+			ok(!await isAutoApproved('del file.txt'));
+			ok(!await isAutoApproved('DEL file.txt'));
+			ok(!await isAutoApproved('Del file.txt'));
 		});
 
-		test('should be case-insensitive with regex patterns', () => {
+		test('should be case-insensitive with regex patterns', async () => {
 			setAutoApprove({
 				'/^Get-/': true,
 				'/Remove-Item|rm/': false
 			});
 
-			ok(isAutoApproved('Get-ChildItem'));
-			ok(isAutoApproved('get-childitem'));
-			ok(isAutoApproved('GET-PROCESS'));
-			ok(isAutoApproved('Get-Location'));
+			ok(await isAutoApproved('Get-ChildItem'));
+			ok(await isAutoApproved('get-childitem'));
+			ok(await isAutoApproved('GET-PROCESS'));
+			ok(await isAutoApproved('Get-Location'));
 
-			ok(!isAutoApproved('Remove-Item file.txt'));
-			ok(!isAutoApproved('remove-item file.txt'));
-			ok(!isAutoApproved('rm file.txt'));
-			ok(!isAutoApproved('RM file.txt'));
+			ok(!await isAutoApproved('Remove-Item file.txt'));
+			ok(!await isAutoApproved('remove-item file.txt'));
+			ok(!await isAutoApproved('rm file.txt'));
+			ok(!await isAutoApproved('RM file.txt'));
 		});
 
-		test('should handle case-insensitive PowerShell commands on different OS', () => {
+		test('should handle case-insensitive PowerShell commands on different OS', async () => {
 			setAutoApprove({
 				'Get-Process': true,
 				'Stop-Process': false
@@ -602,17 +602,17 @@ suite('CommandLineAutoApprover', () => {
 
 			for (const currnetOS of [OperatingSystem.Windows, OperatingSystem.Linux, OperatingSystem.Macintosh]) {
 				os = currnetOS;
-				ok(isAutoApproved('Get-Process'), `os=${os}`);
-				ok(isAutoApproved('get-process'), `os=${os}`);
-				ok(isAutoApproved('GET-PROCESS'), `os=${os}`);
-				ok(!isAutoApproved('Stop-Process'), `os=${os}`);
-				ok(!isAutoApproved('stop-process'), `os=${os}`);
+				ok(await isAutoApproved('Get-Process'), `os=${os}`);
+				ok(await isAutoApproved('get-process'), `os=${os}`);
+				ok(await isAutoApproved('GET-PROCESS'), `os=${os}`);
+				ok(!await isAutoApproved('Stop-Process'), `os=${os}`);
+				ok(!await isAutoApproved('stop-process'), `os=${os}`);
 			}
 		});
 	});
 
 	suite('isCommandLineAutoApproved - matchCommandLine functionality', () => {
-		test('should auto-approve command line patterns with matchCommandLine: true', () => {
+		test('should auto-approve command line patterns with matchCommandLine: true', async () => {
 			setAutoApproveWithCommandLine({
 				'echo': { approve: true, matchCommandLine: true }
 			});
@@ -621,7 +621,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(isCommandLineAutoApproved('echo test && ls'));
 		});
 
-		test('should not auto-approve regular patterns with isCommandLineAutoApproved', () => {
+		test('should not auto-approve regular patterns with isCommandLineAutoApproved', async () => {
 			setAutoApprove({
 				'echo': true
 			});
@@ -630,7 +630,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved('echo hello'));
 		});
 
-		test('should handle regex patterns with matchCommandLine: true', () => {
+		test('should handle regex patterns with matchCommandLine: true', async () => {
 			setAutoApproveWithCommandLine({
 				'/echo.*world/': { approve: true, matchCommandLine: true }
 			});
@@ -639,7 +639,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved('echo hello'));
 		});
 
-		test('should handle case-insensitive regex with matchCommandLine: true', () => {
+		test('should handle case-insensitive regex with matchCommandLine: true', async () => {
 			setAutoApproveWithCommandLine({
 				'/echo/i': { approve: true, matchCommandLine: true }
 			});
@@ -649,7 +649,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(isCommandLineAutoApproved('Echo hello'));
 		});
 
-		test('should handle complex command line patterns', () => {
+		test('should handle complex command line patterns', async () => {
 			setAutoApproveWithCommandLine({
 				'/^npm run build/': { approve: true, matchCommandLine: true },
 				'/\.ps1/i': { approve: true, matchCommandLine: true }
@@ -661,7 +661,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved('npm install'));
 		});
 
-		test('should return false for empty command line', () => {
+		test('should return false for empty command line', async () => {
 			setAutoApproveWithCommandLine({
 				'echo': { approve: true, matchCommandLine: true }
 			});
@@ -670,7 +670,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved('   '));
 		});
 
-		test('should handle mixed configuration with matchCommandLine entries', () => {
+		test('should handle mixed configuration with matchCommandLine entries', async () => {
 			setAutoApproveWithCommandLine({
 				'echo': true,  // Regular pattern
 				'ls': { approve: true, matchCommandLine: true },  // Command line pattern
@@ -683,7 +683,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved('rm file.txt'));
 		});
 
-		test('should handle deny patterns with matchCommandLine: true', () => {
+		test('should handle deny patterns with matchCommandLine: true', async () => {
 			setAutoApproveWithCommandLine({
 				'echo': { approve: true, matchCommandLine: true },
 				'/dangerous/': { approve: false, matchCommandLine: true }
@@ -694,7 +694,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved('dangerous operation'));
 		});
 
-		test('should prioritize deny list over allow list for command line patterns', () => {
+		test('should prioritize deny list over allow list for command line patterns', async () => {
 			setAutoApproveWithCommandLine({
 				'/echo/': { approve: true, matchCommandLine: true },
 				'/echo.*dangerous/': { approve: false, matchCommandLine: true }
@@ -704,7 +704,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved('echo dangerous command'));
 		});
 
-		test('should handle complex deny patterns with matchCommandLine', () => {
+		test('should handle complex deny patterns with matchCommandLine', async () => {
 			setAutoApproveWithCommandLine({
 				'npm': { approve: true, matchCommandLine: true },
 				'/npm.*--force/': { approve: false, matchCommandLine: true },
@@ -717,7 +717,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved('powershell -File script.ps1 -ExecutionPolicy Bypass'));
 		});
 
-		test('should handle empty regex patterns with matchCommandLine that could cause endless loops', () => {
+		test('should handle empty regex patterns with matchCommandLine that could cause endless loops', async () => {
 			setAutoApproveWithCommandLine({
 				'//': { approve: true, matchCommandLine: true },
 				'/(?:)/': { approve: true, matchCommandLine: true },
@@ -732,7 +732,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved(''));
 		});
 
-		test('should handle regex patterns with matchCommandLine that would cause endless loops', () => {
+		test('should handle regex patterns with matchCommandLine that would cause endless loops', async () => {
 			setAutoApproveWithCommandLine({
 				'/a*/': { approve: true, matchCommandLine: true },
 				'/b?/': { approve: true, matchCommandLine: true },
@@ -747,7 +747,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved('b'));
 		});
 
-		test('should handle mixed valid and problematic regex patterns with matchCommandLine', () => {
+		test('should handle mixed valid and problematic regex patterns with matchCommandLine', async () => {
 			setAutoApproveWithCommandLine({
 				'/^echo/': { approve: true, matchCommandLine: true },        // Valid pattern
 				'//': { approve: true, matchCommandLine: true },             // Empty pattern
@@ -762,7 +762,7 @@ suite('CommandLineAutoApprover', () => {
 			ok(!isCommandLineAutoApproved('rm file'));
 		});
 
-		test('should handle invalid regex patterns with matchCommandLine gracefully', () => {
+		test('should handle invalid regex patterns with matchCommandLine gracefully', async () => {
 			setAutoApproveWithCommandLine({
 				'/*/': { approve: true, matchCommandLine: true },                    // Invalid regex - nothing to repeat
 				'/(?:+/': { approve: true, matchCommandLine: true },                 // Invalid regex - incomplete quantifier
@@ -780,8 +780,8 @@ suite('CommandLineAutoApprover', () => {
 	});
 
 	suite('reasons', () => {
-		function getCommandReason(command: string): string {
-			return commandLineAutoApprover.isCommandAutoApproved(command, shell, os).reason;
+		async function getCommandReason(command: string): Promise<string> {
+			return (await commandLineAutoApprover.isCommandAutoApproved(command, shell, os, undefined)).reason;
 		}
 
 		function getCommandLineReason(commandLine: string): string {
@@ -789,30 +789,30 @@ suite('CommandLineAutoApprover', () => {
 		}
 
 		suite('command', () => {
-			test('approved', () => {
+			test('approved', async () => {
 				setAutoApprove({ echo: true });
-				strictEqual(getCommandReason('echo hello'), `Command 'echo hello' is approved by allow list rule: echo`);
+				strictEqual(await getCommandReason('echo hello'), `Command 'echo hello' is approved by allow list rule: echo`);
 			});
-			test('not approved', () => {
+			test('not approved', async () => {
 				setAutoApprove({ echo: false });
-				strictEqual(getCommandReason('echo hello'), `Command 'echo hello' is denied by deny list rule: echo`);
+				strictEqual(await getCommandReason('echo hello'), `Command 'echo hello' is denied by deny list rule: echo`);
 			});
-			test('no match', () => {
+			test('no match', async () => {
 				setAutoApprove({});
-				strictEqual(getCommandReason('echo hello'), `Command 'echo hello' has no matching auto approve entries`);
+				strictEqual(await getCommandReason('echo hello'), `Command 'echo hello' has no matching auto approve entries`);
 			});
 		});
 
 		suite('command line', () => {
-			test('approved', () => {
+			test('approved', async () => {
 				setAutoApproveWithCommandLine({ echo: { approve: true, matchCommandLine: true } });
 				strictEqual(getCommandLineReason('echo hello'), `Command line 'echo hello' is approved by allow list rule: echo`);
 			});
-			test('not approved', () => {
+			test('not approved', async () => {
 				setAutoApproveWithCommandLine({ echo: { approve: false, matchCommandLine: true } });
 				strictEqual(getCommandLineReason('echo hello'), `Command line 'echo hello' is denied by deny list rule: echo`);
 			});
-			test('no match', () => {
+			test('no match', async () => {
 				setAutoApproveWithCommandLine({});
 				strictEqual(getCommandLineReason('echo hello'), `Command line 'echo hello' has no matching auto approve entries`);
 			});
@@ -820,8 +820,8 @@ suite('CommandLineAutoApprover', () => {
 	});
 
 	suite('isDefaultRule logic', () => {
-		function getIsDefaultRule(command: string): boolean | undefined {
-			return commandLineAutoApprover.isCommandAutoApproved(command, shell, os).rule?.isDefaultRule;
+		async function getIsDefaultRule(command: string): Promise<boolean | undefined> {
+			return (await commandLineAutoApprover.isCommandAutoApproved(command, shell, os, undefined)).rule?.isDefaultRule;
 		}
 
 		function getCommandLineIsDefaultRule(commandLine: string): boolean | undefined {
@@ -911,67 +911,67 @@ suite('CommandLineAutoApprover', () => {
 			});
 		}
 
-		test('should correctly identify default rules vs user-defined rules', () => {
+		test('should correctly identify default rules vs user-defined rules', async () => {
 			setAutoApproveWithDefaults(
 				{ 'echo': true, 'ls': true, 'pwd': false },
 				{ 'echo': true, 'cat': true }
 			);
 
-			strictEqual(getIsDefaultRule('echo hello'), true, 'echo is in both default and user config with same value - should be marked as default');
-			strictEqual(getIsDefaultRule('ls -la'), false, 'ls is only in user config - should be marked as user-defined');
-			strictEqual(getIsDefaultRule('pwd'), false, 'pwd is only in user config - should be marked as user-defined');
-			strictEqual(getIsDefaultRule('cat file.txt'), true, 'cat is in both default and user config with same value - should be marked as default');
+			strictEqual(await getIsDefaultRule('echo hello'), true, 'echo is in both default and user config with same value - should be marked as default');
+			strictEqual(await getIsDefaultRule('ls -la'), false, 'ls is only in user config - should be marked as user-defined');
+			strictEqual(await getIsDefaultRule('pwd'), false, 'pwd is only in user config - should be marked as user-defined');
+			strictEqual(await getIsDefaultRule('cat file.txt'), true, 'cat is in both default and user config with same value - should be marked as default');
 		});
 
-		test('should mark as default when command is only in default config but not in user config', () => {
+		test('should mark as default when command is only in default config but not in user config', async () => {
 			setAutoApproveWithDefaults(
 				{ 'echo': true, 'ls': true },  // User config (cat is NOT here)
 				{ 'echo': true, 'cat': true }  // Default config (cat IS here)
 			);
 
 			// Test that merged config includes all commands
-			strictEqual(commandLineAutoApprover.isCommandAutoApproved('echo', shell, os).result, 'approved', 'echo should be approved');
-			strictEqual(commandLineAutoApprover.isCommandAutoApproved('ls', shell, os).result, 'approved', 'ls should be approved');
+			strictEqual((await commandLineAutoApprover.isCommandAutoApproved('echo', shell, os, undefined)).result, 'approved', 'echo should be approved');
+			strictEqual((await commandLineAutoApprover.isCommandAutoApproved('ls', shell, os, undefined)).result, 'approved', 'ls should be approved');
 
 			// cat should be approved because it's in the merged config
-			const catResult = commandLineAutoApprover.isCommandAutoApproved('cat', shell, os);
+			const catResult = await commandLineAutoApprover.isCommandAutoApproved('cat', shell, os, undefined);
 			strictEqual(catResult.result, 'approved', 'cat should be approved from default config');
 
 			// cat should be marked as default rule since it comes from default config only
 			strictEqual(catResult.rule?.isDefaultRule, true, 'cat is only in default config, not in user config - should be marked as default');
 		});
 
-		test('should handle default rules with different values', () => {
+		test('should handle default rules with different values', async () => {
 			setAutoApproveWithDefaults(
 				{ 'echo': true, 'rm': true },
 				{ 'echo': false, 'rm': true }
 			);
 
-			strictEqual(getIsDefaultRule('echo hello'), false, 'echo has different values in default vs user - should be marked as user-defined');
-			strictEqual(getIsDefaultRule('rm file.txt'), true, 'rm has same value in both - should be marked as default');
+			strictEqual(await getIsDefaultRule('echo hello'), false, 'echo has different values in default vs user - should be marked as user-defined');
+			strictEqual(await getIsDefaultRule('rm file.txt'), true, 'rm has same value in both - should be marked as default');
 		});
 
-		test('should handle regex patterns as default rules', () => {
+		test('should handle regex patterns as default rules', async () => {
 			setAutoApproveWithDefaults(
 				{ '/^git/': true, '/^npm/': false },
 				{ '/^git/': true, '/^docker/': true }
 			);
 
-			strictEqual(getIsDefaultRule('git status'), true, 'git pattern matches default - should be marked as default');
-			strictEqual(getIsDefaultRule('npm install'), false, 'npm pattern is user-only - should be marked as user-defined');
+			strictEqual(await getIsDefaultRule('git status'), true, 'git pattern matches default - should be marked as default');
+			strictEqual(await getIsDefaultRule('npm install'), false, 'npm pattern is user-only - should be marked as user-defined');
 		});
 
-		test('should handle mixed string and regex patterns', () => {
+		test('should handle mixed string and regex patterns', async () => {
 			setAutoApproveWithDefaults(
 				{ 'echo': true, '/^ls/': false },
 				{ 'echo': true, 'cat': true }
 			);
 
-			strictEqual(getIsDefaultRule('echo hello'), true, 'String pattern matching default');
-			strictEqual(getIsDefaultRule('ls -la'), false, 'Regex pattern user-defined');
+			strictEqual(await getIsDefaultRule('echo hello'), true, 'String pattern matching default');
+			strictEqual(await getIsDefaultRule('ls -la'), false, 'Regex pattern user-defined');
 		});
 
-		test('should handle command line rules with isDefaultRule', () => {
+		test('should handle command line rules with isDefaultRule', async () => {
 			setAutoApproveWithDefaultsCommandLine(
 				{
 					'echo': { approve: true, matchCommandLine: true },
@@ -987,7 +987,7 @@ suite('CommandLineAutoApprover', () => {
 			strictEqual(getCommandLineIsDefaultRule('ls -la'), false, 'ls is user-defined only - should be marked as user-defined');
 		});
 
-		test('should handle command line rules with different matchCommandLine values', () => {
+		test('should handle command line rules with different matchCommandLine values', async () => {
 			setAutoApproveWithDefaultsCommandLine(
 				{
 					'echo': { approve: true, matchCommandLine: true },
@@ -1003,7 +1003,7 @@ suite('CommandLineAutoApprover', () => {
 			strictEqual(getCommandLineIsDefaultRule('ls -la'), undefined, 'ls matches exactly - should be default (but won\'t match command line check since matchCommandLine is false)');
 		});
 
-		test('should handle boolean vs object format consistency', () => {
+		test('should handle boolean vs object format consistency', async () => {
 			setAutoApproveWithDefaultsCommandLine(
 				{
 					'echo': true,
@@ -1015,41 +1015,41 @@ suite('CommandLineAutoApprover', () => {
 				}
 			);
 
-			strictEqual(getIsDefaultRule('echo hello'), true, 'Boolean format matching - should be default');
+			strictEqual(await getIsDefaultRule('echo hello'), true, 'Boolean format matching - should be default');
 			strictEqual(getCommandLineIsDefaultRule('ls -la'), true, 'Object format matching using structural equality - should be default');
 		});
 
-		test('should return undefined for noMatch cases', () => {
+		test('should return undefined for noMatch cases', async () => {
 			setAutoApproveWithDefaults(
 				{ 'echo': true },
 				{ 'cat': true }
 			);
 
-			strictEqual(getIsDefaultRule('unknown-command'), undefined, 'Command that matches neither user nor default config');
+			strictEqual(await getIsDefaultRule('unknown-command'), undefined, 'Command that matches neither user nor default config');
 			strictEqual(getCommandLineIsDefaultRule('unknown-command'), undefined, 'Command that matches neither user nor default config');
 		});
 
-		test('should handle empty configurations', () => {
+		test('should handle empty configurations', async () => {
 			setAutoApproveWithDefaults(
 				{},
 				{}
 			);
 
-			strictEqual(getIsDefaultRule('echo hello'), undefined);
+			strictEqual(await getIsDefaultRule('echo hello'), undefined);
 			strictEqual(getCommandLineIsDefaultRule('echo hello'), undefined);
 		});
 
-		test('should handle only default config with no user overrides', () => {
+		test('should handle only default config with no user overrides', async () => {
 			setAutoApproveWithDefaults(
 				{},
 				{ 'echo': true, 'ls': false }
 			);
 
-			strictEqual(getIsDefaultRule('echo hello'), true, 'Commands in default config should be marked as default rules even with empty user config');
-			strictEqual(getIsDefaultRule('ls -la'), true, 'Commands in default config should be marked as default rules even with empty user config');
+			strictEqual(await getIsDefaultRule('echo hello'), true, 'Commands in default config should be marked as default rules even with empty user config');
+			strictEqual(await getIsDefaultRule('ls -la'), true, 'Commands in default config should be marked as default rules even with empty user config');
 		});
 
-		test('should handle complex nested object rules', () => {
+		test('should handle complex nested object rules', async () => {
 			setAutoApproveWithDefaultsCommandLine(
 				{
 					'npm': { approve: true, matchCommandLine: true },
@@ -1065,7 +1065,7 @@ suite('CommandLineAutoApprover', () => {
 			strictEqual(getCommandLineIsDefaultRule('git status'), undefined, 'git is user-defined - should be user-defined (but won\'t match command line since matchCommandLine is false)');
 		});
 
-		test('should handle PowerShell case-insensitive matching with defaults', () => {
+		test('should handle PowerShell case-insensitive matching with defaults', async () => {
 			shell = 'pwsh';
 			os = OperatingSystem.Windows;
 
@@ -1074,12 +1074,12 @@ suite('CommandLineAutoApprover', () => {
 				{ 'Get-Process': true }
 			);
 
-			strictEqual(getIsDefaultRule('Get-Process'), true, 'Case-insensitive PowerShell command matching default');
-			strictEqual(getIsDefaultRule('get-process'), true, 'Case-insensitive PowerShell command matching default');
-			strictEqual(getIsDefaultRule('GET-PROCESS'), true, 'Case-insensitive PowerShell command matching default');
+			strictEqual(await getIsDefaultRule('Get-Process'), true, 'Case-insensitive PowerShell command matching default');
+			strictEqual(await getIsDefaultRule('get-process'), true, 'Case-insensitive PowerShell command matching default');
+			strictEqual(await getIsDefaultRule('GET-PROCESS'), true, 'Case-insensitive PowerShell command matching default');
 		});
 
-		test('should use structural equality for object comparison', () => {
+		test('should use structural equality for object comparison', async () => {
 			// Test that objects with same content but different instances are treated as equal
 			const userConfig = { 'test': { approve: true, matchCommandLine: true } };
 			const defaultConfig = { 'test': { approve: true, matchCommandLine: true } };
@@ -1089,7 +1089,7 @@ suite('CommandLineAutoApprover', () => {
 			strictEqual(getCommandLineIsDefaultRule('test command'), true, 'Even though userConfig and defaultConfig are different object instances, they have the same structure and values, so should be considered default');
 		});
 
-		test('should detect structural differences in objects', () => {
+		test('should detect structural differences in objects', async () => {
 			const userConfig = { 'test': { approve: true, matchCommandLine: true } };
 			const defaultConfig = { 'test': { approve: true, matchCommandLine: false } };
 
@@ -1098,7 +1098,7 @@ suite('CommandLineAutoApprover', () => {
 			strictEqual(getCommandLineIsDefaultRule('test command'), false, 'Objects have different matchCommandLine values, so should be user-defined');
 		});
 
-		test('should handle mixed types correctly', () => {
+		test('should handle mixed types correctly', async () => {
 			const userConfig = {
 				'cmd1': true,
 				'cmd2': { approve: false, matchCommandLine: true }
@@ -1110,7 +1110,7 @@ suite('CommandLineAutoApprover', () => {
 
 			setAutoApproveWithDefaultsCommandLine(userConfig, defaultConfig);
 
-			strictEqual(getIsDefaultRule('cmd1 arg'), true, 'Boolean type should match default');
+			strictEqual(await getIsDefaultRule('cmd1 arg'), true, 'Boolean type should match default');
 			strictEqual(getCommandLineIsDefaultRule('cmd2 arg'), true, 'Object type should match default using structural equality (even though it\'s a deny rule)');
 		});
 	});
@@ -1160,28 +1160,28 @@ suite('CommandLineAutoApprover', () => {
 			setConfig(TerminalChatAgentToolsSettingId.IgnoreDefaultAutoApproveRules, value);
 		}
 
-		test('should include default rules when ignoreDefaultAutoApproveRules is false (default behavior)', () => {
+		test('should include default rules when ignoreDefaultAutoApproveRules is false (default behavior)', async () => {
 			setAutoApproveWithDefaults(
 				{ 'ls': true },
 				{ 'echo': true, 'cat': true }
 			);
 			setIgnoreDefaultAutoApproveRules(false);
 
-			ok(isAutoApproved('ls -la'), 'User-defined rule should work');
-			ok(isAutoApproved('echo hello'), 'Default rule should work when not ignored');
-			ok(isAutoApproved('cat file.txt'), 'Default rule should work when not ignored');
+			ok(await isAutoApproved('ls -la'), 'User-defined rule should work');
+			ok(await isAutoApproved('echo hello'), 'Default rule should work when not ignored');
+			ok(await isAutoApproved('cat file.txt'), 'Default rule should work when not ignored');
 		});
 
-		test('should exclude default rules when ignoreDefaultAutoApproveRules is true', () => {
+		test('should exclude default rules when ignoreDefaultAutoApproveRules is true', async () => {
 			setAutoApproveWithDefaults(
 				{ 'ls': true },
 				{ 'echo': true, 'cat': true }
 			);
 			setIgnoreDefaultAutoApproveRules(true);
 
-			ok(isAutoApproved('ls -la'), 'User-defined rule should still work');
-			ok(!isAutoApproved('echo hello'), 'Default rule should be ignored');
-			ok(!isAutoApproved('cat file.txt'), 'Default rule should be ignored');
+			ok(await isAutoApproved('ls -la'), 'User-defined rule should still work');
+			ok(!await isAutoApproved('echo hello'), 'Default rule should be ignored');
+			ok(!await isAutoApproved('cat file.txt'), 'Default rule should be ignored');
 		});
 	});
 });
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/runInTerminalHelpers.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/runInTerminalHelpers.test.ts
index fc802aafa1b41..da303f7582af2 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/runInTerminalHelpers.test.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/runInTerminalHelpers.test.ts
@@ -8,7 +8,7 @@ import { TRUNCATION_MESSAGE, dedupeRules, isPowerShell, sanitizeTerminalOutput,
 import { OperatingSystem } from '../../../../../../base/common/platform.js';
 import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../../base/test/common/utils.js';
 import { ConfigurationTarget } from '../../../../../../platform/configuration/common/configuration.js';
-import type { IAutoApproveRule, ICommandApprovalResultWithReason } from '../../browser/commandLineAutoApprover.js';
+import type { IAutoApproveRule, ICommandApprovalResultWithReason } from '../../browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.js';
 
 suite('isPowerShell', () => {
 	ensureNoDisposablesAreLeakedInTestSuite();
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
deleted file mode 100644
index 5c3e73e85df83..0000000000000
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.test.ts
+++ /dev/null
@@ -1,365 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { strictEqual } from 'assert';
-import { VSBuffer } from '../../../../../../../base/common/buffer.js';
-import { Schemas } from '../../../../../../../base/common/network.js';
-import { OperatingSystem } from '../../../../../../../base/common/platform.js';
-import { URI } from '../../../../../../../base/common/uri.js';
-import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../../../base/test/common/utils.js';
-import { ITreeSitterLibraryService } from '../../../../../../../editor/common/services/treeSitter/treeSitterLibraryService.js';
-import { TestConfigurationService } from '../../../../../../../platform/configuration/test/common/testConfigurationService.js';
-import { FileService } from '../../../../../../../platform/files/common/fileService.js';
-import { IFileService } from '../../../../../../../platform/files/common/files.js';
-import { InMemoryFileSystemProvider } from '../../../../../../../platform/files/common/inMemoryFilesystemProvider.js';
-import type { TestInstantiationService } from '../../../../../../../platform/instantiation/test/common/instantiationServiceMock.js';
-import { NullLogService } from '../../../../../../../platform/log/common/log.js';
-import { IStorageService, StorageScope } from '../../../../../../../platform/storage/common/storage.js';
-import { IWorkspaceContextService, toWorkspaceFolder } from '../../../../../../../platform/workspace/common/workspace.js';
-import { Workspace } from '../../../../../../../platform/workspace/test/common/testWorkspace.js';
-import { TerminalToolConfirmationStorageKeys } from '../../../../../chat/browser/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
-import { TreeSitterLibraryService } from '../../../../../../services/treeSitter/browser/treeSitterLibraryService.js';
-import { workbenchInstantiationService } from '../../../../../../test/browser/workbenchTestServices.js';
-import { TestIPCFileSystemProvider } from '../../../../../../test/electron-browser/workbenchTestServices.js';
-import { TestContextService, TestStorageService } from '../../../../../../test/common/workbenchTestServices.js';
-import type { ICommandLineAnalyzerOptions } from '../../../browser/tools/commandLineAnalyzer/commandLineAnalyzer.js';
-import { CommandLineNpmScriptAutoApproveAnalyzer } from '../../../browser/tools/commandLineAnalyzer/commandLineNpmScriptAutoApproveAnalyzer.js';
-import { TreeSitterCommandParser, TreeSitterCommandParserLanguage } from '../../../browser/treeSitterCommandParser.js';
-import { TerminalChatAgentToolsSettingId } from '../../../common/terminalChatAgentToolsConfiguration.js';
-
-suite('CommandLineNpmScriptAutoApproveAnalyzer', () => {
-	const store = ensureNoDisposablesAreLeakedInTestSuite();
-
-	let instantiationService: TestInstantiationService;
-	let parser: TreeSitterCommandParser;
-	let analyzer: CommandLineNpmScriptAutoApproveAnalyzer;
-	let configurationService: TestConfigurationService;
-	let workspaceContextService: TestContextService;
-	let storageService: TestStorageService;
-	let fileService: FileService;
-	let fileSystemProvider: InMemoryFileSystemProvider;
-
-	const mockLog = (..._args: unknown[]) => { };
-
-	// Use inMemory scheme to avoid platform-specific path issues
-	const cwd = URI.from({ scheme: Schemas.inMemory, path: '/workspace/project' });
-
-	setup(async () => {
-		fileService = store.add(new FileService(new NullLogService()));
-
-		// Register file: scheme provider for tree-sitter WASM grammar loading
-		store.add(fileService.registerProvider(Schemas.file, new TestIPCFileSystemProvider()));
-
-		// Register inMemory: scheme provider for test package.json files
-		fileSystemProvider = store.add(new InMemoryFileSystemProvider());
-		store.add(fileService.registerProvider(Schemas.inMemory, fileSystemProvider));
-
-		// Create workspace directory structure
-		await fileService.createFolder(cwd);
-
-		configurationService = new TestConfigurationService();
-		workspaceContextService = new TestContextService();
-		storageService = store.add(new TestStorageService());
-
-		instantiationService = workbenchInstantiationService({
-			fileService: () => fileService,
-			configurationService: () => configurationService
-		}, store);
-
-		instantiationService.stub(IWorkspaceContextService, workspaceContextService);
-		instantiationService.stub(IStorageService, storageService);
-		instantiationService.stub(IFileService, fileService);
-
-		const treeSitterLibraryService = store.add(instantiationService.createInstance(TreeSitterLibraryService));
-		treeSitterLibraryService.isTest = true;
-		instantiationService.stub(ITreeSitterLibraryService, treeSitterLibraryService);
-
-		parser = store.add(instantiationService.createInstance(TreeSitterCommandParser));
-
-		analyzer = store.add(instantiationService.createInstance(
-			CommandLineNpmScriptAutoApproveAnalyzer,
-			parser,
-			mockLog
-		));
-
-		// Enable auto-approve by default for tests
-		configurationService.setUserConfiguration(TerminalChatAgentToolsSettingId.EnableAutoApprove, true);
-		configurationService.setUserConfiguration(TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts, true);
-		storageService.store(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, true, StorageScope.APPLICATION, 0);
-
-		// Setup workspace
-		const workspace = new Workspace('test', [toWorkspaceFolder(cwd)]);
-		workspaceContextService.setWorkspace(workspace);
-	});
-
-	async function writePackageJson(uri: URI, scripts: Record<string, string>) {
-		const packageJson = {
-			name: 'test-project',
-			version: '1.0.0',
-			scripts
-		};
-		await fileService.writeFile(uri, VSBuffer.fromString(JSON.stringify(packageJson, null, 2)));
-	}
-
-	async function t(commandLine: string, scripts: Record<string, string>, expectedAutoApproved: boolean | undefined) {
-		const packageJsonUri = URI.joinPath(cwd, 'package.json');
-		await writePackageJson(packageJsonUri, scripts);
-
-		const options: ICommandLineAnalyzerOptions = {
-			commandLine,
-			cwd,
-			shell: 'bash',
-			os: OperatingSystem.Linux,
-			treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
-			terminalToolSessionId: 'test',
-			chatSessionId: 'test',
-		};
-
-		const result = await analyzer.analyze(options);
-		strictEqual(result.isAutoApproved, expectedAutoApproved, `Expected isAutoApproved to be ${expectedAutoApproved} for: ${commandLine}`);
-		strictEqual(result.isAutoApproveAllowed, true, 'isAutoApproveAllowed should always be true');
-	}
-
-	suite('npm run commands', () => {
-		test('npm run build - script exists', () => t('npm run build', { build: 'tsc' }, true));
-		test('npm run test - script exists', () => t('npm run test', { test: 'jest' }, true));
-		test('npm run dev - script exists', () => t('npm run dev', { dev: 'vite' }, true));
-		test('npm run start - script exists', () => t('npm run start', { start: 'node index.js' }, true));
-		test('npm run lint - script exists', () => t('npm run lint', { lint: 'eslint .' }, true));
-		test('npm run-script build - script exists', () => t('npm run-script build', { build: 'tsc' }, true));
-
-		// Scripts with colons (namespaced scripts)
-		test('npm run build:prod - script with colon exists', () => t('npm run build:prod', { 'build:prod': 'tsc --build' }, true));
-		test('npm run test:unit - script with colon exists', () => t('npm run test:unit', { 'test:unit': 'jest --testPathPattern=unit' }, true));
-		test('npm run lint:fix - script with colon exists', () => t('npm run lint:fix', { 'lint:fix': 'eslint . --fix' }, true));
-
-		test('npm run missing - script does not exist', () => t('npm run missing', { build: 'tsc' }, undefined));
-		test('npm run build - no scripts section', async () => {
-			const packageJsonUri = URI.joinPath(cwd, 'package.json');
-			await fileService.writeFile(packageJsonUri, VSBuffer.fromString(JSON.stringify({ name: 'test' })));
-
-			const options: ICommandLineAnalyzerOptions = {
-				commandLine: 'npm run build',
-				cwd,
-				shell: 'bash',
-				os: OperatingSystem.Linux,
-				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
-				terminalToolSessionId: 'test',
-				chatSessionId: 'test',
-			};
-
-			const result = await analyzer.analyze(options);
-			strictEqual(result.isAutoApproved, undefined);
-		});
-	});
-
-	suite('yarn commands', () => {
-		test('yarn run build - script exists', () => t('yarn run build', { build: 'tsc' }, true));
-		test('yarn run test - script exists', () => t('yarn run test', { test: 'jest' }, true));
-
-		// Yarn shorthand (yarn <script>)
-		test('yarn build - script exists (shorthand)', () => t('yarn build', { build: 'tsc' }, true));
-		test('yarn test - script exists (shorthand)', () => t('yarn test', { test: 'jest' }, true));
-
-		// Yarn built-in commands should not match
-		test('yarn install - built-in command, not a script', () => t('yarn install', { install: 'echo should not match' }, undefined));
-		test('yarn add - built-in command, not a script', () => t('yarn add lodash', { add: 'echo should not match' }, undefined));
-
-		test('yarn run missing - script does not exist', () => t('yarn run missing', { build: 'tsc' }, undefined));
-	});
-
-	suite('pnpm commands', () => {
-		test('pnpm run build - script exists', () => t('pnpm run build', { build: 'tsc' }, true));
-		test('pnpm run test - script exists', () => t('pnpm run test', { test: 'jest' }, true));
-
-		// pnpm shorthand (pnpm <script>)
-		test('pnpm build - script exists (shorthand)', () => t('pnpm build', { build: 'tsc' }, true));
-		test('pnpm test - script exists (shorthand)', () => t('pnpm test', { test: 'jest' }, true));
-
-		// pnpm built-in commands should not match
-		test('pnpm install - built-in command, not a script', () => t('pnpm install', { install: 'echo should not match' }, undefined));
-		test('pnpm add - built-in command, not a script', () => t('pnpm add lodash', { add: 'echo should not match' }, undefined));
-
-		test('pnpm run missing - script does not exist', () => t('pnpm run missing', { build: 'tsc' }, undefined));
-	});
-
-	suite('chained commands', () => {
-		test('npm install && npm run build - both scripts exist', () => t('npm install && npm run build', { build: 'tsc' }, true));
-		test('npm run lint && npm run test - both scripts exist', () => t('npm run lint && npm run test', { lint: 'eslint .', test: 'jest' }, true));
-		test('npm run build && npm run missing - one script missing', () => t('npm run build && npm run missing', { build: 'tsc' }, undefined));
-	});
-
-	suite('no package.json', () => {
-		test('npm run build - no package.json file', async () => {
-			const options: ICommandLineAnalyzerOptions = {
-				commandLine: 'npm run build',
-				cwd: URI.from({ scheme: Schemas.inMemory, path: '/nonexistent/path' }),
-				shell: 'bash',
-				os: OperatingSystem.Linux,
-				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
-				terminalToolSessionId: 'test',
-				chatSessionId: 'test',
-			};
-
-			const result = await analyzer.analyze(options);
-			strictEqual(result.isAutoApproved, undefined);
-			strictEqual(result.isAutoApproveAllowed, true);
-		});
-	});
-
-	suite('non-npm commands', () => {
-		test('git status - not an npm command', () => t('git status', { build: 'tsc' }, undefined));
-		test('ls -la - not an npm command', () => t('ls -la', { build: 'tsc' }, undefined));
-		test('echo hello - not an npm command', () => t('echo hello', { build: 'tsc' }, undefined));
-	});
-
-	suite('auto-approve disabled', () => {
-		test('npm run build - npm script auto-approve setting disabled', async () => {
-			configurationService.setUserConfiguration(TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts, false);
-
-			const packageJsonUri = URI.joinPath(cwd, 'package.json');
-			await writePackageJson(packageJsonUri, { build: 'tsc' });
-
-			const options: ICommandLineAnalyzerOptions = {
-				commandLine: 'npm run build',
-				cwd,
-				shell: 'bash',
-				os: OperatingSystem.Linux,
-				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
-				terminalToolSessionId: 'test',
-				chatSessionId: 'test',
-			};
-
-			const result = await analyzer.analyze(options);
-			strictEqual(result.isAutoApproved, undefined);
-			strictEqual(result.isAutoApproveAllowed, true);
-		});
-
-		test('npm run build - auto-approve setting disabled', async () => {
-			configurationService.setUserConfiguration(TerminalChatAgentToolsSettingId.EnableAutoApprove, false);
-
-			const packageJsonUri = URI.joinPath(cwd, 'package.json');
-			await writePackageJson(packageJsonUri, { build: 'tsc' });
-
-			const options: ICommandLineAnalyzerOptions = {
-				commandLine: 'npm run build',
-				cwd,
-				shell: 'bash',
-				os: OperatingSystem.Linux,
-				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
-				terminalToolSessionId: 'test',
-				chatSessionId: 'test',
-			};
-
-			const result = await analyzer.analyze(options);
-			strictEqual(result.isAutoApproved, undefined);
-			strictEqual(result.isAutoApproveAllowed, true);
-		});
-
-		test('npm run build - warning not accepted', async () => {
-			storageService.store(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, false, StorageScope.APPLICATION, 0);
-
-			const packageJsonUri = URI.joinPath(cwd, 'package.json');
-			await writePackageJson(packageJsonUri, { build: 'tsc' });
-
-			const options: ICommandLineAnalyzerOptions = {
-				commandLine: 'npm run build',
-				cwd,
-				shell: 'bash',
-				os: OperatingSystem.Linux,
-				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
-				terminalToolSessionId: 'test',
-				chatSessionId: 'test',
-			};
-
-			const result = await analyzer.analyze(options);
-			strictEqual(result.isAutoApproved, undefined);
-			strictEqual(result.isAutoApproveAllowed, true);
-		});
-	});
-
-	suite('autoApproveInfo message', () => {
-		test('single script - message contains script name', async () => {
-			const packageJsonUri = URI.joinPath(cwd, 'package.json');
-			await writePackageJson(packageJsonUri, { build: 'tsc' });
-
-			const options: ICommandLineAnalyzerOptions = {
-				commandLine: 'npm run build',
-				cwd,
-				shell: 'bash',
-				os: OperatingSystem.Linux,
-				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
-				terminalToolSessionId: 'test',
-				chatSessionId: 'test',
-			};
-
-			const result = await analyzer.analyze(options);
-			strictEqual(result.isAutoApproved, true);
-			strictEqual(result.autoApproveInfo?.value.includes('build'), true, 'Should mention script name');
-			strictEqual(result.autoApproveInfo?.value.includes('package.json'), true, 'Should mention package.json');
-		});
-
-		test('multiple scripts - message contains all script names', async () => {
-			const packageJsonUri = URI.joinPath(cwd, 'package.json');
-			await writePackageJson(packageJsonUri, { lint: 'eslint .', test: 'jest' });
-
-			const options: ICommandLineAnalyzerOptions = {
-				commandLine: 'npm run lint && npm run test',
-				cwd,
-				shell: 'bash',
-				os: OperatingSystem.Linux,
-				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
-				terminalToolSessionId: 'test',
-				chatSessionId: 'test',
-			};
-
-			const result = await analyzer.analyze(options);
-			strictEqual(result.isAutoApproved, true);
-			strictEqual(result.autoApproveInfo?.value.includes('lint'), true, 'Should mention lint script');
-			strictEqual(result.autoApproveInfo?.value.includes('test'), true, 'Should mention test script');
-		});
-	});
-
-	suite('workspace folder fallback', () => {
-		test('no cwd - falls back to workspace folder root', async () => {
-			const packageJsonUri = URI.joinPath(cwd, 'package.json');
-			await writePackageJson(packageJsonUri, { build: 'tsc' });
-
-			const options: ICommandLineAnalyzerOptions = {
-				commandLine: 'npm run build',
-				cwd: undefined, // No cwd
-				shell: 'bash',
-				os: OperatingSystem.Linux,
-				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
-				terminalToolSessionId: 'test',
-				chatSessionId: 'test',
-			};
-
-			const result = await analyzer.analyze(options);
-			strictEqual(result.isAutoApproved, true);
-		});
-
-		test('cwd outside workspace - does not auto-approve', async () => {
-			// Create package.json outside workspace
-			const outsideCwd = URI.from({ scheme: Schemas.inMemory, path: '/outside/project' });
-			await fileService.createFolder(outsideCwd);
-			const outsidePackageJsonUri = URI.joinPath(outsideCwd, 'package.json');
-			await writePackageJson(outsidePackageJsonUri, { build: 'tsc' });
-
-			const options: ICommandLineAnalyzerOptions = {
-				commandLine: 'npm run build',
-				cwd: outsideCwd, // cwd is outside workspace
-				shell: 'bash',
-				os: OperatingSystem.Linux,
-				treeSitterLanguage: TreeSitterCommandParserLanguage.Bash,
-				terminalToolSessionId: 'test',
-				chatSessionId: 'test',
-			};
-
-			const result = await analyzer.analyze(options);
-			strictEqual(result.isAutoApproved !== true, true, 'Should not auto-approve when cwd is outside workspace');
-		});
-	});
-});
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/npmScriptAutoApprover.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/npmScriptAutoApprover.test.ts
new file mode 100644
index 0000000000000..f73d73eac1b27
--- /dev/null
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/npmScriptAutoApprover.test.ts
@@ -0,0 +1,192 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { strictEqual } from 'assert';
+import { VSBuffer } from '../../../../../../../base/common/buffer.js';
+import { Schemas } from '../../../../../../../base/common/network.js';
+import { URI } from '../../../../../../../base/common/uri.js';
+import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../../../base/test/common/utils.js';
+import { TestConfigurationService } from '../../../../../../../platform/configuration/test/common/testConfigurationService.js';
+import { FileService } from '../../../../../../../platform/files/common/fileService.js';
+import { IFileService } from '../../../../../../../platform/files/common/files.js';
+import { InMemoryFileSystemProvider } from '../../../../../../../platform/files/common/inMemoryFilesystemProvider.js';
+import type { TestInstantiationService } from '../../../../../../../platform/instantiation/test/common/instantiationServiceMock.js';
+import { NullLogService } from '../../../../../../../platform/log/common/log.js';
+import { IWorkspaceContextService, toWorkspaceFolder } from '../../../../../../../platform/workspace/common/workspace.js';
+import { Workspace } from '../../../../../../../platform/workspace/test/common/testWorkspace.js';
+import { workbenchInstantiationService } from '../../../../../../test/browser/workbenchTestServices.js';
+import { TestIPCFileSystemProvider } from '../../../../../../test/electron-browser/workbenchTestServices.js';
+import { TestContextService } from '../../../../../../test/common/workbenchTestServices.js';
+import { TerminalChatAgentToolsSettingId } from '../../../common/terminalChatAgentToolsConfiguration.js';
+import { NpmScriptAutoApprover } from '../../../browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.js';
+
+suite('NpmScriptAutoApprover', () => {
+	const store = ensureNoDisposablesAreLeakedInTestSuite();
+
+	let instantiationService: TestInstantiationService;
+	let approver: NpmScriptAutoApprover;
+	let configurationService: TestConfigurationService;
+	let workspaceContextService: TestContextService;
+	let fileService: FileService;
+	let fileSystemProvider: InMemoryFileSystemProvider;
+
+	// Use inMemory scheme to avoid platform-specific path issues
+	const cwd = URI.from({ scheme: Schemas.inMemory, path: '/workspace/project' });
+
+	setup(async () => {
+		fileService = store.add(new FileService(new NullLogService()));
+
+		// Register file: scheme provider for tree-sitter WASM grammar loading
+		store.add(fileService.registerProvider(Schemas.file, new TestIPCFileSystemProvider()));
+
+		// Register inMemory: scheme provider for test package.json files
+		fileSystemProvider = store.add(new InMemoryFileSystemProvider());
+		store.add(fileService.registerProvider(Schemas.inMemory, fileSystemProvider));
+
+		// Create workspace directory structure
+		await fileService.createFolder(cwd);
+
+		configurationService = new TestConfigurationService();
+		workspaceContextService = new TestContextService();
+
+		instantiationService = workbenchInstantiationService({
+			fileService: () => fileService,
+			configurationService: () => configurationService
+		}, store);
+
+		instantiationService.stub(IWorkspaceContextService, workspaceContextService);
+		instantiationService.stub(IFileService, fileService);
+
+		approver = store.add(instantiationService.createInstance(NpmScriptAutoApprover));
+
+		// Enable npm script auto-approve by default for tests
+		configurationService.setUserConfiguration(TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts, true);
+
+		// Setup workspace
+		const workspace = new Workspace('test', [toWorkspaceFolder(cwd)]);
+		workspaceContextService.setWorkspace(workspace);
+	});
+
+	async function writePackageJson(uri: URI, scripts: Record<string, string>) {
+		const packageJson = {
+			name: 'test-project',
+			version: '1.0.0',
+			scripts
+		};
+		await fileService.writeFile(uri, VSBuffer.fromString(JSON.stringify(packageJson, null, 2)));
+	}
+
+	async function t(command: string, scripts: Record<string, string>, expectedAutoApproved: boolean) {
+		const packageJsonUri = URI.joinPath(cwd, 'package.json');
+		await writePackageJson(packageJsonUri, scripts);
+
+		const result = await approver.isCommandAutoApproved(command, cwd);
+		strictEqual(result.isAutoApproved, expectedAutoApproved, `Expected isAutoApproved to be ${expectedAutoApproved} for: ${command}`);
+	}
+
+	suite('npm run commands', () => {
+		test('npm run build - script exists', () => t('npm run build', { build: 'tsc' }, true));
+		test('npm run test - script exists', () => t('npm run test', { test: 'jest' }, true));
+		test('npm run dev - script exists', () => t('npm run dev', { dev: 'vite' }, true));
+		test('npm run start - script exists', () => t('npm run start', { start: 'node index.js' }, true));
+		test('npm run lint - script exists', () => t('npm run lint', { lint: 'eslint .' }, true));
+		test('npm run-script build - script exists', () => t('npm run-script build', { build: 'tsc' }, true));
+
+		// Scripts with colons (namespaced scripts)
+		test('npm run build:prod - script with colon exists', () => t('npm run build:prod', { 'build:prod': 'tsc --build' }, true));
+		test('npm run test:unit - script with colon exists', () => t('npm run test:unit', { 'test:unit': 'jest --testPathPattern=unit' }, true));
+		test('npm run lint:fix - script with colon exists', () => t('npm run lint:fix', { 'lint:fix': 'eslint . --fix' }, true));
+
+		test('npm run missing - script does not exist', () => t('npm run missing', { build: 'tsc' }, false));
+		test('npm run build - no scripts section', async () => {
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			await fileService.writeFile(packageJsonUri, VSBuffer.fromString(JSON.stringify({ name: 'test' })));
+
+			const result = await approver.isCommandAutoApproved('npm run build', cwd);
+			strictEqual(result.isAutoApproved, false);
+		});
+	});
+
+	suite('yarn commands', () => {
+		test('yarn run build - script exists', () => t('yarn run build', { build: 'tsc' }, true));
+		test('yarn run test - script exists', () => t('yarn run test', { test: 'jest' }, true));
+
+		// Yarn shorthand (yarn <script>)
+		test('yarn build - script exists (shorthand)', () => t('yarn build', { build: 'tsc' }, true));
+		test('yarn test - script exists (shorthand)', () => t('yarn test', { test: 'jest' }, true));
+
+		// Yarn built-in commands should not match
+		test('yarn install - built-in command, not a script', () => t('yarn install', { install: 'echo should not match' }, false));
+		test('yarn add - built-in command, not a script', () => t('yarn add lodash', { add: 'echo should not match' }, false));
+
+		test('yarn run missing - script does not exist', () => t('yarn run missing', { build: 'tsc' }, false));
+	});
+
+	suite('pnpm commands', () => {
+		test('pnpm run build - script exists', () => t('pnpm run build', { build: 'tsc' }, true));
+		test('pnpm run test - script exists', () => t('pnpm run test', { test: 'jest' }, true));
+
+		// pnpm shorthand (pnpm <script>)
+		test('pnpm build - script exists (shorthand)', () => t('pnpm build', { build: 'tsc' }, true));
+		test('pnpm test - script exists (shorthand)', () => t('pnpm test', { test: 'jest' }, true));
+
+		// pnpm built-in commands should not match
+		test('pnpm install - built-in command, not a script', () => t('pnpm install', { install: 'echo should not match' }, false));
+		test('pnpm add - built-in command, not a script', () => t('pnpm add lodash', { add: 'echo should not match' }, false));
+
+		test('pnpm run missing - script does not exist', () => t('pnpm run missing', { build: 'tsc' }, false));
+	});
+
+	suite('no package.json', () => {
+		test('npm run build - no package.json file', async () => {
+			const result = await approver.isCommandAutoApproved('npm run build', URI.from({ scheme: Schemas.inMemory, path: '/nonexistent/path' }));
+			strictEqual(result.isAutoApproved, false);
+		});
+	});
+
+	suite('non-npm commands', () => {
+		test('git status - not an npm command', () => t('git status', { build: 'tsc' }, false));
+		test('ls -la - not an npm command', () => t('ls -la', { build: 'tsc' }, false));
+		test('echo hello - not an npm command', () => t('echo hello', { build: 'tsc' }, false));
+	});
+
+	suite('auto-approve disabled', () => {
+		test('npm run build - npm script auto-approve setting disabled', async () => {
+			configurationService.setUserConfiguration(TerminalChatAgentToolsSettingId.AutoApproveWorkspaceNpmScripts, false);
+
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			await writePackageJson(packageJsonUri, { build: 'tsc' });
+
+			const result = await approver.isCommandAutoApproved('npm run build', cwd);
+			strictEqual(result.isAutoApproved, false);
+		});
+	});
+
+	suite('autoApproveInfo message', () => {
+		test('single script - message contains script name', async () => {
+			const packageJsonUri = URI.joinPath(cwd, 'package.json');
+			await writePackageJson(packageJsonUri, { build: 'tsc' });
+
+			const result = await approver.isCommandAutoApproved('npm run build', cwd);
+			strictEqual(result.isAutoApproved, true);
+			strictEqual(result.scriptName, 'build', 'Should return script name');
+			strictEqual(result.autoApproveInfo?.value.includes('build'), true, 'Should mention script name');
+			strictEqual(result.autoApproveInfo?.value.includes('package.json'), true, 'Should mention package.json');
+		});
+	});
+
+	suite('workspace folder security', () => {
+		test('cwd outside workspace - does not auto-approve', async () => {
+			// Create package.json outside workspace
+			const outsideCwd = URI.from({ scheme: Schemas.inMemory, path: '/outside/project' });
+			await fileService.createFolder(outsideCwd);
+			const outsidePackageJsonUri = URI.joinPath(outsideCwd, 'package.json');
+			await writePackageJson(outsidePackageJsonUri, { build: 'tsc' });
+
+			const result = await approver.isCommandAutoApproved('npm run build', outsideCwd);
+			strictEqual(result.isAutoApproved, false, 'Should not auto-approve when cwd is outside workspace');
+		});
+	});
+});

From 764f82950205f13bdeb807c19030316acc808ee3 Mon Sep 17 00:00:00 2001
From: Daniel Imms <2193314+Tyriar@users.noreply.github.com>
Date: Thu, 1 Jan 2026 04:45:43 -0800
Subject: [PATCH 08/10] Encapsulate npm script result inside
 CommandLineAutoApprover

---
 .../autoApprove/commandLineAutoApprover.ts    |  4 +--
 .../commandLineAutoApproveAnalyzer.ts         | 30 +++++++------------
 2 files changed, 11 insertions(+), 23 deletions(-)

diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
index d8a8bba3740d5..c9a5ae75871b1 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
@@ -13,7 +13,7 @@ import { ConfigurationTarget, IConfigurationService, type IConfigurationValue }
 import { IInstantiationService } from '../../../../../../../../platform/instantiation/common/instantiation.js';
 import { TerminalChatAgentToolsSettingId } from '../../../../common/terminalChatAgentToolsConfiguration.js';
 import { isPowerShell } from '../../../runInTerminalHelpers.js';
-import { INpmScriptAutoApproveResult, NpmScriptAutoApprover } from './npmScriptAutoApprover.js';
+import { NpmScriptAutoApprover } from './npmScriptAutoApprover.js';
 
 export interface IAutoApproveRule {
 	regex: RegExp;
@@ -27,7 +27,6 @@ export interface ICommandApprovalResultWithReason {
 	result: ICommandApprovalResult;
 	reason: string;
 	rule?: IAutoApproveRule;
-	npmScriptResult?: INpmScriptAutoApproveResult;
 }
 
 export type ICommandApprovalResult = 'approved' | 'denied' | 'noMatch';
@@ -120,7 +119,6 @@ export class CommandLineAutoApprover extends Disposable {
 		if (npmScriptResult.isAutoApproved) {
 			return {
 				result: 'approved',
-				npmScriptResult,
 				reason: `Command '${command}' is approved as npm script '${npmScriptResult.scriptName}' is defined in package.json`
 			};
 		}
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
index e5a48a4a0e046..eefc8a578cb07 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
@@ -95,9 +95,8 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 		];
 
 		let isDenied = false;
-		let autoApproveReason: 'subCommand' | 'commandLine' | 'npmScript' | undefined;
+		let autoApproveReason: 'subCommand' | 'commandLine' | undefined;
 		let autoApproveDefault: boolean | undefined;
-		let npmScriptAutoApproveInfo: IMarkdownString | undefined;
 
 		const deniedSubCommandResult = subCommandResults.find(e => e.result === 'denied');
 		if (deniedSubCommandResult) {
@@ -113,14 +112,7 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 		} else {
 			if (subCommandResults.every(e => e.result === 'approved')) {
 				this._log('All sub-commands auto-approved');
-				// Check if any sub-command was approved via npm script
-				const npmScriptApprovedResult = subCommandResults.find(e => e.npmScriptResult?.isAutoApproved);
-				if (npmScriptApprovedResult) {
-					autoApproveReason = 'npmScript';
-					npmScriptAutoApproveInfo = npmScriptApprovedResult.npmScriptResult?.autoApproveInfo;
-				} else {
-					autoApproveReason = 'subCommand';
-				}
+				autoApproveReason = 'subCommand';
 				isAutoApproved = true;
 				autoApproveDefault = subCommandResults.every(e => e.rule?.isDefaultRule);
 			} else {
@@ -145,15 +137,13 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 		const isAutoApproveEnabled = this._configurationService.getValue(TerminalChatAgentToolsSettingId.EnableAutoApprove) === true;
 		const isAutoApproveWarningAccepted = this._storageService.getBoolean(TerminalToolConfirmationStorageKeys.TerminalAutoApproveWarningAccepted, StorageScope.APPLICATION, false);
 		if (isAutoApproveEnabled && isAutoApproved) {
-			autoApproveInfo = autoApproveReason === 'npmScript' && npmScriptAutoApproveInfo
-				? npmScriptAutoApproveInfo
-				: this._createAutoApproveInfo(
-					isAutoApproved,
-					isDenied,
-					autoApproveReason,
-					subCommandResults,
-					commandLineResult,
-				);
+			autoApproveInfo = this._createAutoApproveInfo(
+				isAutoApproved,
+				isDenied,
+				autoApproveReason,
+				subCommandResults,
+				commandLineResult,
+			);
 		} else {
 			isAutoApproved = false;
 		}
@@ -195,7 +185,7 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 	private _createAutoApproveInfo(
 		isAutoApproved: boolean,
 		isDenied: boolean,
-		autoApproveReason: 'subCommand' | 'commandLine' | 'npmScript' | undefined,
+		autoApproveReason: 'subCommand' | 'commandLine' | undefined,
 		subCommandResults: ICommandApprovalResultWithReason[],
 		commandLineResult: ICommandApprovalResultWithReason,
 	): IMarkdownString | undefined {

From a37ba16d1fd69b816a193dea70c8e4d9c01c48a7 Mon Sep 17 00:00:00 2001
From: Daniel Imms <2193314+Tyriar@users.noreply.github.com>
Date: Thu, 1 Jan 2026 05:11:48 -0800
Subject: [PATCH 09/10] Show npm script info, support npm shorthand case

---
 .../autoApprove/commandLineAutoApprover.ts             |  4 +++-
 .../autoApprove/npmScriptAutoApprover.ts               |  3 +++
 .../commandLineAutoApproveAnalyzer.ts                  |  6 ++++++
 .../commandLineAnalyzer/npmScriptAutoApprover.test.ts  | 10 ++++++++++
 4 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
index c9a5ae75871b1..693c6710c1473 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
@@ -13,7 +13,7 @@ import { ConfigurationTarget, IConfigurationService, type IConfigurationValue }
 import { IInstantiationService } from '../../../../../../../../platform/instantiation/common/instantiation.js';
 import { TerminalChatAgentToolsSettingId } from '../../../../common/terminalChatAgentToolsConfiguration.js';
 import { isPowerShell } from '../../../runInTerminalHelpers.js';
-import { NpmScriptAutoApprover } from './npmScriptAutoApprover.js';
+import { NpmScriptAutoApprover, type INpmScriptAutoApproveResult } from './npmScriptAutoApprover.js';
 
 export interface IAutoApproveRule {
 	regex: RegExp;
@@ -27,6 +27,7 @@ export interface ICommandApprovalResultWithReason {
 	result: ICommandApprovalResult;
 	reason: string;
 	rule?: IAutoApproveRule;
+	npmScriptResult?: INpmScriptAutoApproveResult;
 }
 
 export type ICommandApprovalResult = 'approved' | 'denied' | 'noMatch';
@@ -119,6 +120,7 @@ export class CommandLineAutoApprover extends Disposable {
 		if (npmScriptResult.isAutoApproved) {
 			return {
 				result: 'approved',
+				npmScriptResult,
 				reason: `Command '${command}' is approved as npm script '${npmScriptResult.scriptName}' is defined in package.json`
 			};
 		}
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts
index ce89f551a01eb..6d1dcc2c21fdc 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts
@@ -22,6 +22,9 @@ const npmRunPatterns = [
 	// npm run <script>
 	// npm run-script <script>
 	/^(?<command>npm)\s+(?:run(?:-script)?)\s+(?<scriptName>[^\s&|;]+)/i,
+	// npm test, npm start, npm stop, npm restart (shorthand commands)
+	// See https://docs.npmjs.com/cli/v10/commands/npm-run-script
+	/^(?<command>npm)\s+(?<scriptName>test|start|stop|restart)\b/i,
 	// yarn <script>
 	// yarn run <script>
 	/^(?<command>yarn)\s+(?:run\s+)?(?<scriptName>[^\s&|;]+)/i,
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
index eefc8a578cb07..c7e99261517ba 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
@@ -218,6 +218,12 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 					break;
 				}
 				case 'subCommand': {
+					// Check if approval came from npm script
+					const npmScriptApproval = subCommandResults.find(e => e.npmScriptResult?.isAutoApproved);
+					if (npmScriptApproval?.npmScriptResult?.autoApproveInfo) {
+						return npmScriptApproval.npmScriptResult.autoApproveInfo;
+					}
+
 					const uniqueRules = dedupeRules(subCommandResults);
 					if (uniqueRules.length === 1) {
 						return new MarkdownString(localize('autoApprove.rule', 'Auto approved by rule {0}', formatRuleLinks(uniqueRules)), mdTrustSettings);
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/npmScriptAutoApprover.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/npmScriptAutoApprover.test.ts
index f73d73eac1b27..ef9dca698a8dc 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/npmScriptAutoApprover.test.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/electron-browser/commandLineAnalyzer/npmScriptAutoApprover.test.ts
@@ -94,6 +94,16 @@ suite('NpmScriptAutoApprover', () => {
 		test('npm run lint - script exists', () => t('npm run lint', { lint: 'eslint .' }, true));
 		test('npm run-script build - script exists', () => t('npm run-script build', { build: 'tsc' }, true));
 
+		// npm shorthand commands (npm test, npm start, npm stop, npm restart)
+		test('npm test - shorthand script exists', () => t('npm test', { test: 'jest' }, true));
+		test('npm start - shorthand script exists', () => t('npm start', { start: 'node index.js' }, true));
+		test('npm stop - shorthand script exists', () => t('npm stop', { stop: 'pkill node' }, true));
+		test('npm restart - shorthand script exists', () => t('npm restart', { restart: 'npm stop && npm start' }, true));
+		test('npm test - shorthand script does not exist', () => t('npm test', { build: 'tsc' }, false));
+		test('npm test -- --watch - shorthand with args', () => t('npm test -- --watch', { test: 'jest' }, true));
+		test('npm startevil - word boundary prevents match', () => t('npm startevil', { start: 'node index.js', startevil: 'evil' }, false));
+		test('npm install - built-in command, not a script', () => t('npm install', { install: 'echo should not match' }, false));
+
 		// Scripts with colons (namespaced scripts)
 		test('npm run build:prod - script with colon exists', () => t('npm run build:prod', { 'build:prod': 'tsc --build' }, true));
 		test('npm run test:unit - script with colon exists', () => t('npm run test:unit', { 'test:unit': 'jest --testPathPattern=unit' }, true));

From c7b57509e59a595dbff70e0bc9d6dd4d2d6c3477 Mon Sep 17 00:00:00 2001
From: Daniel Imms <2193314+Tyriar@users.noreply.github.com>
Date: Thu, 1 Jan 2026 07:14:26 -0800
Subject: [PATCH 10/10] Fix warnings, add type guards

---
 .../browser/runInTerminalHelpers.ts           |  7 +++-
 .../browser/runInTerminalToolTelemetry.ts     |  2 +-
 .../autoApprove/commandLineAutoApprover.ts    | 16 +++------
 .../autoApprove/npmScriptAutoApprover.ts      |  5 +--
 .../commandLineAnalyzer.ts                    | 23 ++++++++++++
 .../commandLineAutoApproveAnalyzer.ts         | 36 ++++++++++---------
 .../browser/commandLineAutoApprover.test.ts   |  9 +++--
 .../test/browser/runInTerminalHelpers.test.ts | 25 +++++++------
 8 files changed, 77 insertions(+), 46 deletions(-)

diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers.ts
index 7bc8ac0512d1a..62342eea008eb 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalHelpers.ts
@@ -12,6 +12,7 @@ import { localize } from '../../../../../nls.js';
 import type { TerminalNewAutoApproveButtonData } from '../../../chat/browser/widget/chatContentParts/toolInvocationParts/chatTerminalToolConfirmationSubPart.js';
 import type { ToolConfirmationAction } from '../../../chat/common/tools/languageModelToolsService.js';
 import type { ICommandApprovalResultWithReason } from './tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.js';
+import { isAutoApproveRule } from './tools/commandLineAnalyzer/commandLineAnalyzer.js';
 
 export function isPowerShell(envShell: string, os: OperatingSystem): boolean {
 	if (os === OperatingSystem.Windows) {
@@ -207,6 +208,10 @@ export function generateAutoApproveActions(commandLine: string, subCommands: str
 
 export function dedupeRules(rules: ICommandApprovalResultWithReason[]): ICommandApprovalResultWithReason[] {
 	return rules.filter((result, index, array) => {
-		return result.rule && array.findIndex(r => r.rule && r.rule.sourceText === result.rule!.sourceText) === index;
+		if (!isAutoApproveRule(result.rule)) {
+			return false;
+		}
+		const sourceText = result.rule.sourceText;
+		return array.findIndex(r => isAutoApproveRule(r.rule) && r.rule.sourceText === sourceText) === index;
 	});
 }
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalToolTelemetry.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalToolTelemetry.ts
index 81afe7193b747..047c59fab3975 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalToolTelemetry.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/runInTerminalToolTelemetry.ts
@@ -19,7 +19,7 @@ export class RunInTerminalToolTelemetry {
 		subCommands: string[];
 		autoApproveAllowed: 'allowed' | 'needsOptIn' | 'off';
 		autoApproveResult: 'approved' | 'denied' | 'manual';
-		autoApproveReason: 'subCommand' | 'commandLine' | 'npmScript' | undefined;
+		autoApproveReason: 'subCommand' | 'commandLine' | undefined;
 		autoApproveDefault: boolean | undefined;
 	}) {
 		const subCommandsSanitized = state.subCommands.map(e => {
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
index 693c6710c1473..a626a94491861 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.ts
@@ -13,21 +13,13 @@ import { ConfigurationTarget, IConfigurationService, type IConfigurationValue }
 import { IInstantiationService } from '../../../../../../../../platform/instantiation/common/instantiation.js';
 import { TerminalChatAgentToolsSettingId } from '../../../../common/terminalChatAgentToolsConfiguration.js';
 import { isPowerShell } from '../../../runInTerminalHelpers.js';
-import { NpmScriptAutoApprover, type INpmScriptAutoApproveResult } from './npmScriptAutoApprover.js';
-
-export interface IAutoApproveRule {
-	regex: RegExp;
-	regexCaseInsensitive: RegExp;
-	sourceText: string;
-	sourceTarget: ConfigurationTarget;
-	isDefaultRule: boolean;
-}
+import type { IAutoApproveRule, INpmScriptAutoApproveRule } from '../commandLineAnalyzer.js';
+import { NpmScriptAutoApprover } from './npmScriptAutoApprover.js';
 
 export interface ICommandApprovalResultWithReason {
 	result: ICommandApprovalResult;
 	reason: string;
-	rule?: IAutoApproveRule;
-	npmScriptResult?: INpmScriptAutoApproveResult;
+	rule?: IAutoApproveRule | INpmScriptAutoApproveRule;
 }
 
 export type ICommandApprovalResult = 'approved' | 'denied' | 'noMatch';
@@ -120,7 +112,7 @@ export class CommandLineAutoApprover extends Disposable {
 		if (npmScriptResult.isAutoApproved) {
 			return {
 				result: 'approved',
-				npmScriptResult,
+				rule: { type: 'npmScript', npmScriptResult },
 				reason: `Command '${command}' is approved as npm script '${npmScriptResult.scriptName}' is defined in package.json`
 			};
 		}
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts
index 6d1dcc2c21fdc..57da0c5439c13 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/autoApprove/npmScriptAutoApprover.ts
@@ -6,8 +6,8 @@
 import { MarkdownString, type IMarkdownString } from '../../../../../../../../base/common/htmlContent.js';
 import { visit, type JSONVisitor } from '../../../../../../../../base/common/json.js';
 import { Disposable } from '../../../../../../../../base/common/lifecycle.js';
-import { extUri } from '../../../../../../../../base/common/resources.js';
 import { URI } from '../../../../../../../../base/common/uri.js';
+import { IUriIdentityService } from '../../../../../../../../platform/uriIdentity/common/uriIdentity.js';
 import { localize } from '../../../../../../../../nls.js';
 import { IConfigurationService } from '../../../../../../../../platform/configuration/common/configuration.js';
 import { IFileService } from '../../../../../../../../platform/files/common/files.js';
@@ -79,6 +79,7 @@ export class NpmScriptAutoApprover extends Disposable {
 	constructor(
 		@IConfigurationService private readonly _configurationService: IConfigurationService,
 		@IFileService private readonly _fileService: IFileService,
+		@IUriIdentityService private readonly _uriIdentityService: IUriIdentityService,
 		@IWorkspaceContextService private readonly _workspaceContextService: IWorkspaceContextService,
 	) {
 		super();
@@ -153,7 +154,7 @@ export class NpmScriptAutoApprover extends Disposable {
 	 */
 	private _isWithinWorkspace(uri: URI): boolean {
 		const workspaceFolders = this._workspaceContextService.getWorkspace().folders;
-		return workspaceFolders.some((folder: IWorkspaceFolder) => extUri.isEqualOrParent(uri, folder.uri));
+		return workspaceFolders.some((folder: IWorkspaceFolder) => this._uriIdentityService.extUri.isEqualOrParent(uri, folder.uri));
 	}
 
 	/**
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAnalyzer.ts
index b31cb17d04609..d9f3bc96e7276 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAnalyzer.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAnalyzer.ts
@@ -7,9 +7,32 @@ import type { IMarkdownString } from '../../../../../../../base/common/htmlConte
 import type { IDisposable } from '../../../../../../../base/common/lifecycle.js';
 import type { OperatingSystem } from '../../../../../../../base/common/platform.js';
 import type { URI } from '../../../../../../../base/common/uri.js';
+import type { ConfigurationTarget } from '../../../../../../../platform/configuration/common/configuration.js';
 import type { ToolConfirmationAction } from '../../../../../chat/common/tools/languageModelToolsService.js';
+import type { INpmScriptAutoApproveResult } from './autoApprove/npmScriptAutoApprover.js';
 import type { TreeSitterCommandParserLanguage } from '../../treeSitterCommandParser.js';
 
+export interface IAutoApproveRule {
+	regex: RegExp;
+	regexCaseInsensitive: RegExp;
+	sourceText: string;
+	sourceTarget: ConfigurationTarget;
+	isDefaultRule: boolean;
+}
+
+export interface INpmScriptAutoApproveRule {
+	type: 'npmScript';
+	npmScriptResult: INpmScriptAutoApproveResult;
+}
+
+export function isAutoApproveRule(rule: IAutoApproveRule | INpmScriptAutoApproveRule | undefined): rule is IAutoApproveRule {
+	return !!rule && 'sourceText' in rule;
+}
+
+export function isNpmScriptAutoApproveRule(rule: IAutoApproveRule | INpmScriptAutoApproveRule | undefined): rule is INpmScriptAutoApproveRule {
+	return !!rule && 'type' in rule && rule.type === 'npmScript';
+}
+
 export interface ICommandLineAnalyzer extends IDisposable {
 	analyze(options: ICommandLineAnalyzerOptions): Promise<ICommandLineAnalyzerResult>;
 }
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
index 15a04597c7d42..51746efc7988c 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/commandLineAnalyzer/commandLineAutoApproveAnalyzer.ts
@@ -19,9 +19,9 @@ import { TerminalChatAgentToolsSettingId } from '../../../common/terminalChatAge
 import { dedupeRules, generateAutoApproveActions, isPowerShell } from '../../runInTerminalHelpers.js';
 import type { RunInTerminalToolTelemetry } from '../../runInTerminalToolTelemetry.js';
 import { type TreeSitterCommandParser } from '../../treeSitterCommandParser.js';
-import type { ICommandLineAnalyzer, ICommandLineAnalyzerOptions, ICommandLineAnalyzerResult } from './commandLineAnalyzer.js';
+import { type ICommandLineAnalyzer, type ICommandLineAnalyzerOptions, type ICommandLineAnalyzerResult, type IAutoApproveRule, isAutoApproveRule, isNpmScriptAutoApproveRule } from './commandLineAnalyzer.js';
 import { TerminalChatCommandId } from '../../../../chat/browser/terminalChat.js';
-import { CommandLineAutoApprover, type IAutoApproveRule, type ICommandApprovalResult, type ICommandApprovalResultWithReason } from './autoApprove/commandLineAutoApprover.js';
+import { CommandLineAutoApprover, type ICommandApprovalResultWithReason } from './autoApprove/commandLineAutoApprover.js';
 
 const promptInjectionWarningCommandsLower = [
 	'curl',
@@ -102,26 +102,26 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 		if (deniedSubCommandResult) {
 			this._log('Sub-command DENIED auto approval');
 			isDenied = true;
-			autoApproveDefault = deniedSubCommandResult.rule?.isDefaultRule;
+			autoApproveDefault = isAutoApproveRule(deniedSubCommandResult.rule) ? deniedSubCommandResult.rule.isDefaultRule : undefined;
 			autoApproveReason = 'subCommand';
 		} else if (commandLineResult.result === 'denied') {
 			this._log('Command line DENIED auto approval');
 			isDenied = true;
-			autoApproveDefault = commandLineResult.rule?.isDefaultRule;
+			autoApproveDefault = isAutoApproveRule(commandLineResult.rule) ? commandLineResult.rule.isDefaultRule : undefined;
 			autoApproveReason = 'commandLine';
 		} else {
 			if (subCommandResults.every(e => e.result === 'approved')) {
 				this._log('All sub-commands auto-approved');
-				autoApproveReason = 'subCommand';
 				isAutoApproved = true;
-				autoApproveDefault = subCommandResults.every(e => e.rule?.isDefaultRule);
+				autoApproveReason = 'subCommand';
+				autoApproveDefault = subCommandResults.every(e => isAutoApproveRule(e.rule) && e.rule.isDefaultRule);
 			} else {
 				this._log('All sub-commands NOT auto-approved');
 				if (commandLineResult.result === 'approved') {
 					this._log('Command line auto-approved');
 					autoApproveReason = 'commandLine';
 					isAutoApproved = true;
-					autoApproveDefault = commandLineResult.rule?.isDefaultRule;
+					autoApproveDefault = isAutoApproveRule(commandLineResult.rule) ? commandLineResult.rule.isDefaultRule : undefined;
 				} else {
 					this._log('Command line NOT auto-approved');
 				}
@@ -189,11 +189,14 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 		subCommandResults: ICommandApprovalResultWithReason[],
 		commandLineResult: ICommandApprovalResultWithReason,
 	): IMarkdownString | undefined {
-		const formatRuleLinks = (result: SingleOrMany<{ result: ICommandApprovalResult; rule?: IAutoApproveRule; reason: string }>): string => {
-			return asArray(result).map(e => {
-				const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, e.rule!.sourceTarget);
-				return `[\`${e.rule!.sourceText}\`](${settingsUri.toString()} "${localize('ruleTooltip', 'View rule in settings')}")`;
-			}).join(', ');
+		const formatRuleLinks = (results: SingleOrMany<ICommandApprovalResultWithReason>): string => {
+			return asArray(results)
+				.filter((e): e is ICommandApprovalResultWithReason & { rule: IAutoApproveRule } =>
+					isAutoApproveRule(e.rule))
+				.map(e => {
+					const settingsUri = createCommandUri(TerminalChatCommandId.OpenTerminalSettingsLink, e.rule.sourceTarget);
+					return `[\`${e.rule.sourceText}\`](${settingsUri.toString()} "${localize('ruleTooltip', 'View rule in settings')}")`;
+				}).join(', ');
 		};
 
 		const mdTrustSettings = {
@@ -212,18 +215,17 @@ export class CommandLineAutoApproveAnalyzer extends Disposable implements IComma
 		if (isAutoApproved) {
 			switch (autoApproveReason) {
 				case 'commandLine': {
-					if (commandLineResult.rule) {
+					if (isAutoApproveRule(commandLineResult.rule)) {
 						return new MarkdownString(localize('autoApprove.rule', 'Auto approved by rule {0}', formatRuleLinks(commandLineResult)), mdTrustSettings);
 					}
 					break;
 				}
 				case 'subCommand': {
 					// Check if approval came from npm script
-					const npmScriptApproval = subCommandResults.find(e => e.npmScriptResult?.isAutoApproved);
-					if (npmScriptApproval?.npmScriptResult?.autoApproveInfo) {
-						return npmScriptApproval.npmScriptResult.autoApproveInfo;
+					const npmScriptApproval = subCommandResults.find(e => isNpmScriptAutoApproveRule(e.rule));
+					if (npmScriptApproval && isNpmScriptAutoApproveRule(npmScriptApproval.rule) && npmScriptApproval.rule.npmScriptResult.autoApproveInfo) {
+						return npmScriptApproval.rule.npmScriptResult.autoApproveInfo;
 					}
-
 					const uniqueRules = dedupeRules(subCommandResults);
 					if (uniqueRules.length === 1) {
 						return new MarkdownString(localize('autoApprove.rule', 'Auto approved by rule {0}', formatRuleLinks(uniqueRules)), mdTrustSettings);
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/commandLineAutoApprover.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/commandLineAutoApprover.test.ts
index 41709cf2bae4c..f9d03d797f6f3 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/commandLineAutoApprover.test.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/commandLineAutoApprover.test.ts
@@ -12,6 +12,7 @@ import { TerminalChatAgentToolsSettingId } from '../../common/terminalChatAgentT
 import { ConfigurationTarget } from '../../../../../../platform/configuration/common/configuration.js';
 import { ok, strictEqual } from 'assert';
 import { CommandLineAutoApprover } from '../../browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.js';
+import { isAutoApproveRule } from '../../browser/tools/commandLineAnalyzer/commandLineAnalyzer.js';
 
 suite('CommandLineAutoApprover', () => {
 	const store = ensureNoDisposablesAreLeakedInTestSuite();
@@ -821,11 +822,13 @@ suite('CommandLineAutoApprover', () => {
 
 	suite('isDefaultRule logic', () => {
 		async function getIsDefaultRule(command: string): Promise<boolean | undefined> {
-			return (await commandLineAutoApprover.isCommandAutoApproved(command, shell, os, undefined)).rule?.isDefaultRule;
+			const rule = (await commandLineAutoApprover.isCommandAutoApproved(command, shell, os, undefined)).rule;
+			return isAutoApproveRule(rule) ? rule.isDefaultRule : undefined;
 		}
 
 		function getCommandLineIsDefaultRule(commandLine: string): boolean | undefined {
-			return commandLineAutoApprover.isCommandLineAutoApproved(commandLine).rule?.isDefaultRule;
+			const rule = commandLineAutoApprover.isCommandLineAutoApproved(commandLine).rule;
+			return isAutoApproveRule(rule) ? rule.isDefaultRule : undefined;
 		}
 
 		function setAutoApproveWithDefaults(userConfig: { [key: string]: boolean }, defaultConfig: { [key: string]: boolean }) {
@@ -938,7 +941,7 @@ suite('CommandLineAutoApprover', () => {
 			strictEqual(catResult.result, 'approved', 'cat should be approved from default config');
 
 			// cat should be marked as default rule since it comes from default config only
-			strictEqual(catResult.rule?.isDefaultRule, true, 'cat is only in default config, not in user config - should be marked as default');
+			strictEqual(isAutoApproveRule(catResult.rule) ? catResult.rule.isDefaultRule : undefined, true, 'cat is only in default config, not in user config - should be marked as default');
 		});
 
 		test('should handle default rules with different values', async () => {
diff --git a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/runInTerminalHelpers.test.ts b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/runInTerminalHelpers.test.ts
index da303f7582af2..59460d6371ecd 100644
--- a/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/runInTerminalHelpers.test.ts
+++ b/src/vs/workbench/contrib/terminalContrib/chatAgentTools/test/browser/runInTerminalHelpers.test.ts
@@ -8,7 +8,8 @@ import { TRUNCATION_MESSAGE, dedupeRules, isPowerShell, sanitizeTerminalOutput,
 import { OperatingSystem } from '../../../../../../base/common/platform.js';
 import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../../../base/test/common/utils.js';
 import { ConfigurationTarget } from '../../../../../../platform/configuration/common/configuration.js';
-import type { IAutoApproveRule, ICommandApprovalResultWithReason } from '../../browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.js';
+import type { ICommandApprovalResultWithReason } from '../../browser/tools/commandLineAnalyzer/autoApprove/commandLineAutoApprover.js';
+import { isAutoApproveRule, type IAutoApproveRule } from '../../browser/tools/commandLineAnalyzer/commandLineAnalyzer.js';
 
 suite('isPowerShell', () => {
 	ensureNoDisposablesAreLeakedInTestSuite();
@@ -186,6 +187,10 @@ suite('dedupeRules', () => {
 		};
 	}
 
+	function getSourceText(result: ICommandApprovalResultWithReason): string | undefined {
+		return isAutoApproveRule(result.rule) ? result.rule.sourceText : undefined;
+	}
+
 	test('should return empty array for empty input', () => {
 		const result = dedupeRules([]);
 		strictEqual(result.length, 0);
@@ -197,8 +202,8 @@ suite('dedupeRules', () => {
 			createMockResult('approved', 'approved by ls rule', createMockRule('ls'))
 		]);
 		strictEqual(result.length, 2);
-		strictEqual(result[0].rule?.sourceText, 'echo');
-		strictEqual(result[1].rule?.sourceText, 'ls');
+		strictEqual(getSourceText(result[0]), 'echo');
+		strictEqual(getSourceText(result[1]), 'ls');
 	});
 
 	test('should deduplicate rules with same sourceText', () => {
@@ -208,8 +213,8 @@ suite('dedupeRules', () => {
 			createMockResult('approved', 'approved by ls rule', createMockRule('ls'))
 		]);
 		strictEqual(result.length, 2);
-		strictEqual(result[0].rule?.sourceText, 'echo');
-		strictEqual(result[1].rule?.sourceText, 'ls');
+		strictEqual(getSourceText(result[0]), 'echo');
+		strictEqual(getSourceText(result[1]), 'ls');
 	});
 
 	test('should preserve first occurrence when deduplicating', () => {
@@ -228,7 +233,7 @@ suite('dedupeRules', () => {
 			createMockResult('denied', 'denied without rule')
 		]);
 		strictEqual(result.length, 1);
-		strictEqual(result[0].rule?.sourceText, 'echo');
+		strictEqual(getSourceText(result[0]), 'echo');
 	});
 
 	test('should handle mix of rules and no-rule results with duplicates', () => {
@@ -240,8 +245,8 @@ suite('dedupeRules', () => {
 			createMockResult('denied', 'denied without rule')
 		]);
 		strictEqual(result.length, 2);
-		strictEqual(result[0].rule?.sourceText, 'echo');
-		strictEqual(result[1].rule?.sourceText, 'ls');
+		strictEqual(getSourceText(result[0]), 'echo');
+		strictEqual(getSourceText(result[1]), 'ls');
 	});
 
 	test('should handle multiple duplicates of same rule', () => {
@@ -252,9 +257,9 @@ suite('dedupeRules', () => {
 			createMockResult('approved', 'git rule', createMockRule('git'))
 		]);
 		strictEqual(result.length, 2);
-		strictEqual(result[0].rule?.sourceText, 'npm');
+		strictEqual(getSourceText(result[0]), 'npm');
 		strictEqual(result[0].reason, 'npm rule 1');
-		strictEqual(result[1].rule?.sourceText, 'git');
+		strictEqual(getSourceText(result[1]), 'git');
 	});
 });