@codingame/monaco-vscode-chat-service-override 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatTipService.js

@@ -1,92 +1,908 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
 import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IProductService } from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service';
 import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
-import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatModeKind, ChatConfiguration, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ConfigurationTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { localChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { CreateSlashCommandsUsageTracker } from './createSlashCommandsUsageTracker.js';
+import { ChatEntitlement } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { ChatRequestDynamicVariablePart, ChatRequestSlashCommandPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
+import { GENERATE_ON_DEMAND_INSTRUCTIONS_COMMAND_ID, GENERATE_PROMPT_COMMAND_ID, GENERATE_AGENT_COMMAND_ID, GENERATE_SKILL_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
 
+var TipEligibilityTracker_1, ChatTipService_1;
+const ATTACH_FILES_REFERENCE_TRACKING_COMMAND = "chat.tips.attachFiles.referenceUsed";
+const CREATE_AGENT_INSTRUCTIONS_TRACKING_COMMAND = "chat.tips.createAgentInstructions.commandUsed";
+const CREATE_PROMPT_TRACKING_COMMAND = "chat.tips.createPrompt.commandUsed";
+const CREATE_AGENT_TRACKING_COMMAND = "chat.tips.createAgent.commandUsed";
+const CREATE_SKILL_TRACKING_COMMAND = "chat.tips.createSkill.commandUsed";
 const TIP_CATALOG = [{
+    id: "tip.switchToAuto",
+    message: ( localize(
+        6146,
+        "Tip: Using gpt-4.1? Try switching to [Auto](command:workbench.action.chat.openModelPicker) in the model picker for better coding performance."
+    )),
+    enabledCommands: ["workbench.action.chat.openModelPicker"],
+    onlyWhenModelIds: ["gpt-4.1"]
+}, {
+    id: "tip.createInstruction",
+    message: ( localize(
+        6147,
+        "Tip: Use [/create-instructions](command:{0}) to generate an on-demand instructions file with the agent.",
+        GENERATE_ON_DEMAND_INSTRUCTIONS_COMMAND_ID
+    )),
+    when: ( ChatContextKeys.chatSessionType.isEqualTo(localChatSessionType)),
+    enabledCommands: [GENERATE_ON_DEMAND_INSTRUCTIONS_COMMAND_ID],
+    excludeWhenCommandsExecuted: [
+        GENERATE_ON_DEMAND_INSTRUCTIONS_COMMAND_ID,
+        CREATE_AGENT_INSTRUCTIONS_TRACKING_COMMAND
+    ]
+}, {
+    id: "tip.createPrompt",
+    message: ( localize(
+        6148,
+        "Tip: Use [/create-prompt](command:{0}) to generate a reusable prompt file with the agent.",
+        GENERATE_PROMPT_COMMAND_ID
+    )),
+    when: ( ChatContextKeys.chatSessionType.isEqualTo(localChatSessionType)),
+    enabledCommands: [GENERATE_PROMPT_COMMAND_ID],
+    excludeWhenCommandsExecuted: [GENERATE_PROMPT_COMMAND_ID, CREATE_PROMPT_TRACKING_COMMAND]
+}, {
+    id: "tip.createAgent",
+    message: ( localize(
+        6149,
+        "Tip: Use [/create-agent](command:{0}) to scaffold a custom agent for your workflow.",
+        GENERATE_AGENT_COMMAND_ID
+    )),
+    when: ( ChatContextKeys.chatSessionType.isEqualTo(localChatSessionType)),
+    enabledCommands: [GENERATE_AGENT_COMMAND_ID],
+    excludeWhenCommandsExecuted: [GENERATE_AGENT_COMMAND_ID, CREATE_AGENT_TRACKING_COMMAND]
+}, {
+    id: "tip.createSkill",
+    message: ( localize(
+        6150,
+        "Tip: Use [/create-skill](command:{0}) to create a skill the agent can load when relevant.",
+        GENERATE_SKILL_COMMAND_ID
+    )),
+    when: ( ChatContextKeys.chatSessionType.isEqualTo(localChatSessionType)),
+    enabledCommands: [GENERATE_SKILL_COMMAND_ID],
+    excludeWhenCommandsExecuted: [GENERATE_SKILL_COMMAND_ID, CREATE_SKILL_TRACKING_COMMAND]
+}, {
     id: "tip.agentMode",
     message: ( localize(
-        5676,
-        "Tip: Try [Agent mode](command:workbench.action.chat.openEditSession) for multi-file edits and running commands."
+        6151,
+        "Tip: Try [Agents](command:workbench.action.chat.openEditSession) to make edits across your project and run commands."
     )),
     when: ( ChatContextKeys.chatModeKind.notEqualsTo(ChatModeKind.Agent)),
-    enabledCommands: ["workbench.action.chat.openEditSession"]
+    enabledCommands: ["workbench.action.chat.openEditSession"],
+    excludeWhenModesUsed: [ChatModeKind.Agent]
 }, {
     id: "tip.planMode",
     message: ( localize(
-        5677,
-        "Tip: Try [Plan mode](command:workbench.action.chat.openPlan) to let the agent perform deep analysis and planning before implementing changes."
+        6152,
+        "Tip: Try the [Plan agent](command:workbench.action.chat.openPlan) to research and plan before implementing changes."
     )),
     when: ( ChatContextKeys.chatModeName.notEqualsTo("Plan")),
-    enabledCommands: ["workbench.action.chat.openPlan"]
+    enabledCommands: ["workbench.action.chat.openPlan"],
+    excludeWhenCommandsExecuted: ["workbench.action.chat.openPlan"],
+    excludeWhenModesUsed: ["Plan"]
 }, {
     id: "tip.attachFiles",
-    message: ( localize(5678, "Tip: Attach files or folders with # to give Copilot more context."))
+    message: ( localize(
+        6153,
+        "Tip: Reference files or folders with # to give the agent more context about the task."
+    )),
+    excludeWhenCommandsExecuted: [
+        "workbench.action.chat.attachContext",
+        "workbench.action.chat.attachFile",
+        "workbench.action.chat.attachFolder",
+        "workbench.action.chat.attachSelection",
+        ATTACH_FILES_REFERENCE_TRACKING_COMMAND
+    ]
 }, {
     id: "tip.codeActions",
     message: ( localize(
-        5679,
-        "Tip: Select code and right-click for Copilot actions in the context menu."
-    ))
+        6154,
+        "Tip: Select a code block in the editor and right-click to access more AI actions."
+    )),
+    excludeWhenCommandsExecuted: ["inlineChat.start"]
 }, {
     id: "tip.undoChanges",
     message: ( localize(
-        5680,
-        "Tip: You can undo Copilot's changes to any point by clicking Restore Checkpoint."
+        6155,
+        "Tip: Select \"Restore Checkpoint\" to undo changes after that point in the chat conversation."
+    )),
+    when: ( ContextKeyExpr.and(( ChatContextKeys.chatSessionType.isEqualTo(localChatSessionType)), ( ContextKeyExpr.or(( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)), ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Edit)))))),
+    excludeWhenCommandsExecuted: [
+        "workbench.action.chat.restoreCheckpoint",
+        "workbench.action.chat.restoreLastCheckpoint"
+    ]
+}, {
+    id: "tip.messageQueueing",
+    message: ( localize(
+        6156,
+        "Tip: Steer the agent mid-task by sending follow-up messages. They queue and apply in order."
     )),
-    when: ( ContextKeyExpr.or(( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)), ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Edit))))
+    when: ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)),
+    excludeWhenCommandsExecuted: [
+        "workbench.action.chat.queueMessage",
+        "workbench.action.chat.steerWithMessage"
+    ]
 }, {
-    id: "tip.customInstructions",
+    id: "tip.yoloMode",
     message: ( localize(
-        5681,
-        "Tip: [Generate workspace instructions](command:workbench.action.chat.generateInstructions) so Copilot always has the context it needs when starting a task."
+        6157,
+        "Tip: Enable [auto approve](command:workbench.action.openSettings?%5B%22chat.tools.global.autoApprove%22%5D) to give the agent full control without manual confirmation."
     )),
-    enabledCommands: ["workbench.action.chat.generateInstructions"]
+    when: ( ContextKeyExpr.and(( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)), ( ContextKeyExpr.notEquals("config.chat.tools.global.autoApprove", true)))),
+    enabledCommands: ["workbench.action.openSettings"],
+    excludeWhenSettingsChanged: [ChatConfiguration.GlobalAutoApprove],
+    dismissWhenCommandsClicked: ["workbench.action.openSettings"]
+}, {
+    id: "tip.agenticBrowser",
+    message: ( localize(
+        6158,
+        "Tip: Enable [agentic browser integration](command:workbench.action.openSettings?%5B%22workbench.browser.enableChatTools%22%5D) to let the agent open and interact with pages in the Integrated Browser."
+    )),
+    when: ( ContextKeyExpr.and(( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)), ( ContextKeyExpr.notEquals("config.workbench.browser.enableChatTools", true)))),
+    enabledCommands: ["workbench.action.openSettings"],
+    excludeWhenSettingsChanged: ["workbench.browser.enableChatTools"],
+    dismissWhenCommandsClicked: ["workbench.action.openSettings"]
+}, {
+    id: "tip.mermaid",
+    message: ( localize(
+        6159,
+        "Tip: Ask the agent to draw an architectural diagram or flow chart; it can render Mermaid diagrams directly in chat."
+    )),
+    when: ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)),
+    excludeWhenToolsInvoked: ["renderMermaidDiagram"]
+}, {
+    id: "tip.subagents",
+    message: ( localize(
+        6160,
+        "Tip: Ask the agent to work in parallel to complete large tasks faster."
+    )),
+    when: ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)),
+    excludeWhenToolsInvoked: ["runSubagent"]
+}, {
+    id: "tip.thinkingPhrases",
+    message: ( localize(
+        6161,
+        "Tip: Customize the loading messages shown while the agent works with [thinking phrases](command:workbench.action.openSettings?%5B%22chat.agent.thinking.phrases%22%5D)."
+    )),
+    when: ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)),
+    enabledCommands: ["workbench.action.openSettings"],
+    excludeWhenSettingsChanged: ["chat.agent.thinking.phrases"],
+    dismissWhenCommandsClicked: ["workbench.action.openSettings"]
 }];
