@codingame/monaco-vscode-api 20.5.0 → 21.0.1

package/vscode/src/vs/workbench/contrib/chat/common/tools/manageTodoListTool.js

@@ -3,112 +3,113 @@ import { __decorate, __param } from '../../../../../../../../external/tslib/tsli
 import { Disposable } from '../../../../../base/common/lifecycle.js';
 import { Codicon } from '../../../../../base/common/codicons.js';
 import { ThemeIcon } from '../../../../../base/common/themables.js';
-import { MarkdownString } from '../../../../../base/common/htmlContent.js';
 import { ToolDataSource } from '../languageModelToolsService.js';
 import { ILogService } from '../../../../../platform/log/common/log.service.js';
+import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
 import { IChatTodoListService } from '../chatTodoListService.service.js';
 import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
+import { IsSimulationContext } from '../../../../../platform/contextkey/common/contextkeys.js';
+import { localize } from '../../../../../nls.js';
+import { MarkdownString } from '../../../../../base/common/htmlContent.js';
 
 const TodoListToolSettingId = 'chat.todoListTool.enabled';
+const TodoListToolWriteOnlySettingId = 'chat.todoListTool.writeOnly';
 const ManageTodoListToolToolId = 'manage_todo_list';
-const ManageTodoListToolData = {
-    id: ManageTodoListToolToolId,
-    toolReferenceName: 'todos',
-    when: ( ContextKeyExpr.equals(`config.${TodoListToolSettingId}`, true)),
-    canBeReferencedInPrompt: true,
-    icon: ThemeIcon.fromId(Codicon.checklist.id),
-    displayName: 'Update Todo List',
-    userDescription: 'Manage and track todo items for task planning',
-    modelDescription: 'Manage a structured todo list to track progress and plan tasks throughout your coding session. Use this tool VERY frequently to ensure task visibility and proper planning.\n\nWhen to use this tool:\n- Complex multi-step work requiring planning and tracking\n- When user provides multiple tasks or requests (numbered/comma-separated)\n- After receiving new instructions that require multiple steps\n- BEFORE starting work on any todo (mark as in-progress)\n- IMMEDIATELY after completing each todo (mark completed individually)\n- When breaking down larger tasks into smaller actionable steps\n- To give users visibility into your progress and planning\n\nWhen NOT to use:\n- Single, trivial tasks that can be completed in one step\n- Purely conversational/informational requests\n- When just reading files or performing simple searches\n\nCRITICAL workflow:\n1. Plan tasks by writing todo list with specific, actionable items\n2. Mark ONE todo as in-progress before starting work\n3. Complete the work for that specific todo\n4. Mark that todo as completed IMMEDIATELY\n5. Move to next todo and repeat\n\nTodo states:\n- not-started: Todo not yet begun\n- in-progress: Currently working (limit ONE at a time)\n- completed: Finished successfully\n\nIMPORTANT: Mark todos completed as soon as they are done. Do not batch completions.',
-    source: ToolDataSource.Internal,
-    inputSchema: {
-        type: 'object',
-        properties: {
-            operation: {
-                type: 'string',
-                enum: ['write', 'read'],
-                description: 'write: Replace entire todo list with new content. read: Retrieve current todo list. ALWAYS provide complete list when writing - partial updates not supported.'
-            },
-            todoList: {
-                type: 'array',
-                description: 'Complete array of all todo items (required for write operation, ignored for read). Must include ALL items - both existing and new.',
-                items: {
-                    type: 'object',
-                    properties: {
-                        id: {
-                            type: 'number',
-                            description: 'Unique identifier for the todo. Use sequential numbers starting from 1.'
-                        },
-                        title: {
-                            type: 'string',
-                            description: 'Concise action-oriented todo label (3-7 words). Displayed in UI.'
-                        },
-                        description: {
-                            type: 'string',
-                            description: 'Detailed context, requirements, or implementation notes. Include file paths, specific methods, or acceptance criteria.'
-                        },
-                        status: {
-                            type: 'string',
-                            enum: ['not-started', 'in-progress', 'completed'],
-                            description: 'not-started: Not begun | in-progress: Currently working (max 1) | completed: Fully finished with no blockers'
-                        },
+function createManageTodoListToolData(writeOnly) {
+    const baseProperties = {
+        todoList: {
+            type: 'array',
+            description: writeOnly
+                ? 'Complete array of all todo items. Must include ALL items - both existing and new.'
+                : 'Complete array of all todo items (required for write operation, ignored for read). Must include ALL items - both existing and new.',
+            items: {
+                type: 'object',
+                properties: {
+                    id: {
+                        type: 'number',
+                        description: 'Unique identifier for the todo. Use sequential numbers starting from 1.'
                     },
-                    required: ['id', 'title', 'description', 'status']
-                }
+                    title: {
+                        type: 'string',
+                        description: 'Concise action-oriented todo label (3-7 words). Displayed in UI.'
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Detailed context, requirements, or implementation notes. Include file paths, specific methods, or acceptance criteria.'
+                    },
+                    status: {
+                        type: 'string',
+                        enum: ['not-started', 'in-progress', 'completed'],
+                        description: 'not-started: Not begun | in-progress: Currently working (max 1) | completed: Fully finished with no blockers'
+                    },
+                },
+                required: ['id', 'title', 'description', 'status']
             }
-        },
-        required: ['operation']
+        }
+    };
+    const requiredFields = writeOnly ? ['todoList'] : [];
+    if (!writeOnly) {
+        baseProperties.operation = {
+            type: 'string',
+            enum: ['write', 'read'],
+            description: 'write: Replace entire todo list with new content. read: Retrieve current todo list. ALWAYS provide complete list when writing - partial updates not supported.'
+        };
+        requiredFields.unshift('operation');
     }
-};
+    return {
+        id: ManageTodoListToolToolId,
+        toolReferenceName: 'todos',
+        when: ( ContextKeyExpr.or(( ContextKeyExpr.equals(`config.${TodoListToolSettingId}`, true)), IsSimulationContext)),
+        canBeReferencedInPrompt: true,
+        icon: ThemeIcon.fromId(Codicon.checklist.id),
+        displayName: ( localize(5642, 'Manage and track todo items for task planning')),
+        userDescription: ( localize(5643, 'Tool for managing and tracking todo items for task planning')),
+        modelDescription: 'Manage a structured todo list to track progress and plan tasks throughout your coding session. Use this tool VERY frequently to ensure task visibility and proper planning.\n\nWhen to use this tool:\n- Complex multi-step work requiring planning and tracking\n- When user provides multiple tasks or requests (numbered/comma-separated)\n- After receiving new instructions that require multiple steps\n- BEFORE starting work on any todo (mark as in-progress)\n- IMMEDIATELY after completing each todo (mark completed individually)\n- When breaking down larger tasks into smaller actionable steps\n- To give users visibility into your progress and planning\n\nWhen NOT to use:\n- Single, trivial tasks that can be completed in one step\n- Purely conversational/informational requests\n- When just reading files or performing simple searches\n\nCRITICAL workflow:\n1. Plan tasks by writing todo list with specific, actionable items\n2. Mark ONE todo as in-progress before starting work\n3. Complete the work for that specific todo\n4. Mark that todo as completed IMMEDIATELY\n5. Move to next todo and repeat\n\nTodo states:\n- not-started: Todo not yet begun\n- in-progress: Currently working (limit ONE at a time)\n- completed: Finished successfully\n\nIMPORTANT: Mark todos completed as soon as they are done. Do not batch completions.',
+        source: ToolDataSource.Internal,
+        inputSchema: {
+            type: 'object',
+            properties: baseProperties,
+            required: requiredFields
+        }
+    };
+}
+createManageTodoListToolData(false);
 let ManageTodoListTool = class ManageTodoListTool extends Disposable {
-    constructor(chatTodoListService, logService) {
+    constructor(writeOnly, chatTodoListService, logService, telemetryService) {
         super();
+        this.writeOnly = writeOnly;
         this.chatTodoListService = chatTodoListService;
         this.logService = logService;
+        this.telemetryService = telemetryService;
     }
     async invoke(invocation, _countTokens, _progress, _token) {
-        const chatSessionId = invocation.context?.sessionId;
-        if (chatSessionId === undefined) {
-            throw ( new Error('A chat session ID is required for this tool'));
-        }
         const args = invocation.parameters;
+        const DEFAULT_TODO_SESSION_ID = 'default';
+        const chatSessionId = invocation.context?.sessionId ?? args.chatSessionId ?? DEFAULT_TODO_SESSION_ID;
         this.logService.debug(`ManageTodoListTool: Invoking with options ${JSON.stringify(args)}`);
         try {
-            const storage = this.chatTodoListService.getChatTodoListStorage();
-            switch (args.operation) {
-                case 'read': {
-                    const readResult = this.handleRead(storage, chatSessionId);
-                    return {
-                        content: [{
-                                kind: 'text',
-                                value: readResult
-                            }]
-                    };
-                }
-                case 'write': {
-                    const todoList = ( args.todoList.map((parsedTodo) => ({
-                        id: parsedTodo.id,
-                        title: parsedTodo.title,
-                        description: parsedTodo.description,
-                        status: parsedTodo.status
-                    })));
-                    storage.setTodoList(chatSessionId, todoList);
-                    return {
-                        content: [{
-                                kind: 'text',
-                                value: 'Successfully wrote todo list'
-                            }]
-                    };
-                }
-                default: {
-                    const errorResult = 'Error: Unknown operation';
-                    return {
-                        content: [{
-                                kind: 'text',
-                                value: errorResult
-                            }]
-                    };
-                }
+            const operation = this.writeOnly ? 'write' : args.operation;
+            if (!operation) {
+                return {
+                    content: [{
+                            kind: 'text',
+                            value: 'Error: operation parameter is required'
+                        }]
+                };
+            }
+            if (operation === 'read') {
+                return this.handleReadOperation(chatSessionId);
+            }
+            else if (operation === 'write') {
+                return this.handleWriteOperation(args, chatSessionId);
+            }
+            else {
+                return {
+                    content: [{
+                            kind: 'text',
+                            value: 'Error: Unknown operation'
+                        }]
+                };
             }
         }
         catch (error) {
@@ -122,14 +123,13 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
         }
     }
     async prepareToolInvocation(context, _token) {
-        if (!context.chatSessionId) {
-            throw ( new Error('chatSessionId undefined'));
-        }
-        const storage = this.chatTodoListService.getChatTodoListStorage();
-        const currentTodoItems = storage.getTodoList(context.chatSessionId);
         const args = context.parameters;
+        const DEFAULT_TODO_SESSION_ID = 'default';
+        const chatSessionId = context.chatSessionId ?? args.chatSessionId ?? DEFAULT_TODO_SESSION_ID;
+        const currentTodoItems = this.chatTodoListService.getTodos(chatSessionId);
         let message;
-        switch (args.operation) {
+        const operation = this.writeOnly ? 'write' : args.operation;
+        switch (operation) {
             case 'write': {
                 if (args.todoList) {
                     message = this.generatePastTenseMessage(currentTodoItems, args.todoList);
@@ -137,7 +137,7 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
                 break;
             }
             case 'read': {
-                message = 'Read todo list';
+                message = ( localize(5644, "Read todo list"));
                 break;
             }
         }
@@ -149,17 +149,19 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             status: todo.status
         })));
         return {
-            pastTenseMessage: ( new MarkdownString(message ?? 'Updated todo list')),
+            pastTenseMessage: ( new MarkdownString(message ?? ( localize(5645, "Updated todo list")))),
             toolSpecificData: {
                 kind: 'todoList',
-                sessionId: context.chatSessionId,
+                sessionId: chatSessionId,
                 todoList: todoList
             }
         };
     }
     generatePastTenseMessage(currentTodos, newTodos) {
         if (currentTodos.length === 0) {
-            return `Created ${newTodos.length} todo${newTodos.length === 1 ? '' : 's'}`;
+            return newTodos.length === 1
+                ? ( localize(5646, "Created 1 todo"))
+                : ( localize(5647, "Created {0} todos", newTodos.length));
         }
         const currentTodoMap = ( new Map(( currentTodos.map(todo => [todo.id, todo]))));
         const startedTodos = newTodos.filter(newTodo => {
@@ -170,7 +172,13 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             const startedTodo = startedTodos[0];
             const totalTodos = newTodos.length;
             const currentPosition = newTodos.findIndex(todo => todo.id === startedTodo.id) + 1;
-            return `Starting (${currentPosition}/${totalTodos}) *${startedTodo.title}*`;
+            return localize(
+                5648,
+                "Starting ({0}/{1}) *{2}*",
+                currentPosition,
+                totalTodos,
+                startedTodo.title
+            );
         }
         const completedTodos = newTodos.filter(newTodo => {
             const currentTodo = currentTodoMap.get(newTodo.id);
@@ -180,21 +188,95 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             const completedTodo = completedTodos[0];
             const totalTodos = newTodos.length;
             const currentPosition = newTodos.findIndex(todo => todo.id === completedTodo.id) + 1;
-            return `Completed (${currentPosition}/${totalTodos}) *${completedTodo.title}*`;
+            return localize(
+                5649,
+                "Completed ({0}/{1}) *{2}*",
+                currentPosition,
+                totalTodos,
+                completedTodo.title
+            );
         }
         const addedTodos = newTodos.filter(newTodo => !( currentTodoMap.has(newTodo.id)));
         if (addedTodos.length > 0) {
-            return `Added ${addedTodos.length} todo${addedTodos.length === 1 ? '' : 's'}`;
+            return addedTodos.length === 1
+                ? ( localize(5650, "Added 1 todo"))
+                : ( localize(5651, "Added {0} todos", addedTodos.length));
         }
-        return 'Updated todo list';
+        return localize(5652, "Updated todo list");
     }
-    handleRead(storage, sessionId) {
-        const todoItems = storage.getTodoList(sessionId);
+    handleRead(todoItems, sessionId) {
         if (todoItems.length === 0) {
             return 'No todo list found.';
         }
         const markdownTaskList = this.formatTodoListAsMarkdownTaskList(todoItems);
-        return `# Task List\n\n${markdownTaskList}`;
+        return `# Todo List\n\n${markdownTaskList}`;
+    }
+    handleReadOperation(chatSessionId) {
+        const todoItems = this.chatTodoListService.getTodos(chatSessionId);
+        const readResult = this.handleRead(todoItems, chatSessionId);
+        const statusCounts = this.calculateStatusCounts(todoItems);
+        this.telemetryService.publicLog2('todoListToolInvoked', {
+            operation: 'read',
+            notStartedCount: statusCounts.notStartedCount,
+            inProgressCount: statusCounts.inProgressCount,
+            completedCount: statusCounts.completedCount,
+            chatSessionId: chatSessionId
+        });
+        return {
+            content: [{
+                    kind: 'text',
+                    value: readResult
+                }]
+        };
+    }
+    handleWriteOperation(args, chatSessionId) {
+        if (!args.todoList) {
+            return {
+                content: [{
+                        kind: 'text',
+                        value: 'Error: todoList is required for write operation'
+                    }]
+            };
+        }
+        const todoList = ( args.todoList.map((parsedTodo) => ({
+            id: parsedTodo.id,
+            title: parsedTodo.title,
+            description: parsedTodo.description,
+            status: parsedTodo.status
+        })));
+        const existingTodos = this.chatTodoListService.getTodos(chatSessionId);
+        const changes = this.calculateTodoChanges(existingTodos, todoList);
+        this.chatTodoListService.setTodos(chatSessionId, todoList);
+        const statusCounts = this.calculateStatusCounts(todoList);
+        const warnings = [];
+        if (todoList.length < 3) {
+            warnings.push('Warning: Small todo list (<3 items). This task might not need a todo list.');
+        }
+        else if (todoList.length > 10) {
+            warnings.push('Warning: Large todo list (>10 items). Consider keeping the list focused and actionable.');
+        }
+        if (changes > 3) {
+            warnings.push('Warning: Did you mean to update so many todos at the same time? Consider working on them one by one.');
+        }
+        this.telemetryService.publicLog2('todoListToolInvoked', {
+            operation: 'write',
+            notStartedCount: statusCounts.notStartedCount,
+            inProgressCount: statusCounts.inProgressCount,
+            completedCount: statusCounts.completedCount,
+            chatSessionId: chatSessionId
+        });
+        return {
+            content: [{
+                    kind: 'text',
+                    value: `Successfully wrote todo list${warnings.length ? '\n\n' + warnings.join('\n') : ''}`
+                }]
+        };
+    }
+    calculateStatusCounts(todos) {
+        const notStartedCount = todos.filter(todo => todo.status === 'not-started').length;
+        const inProgressCount = todos.filter(todo => todo.status === 'in-progress').length;
+        const completedCount = todos.filter(todo => todo.status === 'completed').length;
+        return { notStartedCount, inProgressCount, completedCount };
     }
     formatTodoListAsMarkdownTaskList(todoList) {
         if (todoList.length === 0) {
@@ -221,10 +303,26 @@ let ManageTodoListTool = class ManageTodoListTool extends Disposable {
             return lines.join('\n');
         })).join('\n');
     }
+    calculateTodoChanges(oldList, newList) {
+        let modified = 0;
+        const minLen = Math.min(oldList.length, newList.length);
+        for (let i = 0; i < minLen; i++) {
+            const o = oldList[i];
+            const n = newList[i];
+            if (o.title !== n.title || (o.description ?? '') !== (n.description ?? '') || o.status !== n.status) {
+                modified++;
+            }
+        }
+        const added = Math.max(0, newList.length - oldList.length);
+        const removed = Math.max(0, oldList.length - newList.length);
+        const totalChanges = added + removed + modified;
+        return totalChanges;
+    }
 };
 ManageTodoListTool = ( __decorate([
-    ( __param(0, IChatTodoListService)),
-    ( __param(1, ILogService))
+    ( __param(1, IChatTodoListService)),
+    ( __param(2, ILogService)),
+    ( __param(3, ITelemetryService))
 ], ManageTodoListTool));
 
-export { ManageTodoListTool, ManageTodoListToolData, ManageTodoListToolToolId, TodoListToolSettingId };
+export { ManageTodoListTool, ManageTodoListToolToolId, TodoListToolSettingId, TodoListToolWriteOnlySettingId, createManageTodoListToolData };

package/vscode/src/vs/workbench/contrib/chat/common/tools/tools.d.ts

@@ -1,9 +1,11 @@
 import { Disposable } from "../../../../../base/common/lifecycle.js";
+import { IConfigurationService } from "../../../../../platform/configuration/common/configuration.service.js";
 import { IInstantiationService } from "../../../../../platform/instantiation/common/instantiation.js";
 import { IWorkbenchContribution } from "../../../../common/contributions.js";
 import { ILanguageModelToolsService } from "../languageModelToolsService.service.js";
 export declare class BuiltinToolsContribution extends Disposable implements IWorkbenchContribution {
+    private readonly configurationService;
     static readonly ID = "chat.builtinTools";
-    constructor(toolsService: ILanguageModelToolsService, instantiationService: IInstantiationService);
+    constructor(toolsService: ILanguageModelToolsService, instantiationService: IInstantiationService, configurationService: IConfigurationService);
 }
 export declare const InternalFetchWebPageToolId = "vscode_fetchWebPage_internal";

package/vscode/src/vs/workbench/contrib/chat/common/tools/tools.js

@@ -1,26 +1,32 @@
 
 import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
 import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.service.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
 import { ILanguageModelToolsService } from '../languageModelToolsService.service.js';
+import { ConfirmationTool, ConfirmationToolData } from './confirmationTool.js';
 import { EditTool, EditToolData } from './editFileTool.js';
-import { ManageTodoListTool, ManageTodoListToolData } from './manageTodoListTool.js';
+import { TodoListToolWriteOnlySettingId, createManageTodoListToolData, ManageTodoListTool } from './manageTodoListTool.js';
 
 let BuiltinToolsContribution = class BuiltinToolsContribution extends Disposable {
     static { this.ID = 'chat.builtinTools'; }
-    constructor(toolsService, instantiationService) {
+    constructor(toolsService, instantiationService, configurationService) {
         super();
+        this.configurationService = configurationService;
         const editTool = instantiationService.createInstance(EditTool);
-        this._register(toolsService.registerToolData(EditToolData));
-        this._register(toolsService.registerToolImplementation(EditToolData.id, editTool));
-        const manageTodoListTool = instantiationService.createInstance(ManageTodoListTool);
-        this._register(toolsService.registerToolData(ManageTodoListToolData));
-        this._register(toolsService.registerToolImplementation(ManageTodoListToolData.id, manageTodoListTool));
+        this._register(toolsService.registerTool(EditToolData, editTool));
+        const writeOnlyMode = this.configurationService.getValue(TodoListToolWriteOnlySettingId) === true;
+        const todoToolData = createManageTodoListToolData(writeOnlyMode);
+        const manageTodoListTool = instantiationService.createInstance(ManageTodoListTool, writeOnlyMode);
+        this._register(toolsService.registerTool(todoToolData, manageTodoListTool));
+        const confirmationTool = instantiationService.createInstance(ConfirmationTool);
+        this._register(toolsService.registerTool(ConfirmationToolData, confirmationTool));
     }
 };
 BuiltinToolsContribution = ( __decorate([
     ( __param(0, ILanguageModelToolsService)),
-    ( __param(1, IInstantiationService))
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IConfigurationService))
 ], BuiltinToolsContribution));
 const InternalFetchWebPageToolId = 'vscode_fetchWebPage_internal';
 

package/vscode/src/vs/workbench/contrib/codeActions/browser/codeActionsContribution.js

@@ -18,17 +18,17 @@ const createCodeActionsAutoSave = (description) => {
         enum: ['always', 'explicit', 'never', true, false],
         enumDescriptions: [
             ( localize(
-            5511,
+            5654,
             'Triggers Code Actions on explicit saves and auto saves triggered by window or focus changes.'
         )),
-            ( localize(5512, 'Triggers Code Actions only when explicitly saved')),
-            ( localize(5513, 'Never triggers Code Actions on save')),
+            ( localize(5655, 'Triggers Code Actions only when explicitly saved')),
+            ( localize(5656, 'Never triggers Code Actions on save')),
             ( localize(
-            5514,
+            5657,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
         )),
             ( localize(
-            5515,
+            5658,
             'Never triggers Code Actions on save. This value will be deprecated in favor of "never".'
         ))
         ],
@@ -41,14 +41,14 @@ const createNotebookCodeActionsAutoSave = (description) => {
         type: ['string', 'boolean'],
         enum: ['explicit', 'never', true, false],
         enumDescriptions: [
-            ( localize(5516, 'Triggers Code Actions only when explicitly saved.')),
-            ( localize(5517, 'Never triggers Code Actions on save.')),
+            ( localize(5659, 'Triggers Code Actions only when explicitly saved.')),
+            ( localize(5660, 'Never triggers Code Actions on save.')),
             ( localize(
-            5518,
+            5661,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "explicit".'
         )),
             ( localize(
-            5519,
+            5662,
             'Triggers Code Actions only when explicitly saved. This value will be deprecated in favor of "never".'
         ))
         ],
@@ -70,7 +70,7 @@ const codeActionsOnSaveSchema = {
         }
     ],
     markdownDescription: ( localize(
-        5520,
+        5663,
         'Run Code Actions for the editor on save. Code Actions must be specified and the editor must not be shutting down. When {0} is set to `afterDelay`, Code Actions will only be run when the file is saved explicitly. Example: `"source.organizeImports": "explicit" `',
         '`#files.autoSave#`'
     )),
@@ -102,7 +102,7 @@ const notebookCodeActionsOnSaveSchema = {
         }
     ],
     markdownDescription: ( localize(
-        5521,
+        5664,
         'Run a series of Code Actions for a notebook on save. Code Actions must be specified and the editor must not be shutting down. When {0} is set to `afterDelay`, Code Actions will only be run when the file is saved explicitly. Example: `"notebook.source.organizeImports": "explicit"`',
         '`#files.autoSave#`'
     )),
@@ -150,12 +150,12 @@ let CodeActionsContribution = class CodeActionsContribution extends Disposable {
         for (const codeActionKind of allProvidedKinds) {
             if (CodeActionKind.Source.contains(codeActionKind) && !properties[codeActionKind.value]) {
                 properties[codeActionKind.value] = createCodeActionsAutoSave(( localize(
-                    5522,
+                    5665,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));
                 notebookProperties[codeActionKind.value] = createNotebookCodeActionsAutoSave(( localize(
-                    5522,
+                    5665,
                     "Controls whether '{0}' actions should be run on file save.",
                     codeActionKind.value
                 )));

package/vscode/src/vs/workbench/contrib/codeEditor/browser/dictation/editorDictation.js

@@ -32,12 +32,12 @@ import { isWindows } from '../../../../../base/common/platform.js';
 var EditorDictation_1;
 registerCss(editorDictation);
 const EDITOR_DICTATION_IN_PROGRESS = ( new RawContextKey('editorDictation.inProgress', false));
-const VOICE_CATEGORY = ( localize2(5525, "Voice"));
+const VOICE_CATEGORY = ( localize2(5668, "Voice"));
 class EditorDictationStartAction extends EditorAction2 {
     constructor() {
         super({
             id: 'workbench.action.editorDictation.start',
-            title: ( localize2(5526, "Start Dictation in Editor")),
+            title: ( localize2(5669, "Start Dictation in Editor")),
             category: VOICE_CATEGORY,
             precondition: ( ContextKeyExpr.and(HasSpeechProvider, ( SpeechToTextInProgress.toNegated()), (
             EditorContextKeys.readOnly.toNegated()))),
@@ -74,7 +74,7 @@ class EditorDictationStopAction extends EditorAction2 {
     constructor() {
         super({
             id: EditorDictationStopAction.ID,
-            title: ( localize2(5527, "Stop Dictation in Editor")),
+            title: ( localize2(5670, "Stop Dictation in Editor")),
             category: VOICE_CATEGORY,
             precondition: EDITOR_DICTATION_IN_PROGRESS,
             f1: true,
@@ -99,7 +99,7 @@ class DictationWidget extends Disposable {
         const stopActionKeybinding = keybindingService.lookupKeybinding(EditorDictationStopAction.ID)?.getLabel();
         actionBar.push(toAction({
             id: EditorDictationStopAction.ID,
-            label: stopActionKeybinding ? ( localize(5528, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(5529, "Stop Dictation")),
+            label: stopActionKeybinding ? ( localize(5671, "Stop Dictation ({0})", stopActionKeybinding)) : ( localize(5672, "Stop Dictation")),
             class: ThemeIcon.asClassName(Codicon.micFilled),
             run: () => EditorDictation.get(editor)?.stop()
         }), { icon: true, label: false, keybinding: stopActionKeybinding });

package/vscode/src/vs/workbench/contrib/codeEditor/browser/diffEditorAccessibilityHelp.js

@@ -31,19 +31,19 @@ class DiffEditorAccessibilityHelp {
             return;
         }
         const switchSides = ( localize(
-            5530,
+            5673,
             "Run the command Diff Editor: Switch Side{0} to toggle between the original and modified editors.",
             '<keybinding:diffEditor.switchSide>'
         ));
         const diffEditorActiveAnnouncement = ( localize(
-            5531,
+            5674,
             "The setting, accessibility.verbosity.diffEditorActive, controls if a diff editor announcement is made when it becomes the active editor."
         ));
         const keys = ['accessibility.signals.diffLineDeleted', 'accessibility.signals.diffLineInserted', 'accessibility.signals.diffLineModified'];
         const content = [
-            ( localize(5532, "You are in a diff editor.")),
+            ( localize(5675, "You are in a diff editor.")),
             ( localize(
-            5533,
+            5676,
             "View the next{0} or previous{1} diff in diff review mode, which is optimized for screen readers.",
             '<keybinding:' + AccessibleDiffViewerNext.id + '>',
             '<keybinding:' + AccessibleDiffViewerPrev.id + '>'
@@ -51,7 +51,7 @@ class DiffEditorAccessibilityHelp {
             switchSides,
             diffEditorActiveAnnouncement,
             ( localize(
-            5534,
+            5677,
             "To control which accessibility signals should be played, the following settings can be configured: {0}.",
             keys.join(', ')
         )),

package/vscode/src/vs/workbench/contrib/codeEditor/browser/diffEditorHelper.js

@@ -32,7 +32,7 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
             const onlyWhiteSpaceChange = ( computationResult.map(r => r && !r.identical && r.changes2.length === 0));
             this._register(autorunWithStore((reader, store) => {
                 if (onlyWhiteSpaceChange.read(reader)) {
-                    const helperWidget = store.add(this._instantiationService.createInstance(FloatingEditorClickWidget, this._diffEditor.getModifiedEditor(), ( localize(5535, "Show Whitespace Differences")), null));
+                    const helperWidget = store.add(this._instantiationService.createInstance(FloatingEditorClickWidget, this._diffEditor.getModifiedEditor(), ( localize(5678, "Show Whitespace Differences")), null));
                     store.add(helperWidget.onClick(() => {
                         this._textResourceConfigurationService.updateValue(this._diffEditor.getModel().modified.uri, 'diffEditor.ignoreTrimWhitespace', false);
                     }));
@@ -43,11 +43,11 @@ let DiffEditorHelperContribution = class DiffEditorHelperContribution extends Di
                 const diffComputationResult = this._diffEditor.getDiffComputationResult();
                 if (diffComputationResult && diffComputationResult.quitEarly) {
                     this._notificationService.prompt(Severity$1.Warning, ( localize(
-                        5536,
+                        5679,
                         "The diff algorithm was stopped early (after {0} ms.)",
                         this._diffEditor.maxComputationTime
                     )), [{
-                            label: ( localize(5537, "Remove Limit")),
+                            label: ( localize(5680, "Remove Limit")),
                             run: () => {
                                 this._textResourceConfigurationService.updateValue(this._diffEditor.getModel().modified.uri, 'diffEditor.maxComputationTime', 0);
                             }

package/vscode/src/vs/workbench/contrib/codeEditor/browser/largeFileOptimizations.js

@@ -26,16 +26,16 @@ let LargeFileOptimizationsWarner = class LargeFileOptimizationsWarner extends Di
         }
         if (model.isTooLargeForTokenization()) {
             const message = ( localize(
-                5556,
+                5699,
                 "{0}: tokenization, wrapping, folding, codelens, word highlighting and sticky scroll have been turned off for this large file in order to reduce memory usage and avoid freezing or crashing.",
                 basename(model.uri.path)
             ));
             this._notificationService.prompt(Severity$1.Info, message, [
                 {
-                    label: ( localize(5557, "Forcefully Enable Features")),
+                    label: ( localize(5700, "Forcefully Enable Features")),
                     run: () => {
                         this._configurationService.updateValue(`editor.largeFileOptimizations`, false).then(() => {
-                            this._notificationService.info(( localize(5558, "Please reopen file in order for this setting to take effect.")));
+                            this._notificationService.info(( localize(5701, "Please reopen file in order for this setting to take effect.")));
                         }, (err) => {
                             this._notificationService.error(err);
                         });