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

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

@@ -2,443 +2,35 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 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 { 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, ChatConfiguration, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { 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';
+import { ChatRequestDynamicVariablePart, ChatRequestSlashCommandPart, ChatRequestAgentSubcommandPart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/requestParser/chatParserTypes';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { TipEligibilityTracker } from './chatTipEligibilityTracker.js';
+import { TIP_CATALOG, ChatTipTier, extractCommandIds } from './chatTipCatalog.js';
+import { TipTrackingCommands, ChatTipStorageKeys } from './chatTipStorageKeys.js';
 
-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(
-        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"],
-    excludeWhenModesUsed: [ChatModeKind.Agent]
-}, {
-    id: "tip.planMode",
-    message: ( localize(
-        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"],
-    excludeWhenCommandsExecuted: ["workbench.action.chat.openPlan"],
-    excludeWhenModesUsed: ["Plan"]
-}, {
-    id: "tip.attachFiles",
-    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(
-        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(
-        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: ( ChatContextKeys.chatModeKind.isEqualTo(ChatModeKind.Agent)),
-    excludeWhenCommandsExecuted: [
-        "workbench.action.chat.queueMessage",
-        "workbench.action.chat.steerWithMessage"
-    ]
-}, {
-    id: "tip.yoloMode",
-    message: ( localize(
-        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."
-    )),
-    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 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));
+const CREATE_AGENT_INSTRUCTIONS_TRACKING_COMMAND = TipTrackingCommands.CreateAgentInstructionsUsed;
+const CREATE_PROMPT_TRACKING_COMMAND = TipTrackingCommands.CreatePromptUsed;
+const CREATE_AGENT_TRACKING_COMMAND = TipTrackingCommands.CreateAgentUsed;
+const CREATE_SKILL_TRACKING_COMMAND = TipTrackingCommands.CreateSkillUsed;
+const FORK_CONVERSATION_TRACKING_COMMAND = TipTrackingCommands.ForkConversationUsed;
 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,
@@ -448,7 +40,8 @@ let ChatTipService = class ChatTipService extends Disposable {
         _logService,
         _chatEntitlementService,
         _commandService,
-        _telemetryService
+        _telemetryService,
+        _keybindingService
     ) {
         super();
         this._productService = _productService;
@@ -459,6 +52,7 @@ let ChatTipService = class ChatTipService extends Disposable {
         this._chatEntitlementService = _chatEntitlementService;
         this._commandService = _commandService;
         this._telemetryService = _telemetryService;
+        this._keybindingService = _keybindingService;
         this._onDidDismissTip = this._register(( new Emitter()));
         this.onDidDismissTip = this._onDidDismissTip.event;
         this._onDidNavigateTip = this._register(( new Emitter()));
@@ -467,6 +61,7 @@ let ChatTipService = class ChatTipService extends Disposable {
         this.onDidHideTip = this._onDidHideTip.event;
         this._onDidDisableTips = this._register(( new Emitter()));
         this.onDidDisableTips = this._onDidDisableTips.event;
+        this._tipsHiddenForSession = false;
         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)));
@@ -481,49 +76,23 @@ let ChatTipService = class ChatTipService extends Disposable {
                 return;
             }
             if (this._hasFileOrFolderReference(message)) {
-                this._tracker.recordCommandExecuted(ATTACH_FILES_REFERENCE_TRACKING_COMMAND);
+                this._tracker.recordCommandExecuted(TipTrackingCommands.AttachFilesReferenceUsed);
             }
-            const createCommandTrackingId = this._getCreateSlashCommandTrackingId(message);
-            if (createCommandTrackingId) {
-                this._tracker.recordCommandExecuted(createCommandTrackingId);
+            const slashCommandTrackingId = this._getSlashCommandTrackingId(message);
+            if (slashCommandTrackingId) {
+                this._tracker.recordCommandExecuted(slashCommandTrackingId);
             }
+            this._hideShownTipIfNowIneligible();
         }));
-        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,
+            ChatTipStorageKeys.ThinkingPhrasesEverModified,
             StorageScope.APPLICATION,
             false
         );
         if (!this._thinkingPhrasesEverModified && this._isSettingModified(ChatConfiguration.ThinkingPhrases)) {
             this._thinkingPhrasesEverModified = true;
             this._storageService.store(
-                ChatTipService_1._THINKING_PHRASES_EVER_MODIFIED_KEY,
+                ChatTipStorageKeys.ThinkingPhrasesEverModified,
                 true,
                 StorageScope.APPLICATION,
                 StorageTarget.MACHINE
@@ -534,7 +103,7 @@ let ChatTipService = class ChatTipService extends Disposable {
                 if (e.affectsConfiguration(ChatConfiguration.ThinkingPhrases)) {
                     this._thinkingPhrasesEverModified = true;
                     this._storageService.store(
-                        ChatTipService_1._THINKING_PHRASES_EVER_MODIFIED_KEY,
+                        ChatTipStorageKeys.ThinkingPhrasesEverModified,
                         true,
                         StorageScope.APPLICATION,
                         StorageTarget.MACHINE
@@ -552,19 +121,24 @@ let ChatTipService = class ChatTipService extends Disposable {
             return dynamicPart.isFile === true || dynamicPart.isDirectory === true;
         }));
     }
-    _getCreateSlashCommandTrackingId(message) {
+    _getSlashCommandTrackingId(message) {
         for (const part of message.parts) {
             if (part.kind === ChatRequestSlashCommandPart.Kind) {
                 const slashCommand = part.slashCommand.command;
-                return this._toCreateSlashCommandTrackingId(slashCommand);
+                return this._toSlashCommandTrackingId(slashCommand);
+            }
+            if (part.kind === ChatRequestAgentSubcommandPart.Kind) {
+                const subCommand = part.command.name;
+                return this._toSlashCommandTrackingId(subCommand);
             }
         }
         const trimmed = message.text.trimStart();
-        const match = /^\/(create-(?:instructions|prompt|agent|skill))(?:\s|$)/.exec(trimmed);
-        return match ? this._toCreateSlashCommandTrackingId(match[1]) : undefined;
+        const match = /^(?:@\S+\s+)?\/(init|create-(?:instructions|prompt|agent|skill)|fork)(?:\s|$)/.exec(trimmed);
+        return match ? this._toSlashCommandTrackingId(match[1]) : undefined;
     }
-    _toCreateSlashCommandTrackingId(command) {
+    _toSlashCommandTrackingId(command) {
         switch (command) {
+        case "init":
         case "create-instructions":
             return CREATE_AGENT_INSTRUCTIONS_TRACKING_COMMAND;
         case "create-prompt":
@@ -573,14 +147,25 @@ let ChatTipService = class ChatTipService extends Disposable {
             return CREATE_AGENT_TRACKING_COMMAND;
         case "create-skill":
             return CREATE_SKILL_TRACKING_COMMAND;
+        case "fork":
+            return FORK_CONVERSATION_TRACKING_COMMAND;
         default:
             return undefined;
         }
     }
+    recordSlashCommandUsage(command) {
+        const trackingId = this._toSlashCommandTrackingId(command);
+        if (!trackingId) {
+            return;
+        }
+        this._tracker.recordCommandExecuted(trackingId);
+        this._hideShownTipIfNowIneligible();
+    }
     resetSession() {
         this._shownTip = undefined;
         this._tipRequestId = undefined;
         this._contextKeyService = undefined;
+        this._tipsHiddenForSession = false;
     }
     dismissTip() {
         if (this._shownTip) {
@@ -588,7 +173,7 @@ let ChatTipService = class ChatTipService extends Disposable {
             const dismissed = ( new Set(this._getDismissedTipIds()));
             dismissed.add(this._shownTip.id);
             this._storageService.store(
-                ChatTipService_1._DISMISSED_TIP_KEY,
+                ChatTipStorageKeys.DismissedTips,
                 JSON.stringify([...dismissed]),
                 StorageScope.APPLICATION,
                 StorageTarget.MACHINE
@@ -597,16 +182,21 @@ let ChatTipService = class ChatTipService extends Disposable {
         this._tipRequestId = undefined;
         this._onDidDismissTip.fire();
     }
+    dismissTipForSession() {
+        this.dismissTip();
+        this.hideTipsForSession();
+    }
     clearDismissedTips() {
-        this._storageService.remove(ChatTipService_1._DISMISSED_TIP_KEY, StorageScope.APPLICATION);
-        this._storageService.remove(ChatTipService_1._DISMISSED_TIP_KEY, StorageScope.PROFILE);
+        this._storageService.remove(ChatTipStorageKeys.DismissedTips, StorageScope.APPLICATION);
+        this._storageService.remove(ChatTipStorageKeys.DismissedTips, StorageScope.PROFILE);
         this._shownTip = undefined;
         this._tipRequestId = undefined;
         this._contextKeyService = undefined;
+        this._tipsHiddenForSession = false;
         this._onDidDismissTip.fire();
     }
     _getDismissedTipIds() {
-        const raw = this._readApplicationWithProfileFallback(ChatTipService_1._DISMISSED_TIP_KEY);
+        const raw = this._readApplicationWithProfileFallback(ChatTipStorageKeys.DismissedTips);
         if (!raw) {
             return [];
         }
@@ -636,6 +226,15 @@ let ChatTipService = class ChatTipService extends Disposable {
         this._tipRequestId = undefined;
         this._onDidHideTip.fire();
     }
+    hideTipsForSession() {
+        if (this._tipsHiddenForSession) {
+            return;
+        }
+        this._tipsHiddenForSession = true;
+        this._shownTip = undefined;
+        this._tipRequestId = undefined;
+        this._onDidHideTip.fire();
+    }
     async disableTips() {
         if (this._shownTip) {
             this._logTipTelemetry(this._shownTip.id, "disabled");
@@ -652,6 +251,9 @@ let ChatTipService = class ChatTipService extends Disposable {
         if (!this._configurationService.getValue("chat.tips.enabled")) {
             return undefined;
         }
+        if (this._tipsHiddenForSession) {
+            return undefined;
+        }
         this._contextKeyService = contextKeyService;
         if (!this._isCopilotEnabled()) {
             return undefined;
@@ -662,16 +264,44 @@ let ChatTipService = class ChatTipService extends Disposable {
         if (!this._isChatLocation(contextKeyService)) {
             return undefined;
         }
+        const foregroundSessionCount = contextKeyService.getContextKeyValue(ChatContextKeys.foregroundSessionCount.key);
+        if (foregroundSessionCount !== 1) {
+            return undefined;
+        }
         if (this._isChatQuotaExceeded(contextKeyService)) {
             return undefined;
         }
         if (this._tipRequestId === "welcome" && this._shownTip) {
+            if (this._shownTip.id !== "tip.switchToAuto") {
+                const switchToAutoTip = TIP_CATALOG.find(tip => tip.id === "tip.switchToAuto");
+                if (switchToAutoTip) {
+                    const dismissedIds = ( new Set(this._getDismissedTipIds()));
+                    if (!( dismissedIds.has(switchToAutoTip.id)) && this._isEligible(switchToAutoTip, contextKeyService)) {
+                        this._shownTip = switchToAutoTip;
+                        this._storageService.store(
+                            ChatTipStorageKeys.LastTipId,
+                            switchToAutoTip.id,
+                            StorageScope.APPLICATION,
+                            StorageTarget.USER
+                        );
+                        const tip = this._createTip(switchToAutoTip);
+                        this._logTipTelemetry(switchToAutoTip.id, "shown");
+                        this._trackTipCommandClicks(switchToAutoTip);
+                        this._onDidNavigateTip.fire(tip);
+                        return tip;
+                    }
+                }
+            }
             if (!this._isEligible(this._shownTip, contextKeyService)) {
+                if (this._tracker.isExcluded(this._shownTip)) {
+                    this.hideTip();
+                    return undefined;
+                }
                 const nextTip = this._findNextEligibleTip(this._shownTip.id, contextKeyService);
                 if (nextTip) {
                     this._shownTip = nextTip;
                     this._storageService.store(
-                        ChatTipService_1._LAST_TIP_ID_KEY,
+                        ChatTipStorageKeys.LastTipId,
                         nextTip.id,
                         StorageScope.APPLICATION,
                         StorageTarget.USER
@@ -680,6 +310,8 @@ let ChatTipService = class ChatTipService extends Disposable {
                     this._onDidNavigateTip.fire(tip);
                     return tip;
                 }
+                this.hideTip();
+                return undefined;
             }
             return this._createTip(this._shownTip);
         }
@@ -702,27 +334,29 @@ let ChatTipService = class ChatTipService extends Disposable {
         }
         return undefined;
     }
+    _hideShownTipIfNowIneligible() {
+        if (!this._shownTip || !this._contextKeyService) {
+            return;
+        }
+        if (this._tipsHiddenForSession) {
+            return;
+        }
+        if (this._isEligible(this._shownTip, this._contextKeyService)) {
+            return;
+        }
+        this.hideTip();
+    }
     _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;
-            }
-        }
+        const eligibleTips = TIP_CATALOG.filter(tip => !( dismissedIds.has(tip.id)) && this._isEligible(tip, contextKeyService));
+        const selectedTip = this._selectTipByTier(eligibleTips);
         if (!selectedTip) {
             return undefined;
         }
         this._storageService.store(
-            ChatTipService_1._LAST_TIP_ID_KEY,
+            ChatTipStorageKeys.LastTipId,
             selectedTip.id,
             StorageScope.APPLICATION,
             StorageTarget.USER
@@ -733,6 +367,18 @@ let ChatTipService = class ChatTipService extends Disposable {
         this._trackTipCommandClicks(selectedTip);
         return this._createTip(selectedTip);
     }
+    _selectTipByTier(eligibleTips) {
+        const foundationalTips = eligibleTips.filter(tip => tip.tier === ChatTipTier.Foundational);
+        if (foundationalTips.length) {
+            return this._sortByPriorityAndCatalogOrder(foundationalTips)[0];
+        }
+        const qolTips = eligibleTips.filter(tip => tip.tier === ChatTipTier.Qol);
+        if (!qolTips.length) {
+            return undefined;
+        }
+        const randomIndex = Math.floor(Math.random() * qolTips.length);
+        return qolTips[randomIndex];
+    }
     navigateToNextTip() {
         if (!this._contextKeyService) {
             return undefined;
@@ -745,6 +391,51 @@ let ChatTipService = class ChatTipService extends Disposable {
         }
         return this._navigateTip(-1, this._contextKeyService);
     }
+    getNextEligibleTip() {
+        if (!this._contextKeyService || !this._shownTip) {
+            return undefined;
+        }
+        const contextKeyService = this._contextKeyService;
+        this._createSlashCommandsUsageTracker.syncContextKey(contextKeyService);
+        const currentTipId = this._shownTip.id;
+        const orderedTips = this._getOrderedEligibleTips(contextKeyService, {
+            includeTipId: currentTipId
+        });
+        if (!orderedTips.length) {
+            return undefined;
+        }
+        const currentIndex = orderedTips.findIndex(tip => tip.id === currentTipId);
+        const candidate = this._getNextTipFromOrderedList(orderedTips, currentIndex, currentTipId);
+        if (candidate) {
+            this._shownTip = candidate;
+            this._tipRequestId = "welcome";
+            this._storageService.store(
+                ChatTipStorageKeys.LastTipId,
+                candidate.id,
+                StorageScope.APPLICATION,
+                StorageTarget.USER
+            );
+            this._logTipTelemetry(candidate.id, "shown");
+            this._trackTipCommandClicks(candidate);
+            return this._createTip(candidate);
+        }
+        return undefined;
+    }
+    _getNextTipFromOrderedList(orderedTips, startIndex, currentTipId) {
+        if (!orderedTips.length) {
+            return undefined;
+        }
+        const fallbackIndex = 0;
+        const normalizedStartIndex = startIndex === -1 ? fallbackIndex : startIndex;
+        for (let i = 1; i <= orderedTips.length; i++) {
+            const index = (normalizedStartIndex + i) % orderedTips.length;
+            const candidate = orderedTips[index];
+            if (candidate.id !== currentTipId) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
     hasMultipleTips() {
         if (!this._contextKeyService) {
             return false;
@@ -757,17 +448,23 @@ let ChatTipService = class ChatTipService extends Disposable {
         if (!this._shownTip) {
             return undefined;
         }
-        const currentIndex = TIP_CATALOG.findIndex(t => t.id === this._shownTip.id);
-        if (currentIndex === -1) {
+        const orderedTips = this._getOrderedEligibleTips(contextKeyService);
+        if (!orderedTips.length) {
+            return undefined;
+        }
+        const currentIndex = orderedTips.findIndex(tip => tip.id === this._shownTip.id);
+        if (orderedTips.length === 1 && currentIndex !== -1) {
             return undefined;
         }
-        const candidate = this._getNavigableTip(direction, currentIndex, contextKeyService);
+        const fallbackIndex = direction === 1 ? 0 : orderedTips.length - 1;
+        const nextIndex = currentIndex === -1 ? fallbackIndex : (currentIndex + direction + orderedTips.length) % orderedTips.length;
+        const candidate = orderedTips[nextIndex];
         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,
+                ChatTipStorageKeys.LastTipId,
                 candidate.id,
                 StorageScope.APPLICATION,
                 StorageTarget.USER
@@ -781,37 +478,44 @@ let ChatTipService = class ChatTipService extends Disposable {
         return undefined;
     }
     _hasNavigableTip(contextKeyService) {
-        if (!this._shownTip) {
+        const orderedTips = this._getOrderedEligibleTips(contextKeyService);
+        if (!orderedTips.length) {
             return false;
         }
-        const currentIndex = TIP_CATALOG.findIndex(t => t.id === this._shownTip.id);
-        if (currentIndex === -1) {
-            return false;
+        if (!this._shownTip) {
+            return orderedTips.length > 1;
+        }
+        if (orderedTips.length > 1) {
+            return true;
         }
-        return !!this._getNavigableTip(1, currentIndex, contextKeyService);
+        return orderedTips[0].id !== this._shownTip.id;
     }
-    _getNavigableTip(direction, currentIndex, contextKeyService) {
+    _getOrderedEligibleTips(contextKeyService, options) {
         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;
-                }
+        const eligibleTips = TIP_CATALOG.filter(tip => {
+            if (options?.includeTipId && tip.id === options.includeTipId) {
+                return true;
             }
-        }
-        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;
+            if (options?.excludeShownTip && this._shownTip && tip.id === this._shownTip.id) {
+                return false;
             }
-        }
-        return undefined;
+            return !( dismissedIds.has(tip.id)) && this._isEligible(tip, contextKeyService);
+        });
+        const foundationalTips = this._sortByPriorityAndCatalogOrder(eligibleTips.filter(tip => tip.tier === ChatTipTier.Foundational));
+        const qolTips = this._sortByPriorityAndCatalogOrder(eligibleTips.filter(tip => tip.tier === ChatTipTier.Qol));
+        return [...foundationalTips, ...qolTips];
+    }
+    _sortByPriorityAndCatalogOrder(tips) {
+        return [...tips].sort((a, b) => {
+            const aPriority = a.priority ?? Number.POSITIVE_INFINITY;
+            const bPriority = b.priority ?? Number.POSITIVE_INFINITY;
+            if (aPriority !== bPriority) {
+                return aPriority - bPriority;
+            }
+            const aCatalogIndex = TIP_CATALOG.findIndex(tip => tip.id === a.id);
+            const bCatalogIndex = TIP_CATALOG.findIndex(tip => tip.id === b.id);
+            return aCatalogIndex - bCatalogIndex;
+        });
     }
     _isEligible(tip, contextKeyService) {
         if (tip.onlyWhenModelIds?.length) {
@@ -842,17 +546,6 @@ let ChatTipService = class ChatTipService extends Disposable {
         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;
-            }
-        }
         if (tip.id === "tip.thinkingPhrases" && this._thinkingPhrasesEverModified) {
             this._logService.debug(
                 "#ChatTips: tip excluded because thinking phrases setting was previously modified",
@@ -909,15 +602,21 @@ let ChatTipService = class ChatTipService extends Disposable {
         return !!defaultChatAgent?.chatExtensionId;
     }
     _createTip(tipDef) {
-        const markdown = ( new MarkdownString(tipDef.message, {
-            isTrusted: tipDef.enabledCommands ? {
-                enabledCommands: tipDef.enabledCommands
+        const ctx = {
+            keybindingService: this._keybindingService
+        };
+        const rawMessage = tipDef.buildMessage(ctx);
+        const prefixedMessage = ( localize(6232, "**Tip:** {0}", rawMessage.value));
+        const enabledCommands = extractCommandIds(prefixedMessage);
+        const markdown = ( new MarkdownString(prefixedMessage, {
+            isTrusted: enabledCommands.length > 0 ? {
+                enabledCommands
             } : false
         }));
         return {
             id: tipDef.id,
             content: markdown,
-            enabledCommands: tipDef.enabledCommands
+            enabledCommands
         };
     }
     _logTipTelemetry(tipId, action, commandId) {
@@ -929,10 +628,15 @@ let ChatTipService = class ChatTipService extends Disposable {
     }
     _trackTipCommandClicks(tip) {
         this._tipCommandListener.clear();
-        if (!tip.enabledCommands?.length) {
+        const ctx = {
+            keybindingService: this._keybindingService
+        };
+        const rawMessage = tip.buildMessage(ctx);
+        const enabledCommands = extractCommandIds(rawMessage.value);
+        if (!enabledCommands.length) {
             return;
         }
-        const enabledCommandSet = ( new Set(tip.enabledCommands));
+        const enabledCommandSet = ( new Set(enabledCommands));
         const dismissCommandSet = ( new Set(tip.dismissWhenCommandsClicked));
         this._tipCommandListener.value = this._commandService.onDidExecuteCommand(e => {
             if (( enabledCommandSet.has(e.commandId)) && this._shownTip?.id === tip.id) {
@@ -940,6 +644,7 @@ let ChatTipService = class ChatTipService extends Disposable {
                 if (( dismissCommandSet.has(e.commandId))) {
                     this.dismissTip();
                 }
+                this.hideTipsForSession();
             }
         });
     }
@@ -955,6 +660,6 @@ let ChatTipService = class ChatTipService extends Disposable {
         return profileValue;
     }
 };
-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));
+ChatTipService = ( __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)), ( __param(9, IKeybindingService))], 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 };
+export { CREATE_AGENT_INSTRUCTIONS_TRACKING_COMMAND, CREATE_AGENT_TRACKING_COMMAND, CREATE_PROMPT_TRACKING_COMMAND, CREATE_SKILL_TRACKING_COMMAND, ChatTipService, FORK_CONVERSATION_TRACKING_COMMAND, TipEligibilityTracker, TipTrackingCommands };