-let ChatTipService = class ChatTipService {
-    constructor(_productService, _configurationService) {
+let TipEligibilityTracker = class TipEligibilityTracker extends Disposable {
+    static {
+        TipEligibilityTracker_1 = this;
+    }
+    static {
+        this._COMMANDS_STORAGE_KEY = "chat.tips.executedCommands";
+    }
+    static {
+        this._MODES_STORAGE_KEY = "chat.tips.usedModes";
+    }
+    static {
+        this._TOOLS_STORAGE_KEY = "chat.tips.invokedTools";
+    }
+    constructor(
+        tips,
+        commandService,
+        _storageService,
+        _promptsService,
+        _languageModelToolsService,
+        _logService
+    ) {
+        super();
+        this._storageService = _storageService;
+        this._promptsService = _promptsService;
+        this._languageModelToolsService = _languageModelToolsService;
+        this._logService = _logService;
+        this._commandListener = this._register(( new MutableDisposable()));
+        this._toolListener = this._register(( new MutableDisposable()));
+        this._excludedByFiles = ( new Set());
+        this._fileCheckGeneration = ( new Map());
+        this._fileChecksInFlight = ( new Map());
+        const storedCmds = this._readApplicationWithProfileFallback(TipEligibilityTracker_1._COMMANDS_STORAGE_KEY);
+        this._executedCommands = ( new Set(storedCmds ? JSON.parse(storedCmds) : []));
+        const storedModes = this._readApplicationWithProfileFallback(TipEligibilityTracker_1._MODES_STORAGE_KEY);
+        this._usedModes = ( new Set(storedModes ? JSON.parse(storedModes) : []));
+        const storedTools = this._readApplicationWithProfileFallback(TipEligibilityTracker_1._TOOLS_STORAGE_KEY);
+        this._invokedTools = ( new Set(storedTools ? JSON.parse(storedTools) : []));
+        this._pendingCommands = ( new Set());
+        for (const tip of tips) {
+            for (const cmd of tip.excludeWhenCommandsExecuted ?? []) {
+                if (!( this._executedCommands.has(cmd))) {
+                    this._pendingCommands.add(cmd);
+                }
+            }
+        }
+        this._pendingModes = ( new Set());
+        for (const tip of tips) {
+            for (const mode of tip.excludeWhenModesUsed ?? []) {
+                if (!( this._usedModes.has(mode))) {
+                    this._pendingModes.add(mode);
+                }
+            }
+        }
+        this._pendingTools = ( new Set());
+        for (const tip of tips) {
+            for (const toolId of tip.excludeWhenToolsInvoked ?? []) {
+                if (!( this._invokedTools.has(toolId))) {
+                    this._pendingTools.add(toolId);
+                }
+            }
+        }
+        if (this._pendingCommands.size > 0) {
+            this._commandListener.value = commandService.onDidExecuteCommand(e => {
+                this.recordCommandExecuted(e.commandId);
+            });
+        }
+        if (this._pendingTools.size > 0) {
+            this._toolListener.value = this._languageModelToolsService.onDidInvokeTool(e => {
+                if (( this._pendingTools.has(e.toolId))) {
+                    this._invokedTools.add(e.toolId);
+                    this._pendingTools.delete(e.toolId);
+                    this._persistSet(TipEligibilityTracker_1._TOOLS_STORAGE_KEY, this._invokedTools);
+                }
+                if (this._pendingTools.size === 0) {
+                    this._toolListener.clear();
+                }
+            });
+        }
+        this._tipsWithFileExclusions = tips.filter(t => t.excludeWhenPromptFilesExist);
+        for (const tip of this._tipsWithFileExclusions) {
+            if (tip.excludeWhenPromptFilesExist.excludeUntilChecked) {
+                this._excludedByFiles.add(tip.id);
+            }
+            this._checkForPromptFiles(tip);
+        }
+        this._register(this._promptsService.onDidChangeCustomAgents(() => {
+            for (const tip of this._tipsWithFileExclusions) {
+                if (tip.excludeWhenPromptFilesExist.promptType === PromptsType.agent) {
+                    this._checkForPromptFiles(tip);
+                }
+            }
+        }));
+    }
+    recordCommandExecuted(commandId) {
+        if (!( this._pendingCommands.has(commandId))) {
+            return;
+        }
+        this._executedCommands.add(commandId);
+        this._persistSet(TipEligibilityTracker_1._COMMANDS_STORAGE_KEY, this._executedCommands);
+        this._pendingCommands.delete(commandId);
+        if (this._pendingCommands.size === 0) {
+            this._commandListener.clear();
+        }
+    }
+    recordCurrentMode(contextKeyService) {
+        if (this._pendingModes.size === 0) {
+            return;
+        }
+        let changed = false;
+        const kind = contextKeyService.getContextKeyValue(ChatContextKeys.chatModeKind.key);
+        if (kind && !( this._usedModes.has(kind))) {
+            this._usedModes.add(kind);
+            this._pendingModes.delete(kind);
+            changed = true;
+        }
+        const name = contextKeyService.getContextKeyValue(ChatContextKeys.chatModeName.key);
+        if (name && !( this._usedModes.has(name))) {
+            this._usedModes.add(name);
+            this._pendingModes.delete(name);
+            changed = true;
+        }
+        if (changed) {
+            this._persistSet(TipEligibilityTracker_1._MODES_STORAGE_KEY, this._usedModes);
+        }
+    }
+    isExcluded(tip) {
+        if (tip.excludeWhenCommandsExecuted) {
+            for (const cmd of tip.excludeWhenCommandsExecuted) {
+                if (( this._executedCommands.has(cmd))) {
+                    this._logService.debug("#ChatTips: tip excluded because command was executed", tip.id, cmd);
+                    return true;
+                }
+            }
+        }
+        if (tip.excludeWhenModesUsed) {
+            for (const mode of tip.excludeWhenModesUsed) {
+                if (( this._usedModes.has(mode))) {
+                    this._logService.debug("#ChatTips: tip excluded because mode was used", tip.id, mode);
+                    return true;
+                }
+            }
+        }
+        if (tip.excludeWhenToolsInvoked) {
+            for (const toolId of tip.excludeWhenToolsInvoked) {
+                if (( this._invokedTools.has(toolId))) {
+                    this._logService.debug("#ChatTips: tip excluded because tool was invoked", tip.id, toolId);
+                    return true;
+                }
+            }
+        }
+        if (tip.excludeWhenPromptFilesExist && ( this._excludedByFiles.has(tip.id))) {
+            this._logService.debug("#ChatTips: tip excluded because prompt files exist", tip.id);
+            return true;
+        }
+        return false;
+    }
+    refreshPromptFileExclusions() {
+        for (const tip of this._tipsWithFileExclusions) {
+            if (tip.excludeWhenPromptFilesExist.excludeUntilChecked) {
+                this._excludedByFiles.add(tip.id);
+            }
+            this._checkForPromptFiles(tip);
+        }
+    }
+    async _checkForPromptFiles(tip) {
+        const inFlight = this._fileChecksInFlight.get(tip.id);
+        if (inFlight) {
+            await inFlight;
+            return;
+        }
+        const checkPromise = this._doCheckForPromptFiles(tip);
+        this._fileChecksInFlight.set(tip.id, checkPromise);
+        try {
+            await checkPromise;
+        } finally {
+            if (this._fileChecksInFlight.get(tip.id) === checkPromise) {
+                this._fileChecksInFlight.delete(tip.id);
+            }
+        }
+    }
+    async _doCheckForPromptFiles(tip) {
+        const config = tip.excludeWhenPromptFilesExist;
+        const generation = (this._fileCheckGeneration.get(tip.id) ?? 0) + 1;
+        this._fileCheckGeneration.set(tip.id, generation);
+        try {
+            const [promptFiles, agentInstructions] = await Promise.all([
+                this._promptsService.listPromptFiles(config.promptType, CancellationToken.None),
+                config.agentFileType ? this._promptsService.listAgentInstructions(CancellationToken.None) : Promise.resolve([])
+            ]);
+            if (this._fileCheckGeneration.get(tip.id) !== generation) {
+                return;
+            }
+            const hasPromptFiles = promptFiles.length > 0;
+            const hasAgentFile = config.agentFileType ? ( agentInstructions.some(f => f.type === config.agentFileType)) : false;
+            const hasPromptFilesOrAgentFile = hasPromptFiles || hasAgentFile;
+            if (hasPromptFilesOrAgentFile) {
+                this._excludedByFiles.add(tip.id);
+            } else {
+                this._excludedByFiles.delete(tip.id);
+            }
+        } catch {
+            if (this._fileCheckGeneration.get(tip.id) !== generation) {
+                return;
+            }
+            if (config.excludeUntilChecked) {
+                this._excludedByFiles.add(tip.id);
+            }
+        }
+    }
+    _persistSet(key, set) {
+        this._storageService.store(
+            key,
+            JSON.stringify([...set]),
+            StorageScope.APPLICATION,
+            StorageTarget.MACHINE
+        );
+    }
+    _readApplicationWithProfileFallback(key) {
+        const applicationValue = this._storageService.get(key, StorageScope.APPLICATION);
+        if (applicationValue) {
+            return applicationValue;
+        }
+        const profileValue = this._storageService.get(key, StorageScope.PROFILE);
+        if (profileValue) {
+            this._storageService.store(key, profileValue, StorageScope.APPLICATION, StorageTarget.MACHINE);
+        }
+        return profileValue;
+    }
+};
+TipEligibilityTracker = TipEligibilityTracker_1 = ( __decorate([( __param(1, ICommandService)), ( __param(2, IStorageService)), ( __param(3, IPromptsService)), ( __param(4, ILanguageModelToolsService)), ( __param(5, ILogService))], TipEligibilityTracker));
+let ChatTipService = class ChatTipService extends Disposable {
+    static {
+        ChatTipService_1 = this;
+    }
+    static {
+        this._DISMISSED_TIP_KEY = "chat.tip.dismissed";
+    }
+    static {
+        this._LAST_TIP_ID_KEY = "chat.tip.lastTipId";
+    }
+    static {
+        this._YOLO_EVER_ENABLED_KEY = "chat.tip.yoloModeEverEnabled";
+    }
+    static {
+        this._THINKING_PHRASES_EVER_MODIFIED_KEY = "chat.tip.thinkingPhrasesEverModified";
+    }
+    constructor(
+        _productService,
+        _configurationService,
+        _storageService,
+        _chatService,
+        instantiationService,
+        _logService,
+        _chatEntitlementService,
+        _commandService,
+        _telemetryService
+    ) {
+        super();
         this._productService = _productService;
         this._configurationService = _configurationService;
-        this._createdAt = Date.now();
-        this._hasShownTip = false;
+        this._storageService = _storageService;
+        this._chatService = _chatService;
+        this._logService = _logService;
+        this._chatEntitlementService = _chatEntitlementService;
+        this._commandService = _commandService;
+        this._telemetryService = _telemetryService;
+        this._onDidDismissTip = this._register(( new Emitter()));
+        this.onDidDismissTip = this._onDidDismissTip.event;
+        this._onDidNavigateTip = this._register(( new Emitter()));
+        this.onDidNavigateTip = this._onDidNavigateTip.event;
+        this._onDidHideTip = this._register(( new Emitter()));
+        this.onDidHideTip = this._onDidHideTip.event;
+        this._onDidDisableTips = this._register(( new Emitter()));
+        this.onDidDisableTips = this._onDidDisableTips.event;
+        this._tipCommandListener = this._register(( new MutableDisposable()));
+        this._tracker = this._register(instantiationService.createInstance(TipEligibilityTracker, TIP_CATALOG));
+        this._createSlashCommandsUsageTracker = this._register(( new CreateSlashCommandsUsageTracker(this._chatService, this._storageService, () => this._contextKeyService)));
+        this._register(this._chatEntitlementService.onDidChangeQuotaExceeded(() => {
+            if (this._chatEntitlementService.quotas.chat?.percentRemaining === 0 && this._shownTip) {
+                this.hideTip();
+            }
+        }));
+        this._register(this._chatService.onDidSubmitRequest(e => {
+            const message = e.message ?? this._chatService.getSession(e.chatSessionResource)?.lastRequest?.message;
+            if (!message) {
+                return;
+            }
+            if (this._hasFileOrFolderReference(message)) {
+                this._tracker.recordCommandExecuted(ATTACH_FILES_REFERENCE_TRACKING_COMMAND);
+            }
+            const createCommandTrackingId = this._getCreateSlashCommandTrackingId(message);
+            if (createCommandTrackingId) {
+                this._tracker.recordCommandExecuted(createCommandTrackingId);
+            }
+        }));
+        this._yoloModeEverEnabled = this._storageService.getBoolean(ChatTipService_1._YOLO_EVER_ENABLED_KEY, StorageScope.APPLICATION, false);
+        if (!this._yoloModeEverEnabled && this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove)) {
+            this._yoloModeEverEnabled = true;
+            this._storageService.store(
+                ChatTipService_1._YOLO_EVER_ENABLED_KEY,
+                true,
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+        }
+        if (!this._yoloModeEverEnabled) {
+            const configListener = this._register(( new MutableDisposable()));
+            configListener.value = this._configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration(ChatConfiguration.GlobalAutoApprove)) {
+                    if (this._configurationService.getValue(ChatConfiguration.GlobalAutoApprove)) {
+                        this._yoloModeEverEnabled = true;
+                        this._storageService.store(
+                            ChatTipService_1._YOLO_EVER_ENABLED_KEY,
+                            true,
+                            StorageScope.APPLICATION,
+                            StorageTarget.MACHINE
+                        );
+                        configListener.clear();
+                    }
+                }
+            });
+        }
+        this._thinkingPhrasesEverModified = this._storageService.getBoolean(
+            ChatTipService_1._THINKING_PHRASES_EVER_MODIFIED_KEY,
+            StorageScope.APPLICATION,
+            false
+        );
+        if (!this._thinkingPhrasesEverModified && this._isSettingModified(ChatConfiguration.ThinkingPhrases)) {
+            this._thinkingPhrasesEverModified = true;
+            this._storageService.store(
+                ChatTipService_1._THINKING_PHRASES_EVER_MODIFIED_KEY,
+                true,
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+        }
+        if (!this._thinkingPhrasesEverModified) {
+            this._register(this._configurationService.onDidChangeConfiguration(e => {
+                if (e.affectsConfiguration(ChatConfiguration.ThinkingPhrases)) {
+                    this._thinkingPhrasesEverModified = true;
+                    this._storageService.store(
+                        ChatTipService_1._THINKING_PHRASES_EVER_MODIFIED_KEY,
+                        true,
+                        StorageScope.APPLICATION,
+                        StorageTarget.MACHINE
+                    );
+                }
+            }));
+        }
+    }
+    _hasFileOrFolderReference(message) {
+        return ( message.parts.some(part => {
+            if (part.kind !== ChatRequestDynamicVariablePart.Kind) {
+                return false;
+            }
+            const dynamicPart = part;
+            return dynamicPart.isFile === true || dynamicPart.isDirectory === true;
+        }));
     }
-    getNextTip(requestId, requestTimestamp, contextKeyService) {
+    _getCreateSlashCommandTrackingId(message) {
+        for (const part of message.parts) {
+            if (part.kind === ChatRequestSlashCommandPart.Kind) {
+                const slashCommand = part.slashCommand.command;
+                return this._toCreateSlashCommandTrackingId(slashCommand);
+            }
+        }
+        const trimmed = message.text.trimStart();
+        const match = /^\/(create-(?:instructions|prompt|agent|skill))(?:\s|$)/.exec(trimmed);
+        return match ? this._toCreateSlashCommandTrackingId(match[1]) : undefined;
+    }
+    _toCreateSlashCommandTrackingId(command) {
+        switch (command) {
+        case "create-instructions":
+            return CREATE_AGENT_INSTRUCTIONS_TRACKING_COMMAND;
+        case "create-prompt":
+            return CREATE_PROMPT_TRACKING_COMMAND;
+        case "create-agent":
+            return CREATE_AGENT_TRACKING_COMMAND;
+        case "create-skill":
+            return CREATE_SKILL_TRACKING_COMMAND;
+        default:
+            return undefined;
+        }
+    }
+    resetSession() {
+        this._shownTip = undefined;
+        this._tipRequestId = undefined;
+        this._contextKeyService = undefined;
+    }
+    dismissTip() {
+        if (this._shownTip) {
+            this._logTipTelemetry(this._shownTip.id, "dismissed");
+            const dismissed = ( new Set(this._getDismissedTipIds()));
+            dismissed.add(this._shownTip.id);
+            this._storageService.store(
+                ChatTipService_1._DISMISSED_TIP_KEY,
+                JSON.stringify([...dismissed]),
+                StorageScope.APPLICATION,
+                StorageTarget.MACHINE
+            );
+        }
+        this._tipRequestId = undefined;
+        this._onDidDismissTip.fire();
+    }
+    clearDismissedTips() {
+        this._storageService.remove(ChatTipService_1._DISMISSED_TIP_KEY, StorageScope.APPLICATION);
+        this._storageService.remove(ChatTipService_1._DISMISSED_TIP_KEY, StorageScope.PROFILE);
+        this._shownTip = undefined;
+        this._tipRequestId = undefined;
+        this._contextKeyService = undefined;
+        this._onDidDismissTip.fire();
+    }
+    _getDismissedTipIds() {
+        const raw = this._readApplicationWithProfileFallback(ChatTipService_1._DISMISSED_TIP_KEY);
+        if (!raw) {
+            return [];
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            this._logService.debug("#ChatTips dismissed:", parsed);
+            if (!Array.isArray(parsed)) {
+                return [];
+            }
+            const knownTipIds = ( new Set(( TIP_CATALOG.map(tip => tip.id))));
+            const dismissed = ( new Set());
+            for (const value of parsed) {
+                if (typeof value === "string" && ( knownTipIds.has(value))) {
+                    dismissed.add(value);
+                }
+            }
+            return [...dismissed];
+        } catch {
+            return [];
+        }
+    }
+    hideTip() {
+        if (this._shownTip) {
+            this._logTipTelemetry(this._shownTip.id, "hidden");
+        }
+        this._shownTip = undefined;
+        this._tipRequestId = undefined;
+        this._onDidHideTip.fire();
+    }
+    async disableTips() {
+        if (this._shownTip) {
+            this._logTipTelemetry(this._shownTip.id, "disabled");
+        }
+        this._shownTip = undefined;
+        this._tipRequestId = undefined;
+        await this._configurationService.updateValue("chat.tips.enabled", false, ConfigurationTarget.APPLICATION);
+        this._onDidDisableTips.fire();
+    }
+    getWelcomeTip(contextKeyService) {
+        this._createSlashCommandsUsageTracker.syncContextKey(contextKeyService);
+        this._tracker.recordCurrentMode(contextKeyService);
+        this._tracker.refreshPromptFileExclusions();
         if (!this._configurationService.getValue("chat.tips.enabled")) {
             return undefined;
         }
+        this._contextKeyService = contextKeyService;
         if (!this._isCopilotEnabled()) {
             return undefined;
         }
-        if (this._tipRequestId === requestId && this._shownTip) {
-            return this._createTip(this._shownTip);
+        if (this._chatEntitlementService.entitlement === ChatEntitlement.Unknown) {
+            return undefined;
         }
-        if (this._hasShownTip) {
+        if (!this._isChatLocation(contextKeyService)) {
             return undefined;
         }
-        if (requestTimestamp < this._createdAt) {
+        if (this._isChatQuotaExceeded(contextKeyService)) {
             return undefined;
         }
-        const eligibleTips = TIP_CATALOG.filter(tip => this._isEligible(tip, contextKeyService));
-        if (eligibleTips.length === 0) {
+        if (this._tipRequestId === "welcome" && this._shownTip) {
+            if (!this._isEligible(this._shownTip, contextKeyService)) {
+                const nextTip = this._findNextEligibleTip(this._shownTip.id, contextKeyService);
+                if (nextTip) {
+                    this._shownTip = nextTip;
+                    this._storageService.store(
+                        ChatTipService_1._LAST_TIP_ID_KEY,
+                        nextTip.id,
+                        StorageScope.APPLICATION,
+                        StorageTarget.USER
+                    );
+                    const tip = this._createTip(nextTip);
+                    this._onDidNavigateTip.fire(tip);
+                    return tip;
+                }
+            }
+            return this._createTip(this._shownTip);
+        }
+        const tip = this._pickTip("welcome", contextKeyService);
+        return tip;
+    }
+    _findNextEligibleTip(currentTipId, contextKeyService) {
+        this._createSlashCommandsUsageTracker.syncContextKey(contextKeyService);
+        const currentIndex = TIP_CATALOG.findIndex(tip => tip.id === currentTipId);
+        if (currentIndex === -1) {
             return undefined;
         }
-        const randomIndex = Math.floor(Math.random() * eligibleTips.length);
-        const selectedTip = eligibleTips[randomIndex];
-        this._hasShownTip = true;
-        this._tipRequestId = requestId;
+        const dismissedIds = ( new Set(this._getDismissedTipIds()));
+        for (let i = 1; i < TIP_CATALOG.length; i++) {
+            const idx = (currentIndex + i) % TIP_CATALOG.length;
+            const candidate = TIP_CATALOG[idx];
+            if (!( dismissedIds.has(candidate.id)) && this._isEligible(candidate, contextKeyService)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    _pickTip(sourceId, contextKeyService) {
+        this._createSlashCommandsUsageTracker.syncContextKey(contextKeyService);
+        this._tracker.recordCurrentMode(contextKeyService);
+        const dismissedIds = ( new Set(this._getDismissedTipIds()));
+        let selectedTip;
+        const lastTipId = this._readApplicationWithProfileFallback(ChatTipService_1._LAST_TIP_ID_KEY);
+        const lastCatalogIndex = lastTipId ? TIP_CATALOG.findIndex(tip => tip.id === lastTipId) : -1;
+        const startIndex = lastCatalogIndex === -1 ? 0 : (lastCatalogIndex + 1) % TIP_CATALOG.length;
+        for (let i = 0; i < TIP_CATALOG.length; i++) {
+            const idx = (startIndex + i) % TIP_CATALOG.length;
+            const candidate = TIP_CATALOG[idx];
+            if (!( dismissedIds.has(candidate.id)) && this._isEligible(candidate, contextKeyService)) {
+                selectedTip = candidate;
+                break;
+            }
+        }
+        if (!selectedTip) {
+            return undefined;
+        }
+        this._storageService.store(
+            ChatTipService_1._LAST_TIP_ID_KEY,
+            selectedTip.id,
+            StorageScope.APPLICATION,
+            StorageTarget.USER
+        );
+        this._tipRequestId = sourceId;
         this._shownTip = selectedTip;
+        this._logTipTelemetry(selectedTip.id, "shown");
+        this._trackTipCommandClicks(selectedTip);
         return this._createTip(selectedTip);
     }
+    navigateToNextTip() {
+        if (!this._contextKeyService) {
+            return undefined;
+        }
+        return this._navigateTip(1, this._contextKeyService);
+    }
+    navigateToPreviousTip() {
+        if (!this._contextKeyService) {
+            return undefined;
+        }
+        return this._navigateTip(-1, this._contextKeyService);
+    }
+    hasMultipleTips() {
+        if (!this._contextKeyService) {
+            return false;
+        }
+        this._createSlashCommandsUsageTracker.syncContextKey(this._contextKeyService);
+        return this._hasNavigableTip(this._contextKeyService);
+    }
+    _navigateTip(direction, contextKeyService) {
+        this._createSlashCommandsUsageTracker.syncContextKey(contextKeyService);
+        if (!this._shownTip) {
+            return undefined;
+        }
+        const currentIndex = TIP_CATALOG.findIndex(t => t.id === this._shownTip.id);
+        if (currentIndex === -1) {
+            return undefined;
+        }
+        const candidate = this._getNavigableTip(direction, currentIndex, contextKeyService);
+        if (candidate) {
+            this._logTipTelemetry(this._shownTip.id, direction === 1 ? "navigateNext" : "navigatePrevious");
+            this._shownTip = candidate;
+            this._tipRequestId = "welcome";
+            this._storageService.store(
+                ChatTipService_1._LAST_TIP_ID_KEY,
+                candidate.id,
+                StorageScope.APPLICATION,
+                StorageTarget.USER
+            );
+            this._logTipTelemetry(candidate.id, "shown");
+            this._trackTipCommandClicks(candidate);
+            const tip = this._createTip(candidate);
+            this._onDidNavigateTip.fire(tip);
+            return tip;
+        }
+        return undefined;
+    }
+    _hasNavigableTip(contextKeyService) {
+        if (!this._shownTip) {
+            return false;
+        }
+        const currentIndex = TIP_CATALOG.findIndex(t => t.id === this._shownTip.id);
+        if (currentIndex === -1) {
+            return false;
+        }
+        return !!this._getNavigableTip(1, currentIndex, contextKeyService);
+    }
+    _getNavigableTip(direction, currentIndex, contextKeyService) {
+        const dismissedIds = ( new Set(this._getDismissedTipIds()));
+        let eligibleTipCount = 0;
+        for (const tip of TIP_CATALOG) {
+            if (!( dismissedIds.has(tip.id)) && this._isEligible(tip, contextKeyService)) {
+                eligibleTipCount++;
+                if (eligibleTipCount > 1) {
+                    break;
+                }
+            }
+        }
+        if (eligibleTipCount <= 1) {
+            return undefined;
+        }
+        for (let i = 1; i < TIP_CATALOG.length; i++) {
+            const idx = ((currentIndex + direction * i) % TIP_CATALOG.length + TIP_CATALOG.length) % TIP_CATALOG.length;
+            const candidate = TIP_CATALOG[idx];
+            if (!( dismissedIds.has(candidate.id)) && this._isEligible(candidate, contextKeyService)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
     _isEligible(tip, contextKeyService) {
-        if (!tip.when) {
-            return true;
+        if (tip.onlyWhenModelIds?.length) {
+            const currentModelId = this._getCurrentChatModelId(contextKeyService);
+            const isModelMatch = ( tip.onlyWhenModelIds.some(
+                modelId => currentModelId === modelId || currentModelId.startsWith(`${modelId}-`)
+            ));
+            if (!isModelMatch) {
+                return false;
+            }
+        }
+        if (tip.excludeWhenSettingsChanged?.some(setting => this._isSettingModified(setting))) {
+            this._logService.debug(
+                "#ChatTips: tip excluded because setting was modified",
+                tip.id,
+                tip.excludeWhenSettingsChanged
+            );
+            return false;
+        }
+        if (tip.when && !contextKeyService.contextMatchesRules(tip.when)) {
+            this._logService.debug(
+                "#ChatTips: tip is not eligible due to when clause",
+                tip.id,
+                tip.when.serialize()
+            );
+            return false;
+        }
+        if (this._tracker.isExcluded(tip)) {
+            return false;
+        }
+        if (tip.id === "tip.yoloMode") {
+            if (this._yoloModeEverEnabled) {
+                this._logService.debug("#ChatTips: tip excluded because yolo mode was previously enabled", tip.id);
+                return false;
+            }
+            const inspected = this._configurationService.inspect(ChatConfiguration.GlobalAutoApprove);
+            if (inspected.policyValue === false) {
+                this._logService.debug("#ChatTips: tip excluded because policy restricts auto-approve", tip.id);
+                return false;
+            }
         }
-        return contextKeyService.contextMatchesRules(tip.when);
+        if (tip.id === "tip.thinkingPhrases" && this._thinkingPhrasesEverModified) {
+            this._logService.debug(
+                "#ChatTips: tip excluded because thinking phrases setting was previously modified",
+                tip.id
+            );
+            return false;
+        }
+        this._logService.debug("#ChatTips: tip is eligible", tip.id);
+        return true;
+    }
+    _isSettingModified(key) {
+        const inspected = this._configurationService.inspect(key);
+        return inspected.userValue !== undefined || inspected.userLocalValue !== undefined || inspected.userRemoteValue !== undefined || inspected.workspaceValue !== undefined || inspected.workspaceFolderValue !== undefined;
+    }
+    _getCurrentChatModelId(contextKeyService) {
+        const normalize = modelId => {
+            const normalizedModelId = modelId?.toLowerCase() ?? "";
+            if (!normalizedModelId) {
+                return "";
+            }
+            if (normalizedModelId.includes("/")) {
+                return normalizedModelId.split("/").at(-1) ?? "";
+            }
+            return normalizedModelId;
+        };
+        const contextKeyModelId = normalize(contextKeyService.getContextKeyValue(ChatContextKeys.chatModelId.key));
+        if (contextKeyModelId) {
+            return contextKeyModelId;
+        }
+        const location = contextKeyService.getContextKeyValue(ChatContextKeys.location.key) ?? ChatAgentLocation.Chat;
+        const sessionType = contextKeyService.getContextKeyValue(ChatContextKeys.chatSessionType.key) ?? "";
+        const candidateStorageKeys = sessionType ? [
+            `chat.currentLanguageModel.${location}.${sessionType}`,
+            `chat.currentLanguageModel.${location}`
+        ] : [`chat.currentLanguageModel.${location}`];
+        for (const storageKey of candidateStorageKeys) {
+            const persistedModelIdentifier = this._storageService.get(storageKey, StorageScope.APPLICATION);
+            const persistedModelId = normalize(persistedModelIdentifier);
+            if (persistedModelId) {
+                return persistedModelId;
+            }
+        }
+        return "";
+    }
+    _isChatLocation(contextKeyService) {
+        const location = contextKeyService.getContextKeyValue(ChatContextKeys.location.key);
+        return !location || location === ChatAgentLocation.Chat;
+    }
+    _isChatQuotaExceeded(contextKeyService) {
+        return contextKeyService.getContextKeyValue(ChatContextKeys.chatQuotaExceeded.key) === true;
     }
     _isCopilotEnabled() {
         const defaultChatAgent = this._productService.defaultChatAgent;
@@ -100,10 +916,45 @@ let ChatTipService = class ChatTipService {
         }));
         return {
             id: tipDef.id,
-            content: markdown
+            content: markdown,
+            enabledCommands: tipDef.enabledCommands
         };
     }
+    _logTipTelemetry(tipId, action, commandId) {
+        this._telemetryService.publicLog2("chatTip", {
+            tipId,
+            action,
+            commandId
+        });
+    }
+    _trackTipCommandClicks(tip) {
+        this._tipCommandListener.clear();
+        if (!tip.enabledCommands?.length) {
+            return;
+        }
+        const enabledCommandSet = ( new Set(tip.enabledCommands));
+        const dismissCommandSet = ( new Set(tip.dismissWhenCommandsClicked));
+        this._tipCommandListener.value = this._commandService.onDidExecuteCommand(e => {
+            if (( enabledCommandSet.has(e.commandId)) && this._shownTip?.id === tip.id) {
+                this._logTipTelemetry(tip.id, "commandClicked", e.commandId);
+                if (( dismissCommandSet.has(e.commandId))) {
+                    this.dismissTip();
+                }
+            }
+        });
+    }
+    _readApplicationWithProfileFallback(key) {
+        const applicationValue = this._storageService.get(key, StorageScope.APPLICATION);
+        if (applicationValue) {
+            return applicationValue;
+        }
+        const profileValue = this._storageService.get(key, StorageScope.PROFILE);
+        if (profileValue) {
+            this._storageService.store(key, profileValue, StorageScope.APPLICATION, StorageTarget.MACHINE);
+        }
+        return profileValue;
+    }
 };
-ChatTipService = ( __decorate([( __param(0, IProductService)), ( __param(1, IConfigurationService))], ChatTipService));
+ChatTipService = ChatTipService_1 = ( __decorate([( __param(0, IProductService)), ( __param(1, IConfigurationService)), ( __param(2, IStorageService)), ( __param(3, IChatService)), ( __param(4, IInstantiationService)), ( __param(5, ILogService)), ( __param(6, IChatEntitlementService)), ( __param(7, ICommandService)), ( __param(8, ITelemetryService))], ChatTipService));
 
-export { ChatTipService };
+export { ATTACH_FILES_REFERENCE_TRACKING_COMMAND, CREATE_AGENT_INSTRUCTIONS_TRACKING_COMMAND, CREATE_AGENT_TRACKING_COMMAND, CREATE_PROMPT_TRACKING_COMMAND, CREATE_SKILL_TRACKING_COMMAND, ChatTipService, TipEligibilityTracker };