@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/openSessionLinkOpener.contribution.js

@@ -0,0 +1,205 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { structuralEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { tildify } from '@codingame/monaco-vscode-api/vscode/vs/base/common/labels';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
+import { LOCAL_AGENT_HOST_SCHEME_PREFIX } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService';
+import { AGENT_HOST_SESSION_LINK_SCHEME, AGENT_HOST_SESSION_LINK_PATTERN, parseOpenSessionLinkUri, buildAgentSessionLinkPresentation } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/openSessionLink';
+import { ILinkPresentationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/common/dataChannel.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
+import { IChatRequestOriginService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatRequestOrigin.service';
+import { ChatSessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { ChatViewPaneTarget } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { getAgentChangesSummary } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { ISessionSummaryHoverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/sessionSummaryHoverService.service';
+import { observableValueOpts } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValueOpts';
+import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
+
+let AgentHostOpenSessionLinkOpenerContribution = class AgentHostOpenSessionLinkOpenerContribution extends Disposable {
+    static {
+        this.ID = "workbench.chat.agentHostOpenSessionLinkOpener";
+    }
+    constructor(
+        openerService,
+        _chatWidgetService,
+        _chatSessionsService,
+        requestOriginService,
+        linkPresentationService,
+        logService,
+        sessionSummaryHoverService,
+        pathService
+    ) {
+        super();
+        this._chatWidgetService = _chatWidgetService;
+        this._chatSessionsService = _chatSessionsService;
+        this._register(openerService.registerOpener({
+            open: async resource => this._open(resource)
+        }));
+        this._register(requestOriginService.registerOpener({
+            open: async origin => origin.sourceSessionResource.scheme === AGENT_HOST_SESSION_LINK_SCHEME ? this._open(origin.sourceSessionResource) : false
+        }));
+        this._register(linkPresentationService.registerLinkPresentationProvider({
+            id: "workbench.agentSessionLinkPresentation",
+            uriPattern: AGENT_HOST_SESSION_LINK_PATTERN,
+            kind: "session"
+        }, {
+            createLinkPresentationWatcher: resource => {
+                const clientResource = toClientSessionResource(resource);
+                if (!clientResource) {
+                    throw ( new Error(`Invalid agent session link: ${( resource.toString(true))}`));
+                }
+                return ( new WorkbenchAgentSessionLinkPresentationWatcher(clientResource, this._chatSessionsService, logService));
+            }
+        }));
+        this._register(sessionSummaryHoverService.registerProvider({
+            provideSessionSummaryHoverData: async (resource, token) => {
+                const item = await this._findChatSessionItem(resource, token);
+                return item ? toSessionSummaryHoverData(item, pathService.userHome({
+                    preferLocal: true
+                }).fsPath) : undefined;
+            }
+        }));
+    }
+    async _findChatSessionItem(resource, token) {
+        const clientResource = toClientSessionResource(resource);
+        if (!clientResource) {
+            return undefined;
+        }
+        const chatSessionType = getChatSessionType(clientResource);
+        await this._chatSessionsService.activateChatSessionItemProvider(chatSessionType);
+        return findChatSessionItem(this._chatSessionsService, chatSessionType, clientResource, token);
+    }
+    async _open(resource) {
+        const clientResource = toClientSessionResource(resource);
+        if (!clientResource) {
+            return false;
+        }
+        await this._chatSessionsService.activateChatSessionItemProvider(getChatSessionType(clientResource));
+        const widget = await this._chatWidgetService.openSession(clientResource, ChatViewPaneTarget, {
+            revealIfOpened: true
+        });
+        return !!widget;
+    }
+};
+AgentHostOpenSessionLinkOpenerContribution = ( __decorate([( __param(0, IOpenerService)), ( __param(1, IChatWidgetService)), ( __param(2, IChatSessionsService)), ( __param(3, IChatRequestOriginService)), ( __param(4, ILinkPresentationService)), ( __param(5, ILogService)), ( __param(6, ISessionSummaryHoverService)), ( __param(7, IPathService))], AgentHostOpenSessionLinkOpenerContribution));
+class WorkbenchAgentSessionLinkPresentationWatcher extends Disposable {
+    constructor(clientResource, _chatSessionsService, _logService) {
+        super();
+        this._chatSessionsService = _chatSessionsService;
+        this._logService = _logService;
+        this._data = observableValueOpts({
+            owner: this,
+            equalsFn: structuralEquals
+        }, undefined);
+        this.presentation = this._data;
+        this._clientResource = clientResource;
+        this._chatSessionType = getChatSessionType(this._clientResource);
+        this._providerReady = this._chatSessionsService.activateChatSessionItemProvider(this._chatSessionType);
+        this._register(Event.any(
+            this._chatSessionsService.onDidChangeAvailability,
+            this._chatSessionsService.onDidChangeInProgress,
+            this._chatSessionsService.onDidChangeItemsProviders,
+            this._chatSessionsService.onDidChangeSessionItems
+        )(() => this._refresh()));
+        this._refresh();
+    }
+    dispose() {
+        this._refreshCancellation?.cancel();
+        this._refreshCancellation?.dispose();
+        this._refreshCancellation = undefined;
+        super.dispose();
+    }
+    _refresh() {
+        this._refreshCancellation?.cancel();
+        this._refreshCancellation?.dispose();
+        const cancellation = ( new CancellationTokenSource());
+        this._refreshCancellation = cancellation;
+        void this._resolve(cancellation.token).then(data => {
+            if (!cancellation.token.isCancellationRequested && this._refreshCancellation === cancellation) {
+                this._data.set(data, undefined);
+            }
+        }, error => {
+            if (!isCancellationError(error) && !cancellation.token.isCancellationRequested) {
+                this._logService.error("Failed to refresh agent session link presentation", error);
+            }
+        });
+    }
+    async _resolve(token) {
+        await this._providerReady;
+        const item = await findChatSessionItem(
+            this._chatSessionsService,
+            this._chatSessionType,
+            this._clientResource,
+            token
+        );
+        return item ? toSessionLinkPresentation(item) : undefined;
+    }
+}
+async function findChatSessionItem(chatSessionsService, chatSessionType, clientResource, token) {
+    for await (const group of chatSessionsService.getChatSessionItems([chatSessionType], token)) {
+        const item = group.items.find(
+            candidate => isEqual(candidate.resource, clientResource) || !!candidate.legacyResource && isEqual(candidate.legacyResource, clientResource)
+        );
+        if (item) {
+            return item;
+        }
+    }
+    return undefined;
+}
+function toClientSessionResource(resource) {
+    const backendSession = parseOpenSessionLinkUri(resource);
+    if (!backendSession) {
+        return undefined;
+    }
+    const provider = AgentSession.provider(backendSession);
+    const rawId = AgentSession.id(backendSession);
+    return provider && rawId ? ( URI.from({
+        scheme: `${LOCAL_AGENT_HOST_SCHEME_PREFIX}${provider}`,
+        path: `/${rawId}`
+    })) : undefined;
+}
+function toSessionLinkPresentation(item) {
+    const description = typeof item.description === "string" ? item.description : item.description?.value;
+    return buildAgentSessionLinkPresentation(item.label, description, chatSessionStatusName(item.status));
+}
+function toSessionSummaryHoverData(item, userHome) {
+    const metadata = item.metadata;
+    const changes = getAgentChangesSummary(item.changes);
+    const workspace = metadata?.repositoryPath ?? metadata?.workingDirectoryPath;
+    return {
+        title: item.label,
+        location: {
+            workspace: workspace ? tildify(workspace, userHome) : undefined,
+            worktree: metadata?.worktreePath ? tildify(metadata.worktreePath, userHome) : undefined,
+            branch: metadata?.branchName ?? metadata?.branch,
+            changes: changes && (changes.insertions > 0 || changes.deletions > 0) ? changes : undefined
+        }
+    };
+}
+function chatSessionStatusName(status) {
+    switch (status) {
+    case ChatSessionStatus.Failed:
+        return "error";
+    case ChatSessionStatus.InProgress:
+        return "inProgress";
+    case ChatSessionStatus.NeedsInput:
+        return "needsInput";
+    case ChatSessionStatus.Completed:
+    case undefined:
+        return "completed";
+    }
+}
+
+export { AgentHostOpenSessionLinkOpenerContribution };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/syncedCustomizationBundler.d.ts

@@ -1,15 +1,45 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IMcpServerConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
 import { PromptsType } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
+import { AICustomizationSource } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService";
 import { type ClientPluginCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { type CustomizationEnablement } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
 import { SYNCED_CUSTOMIZATION_SCHEME } from "../../../../../services/agentHost/common/agentHostFileSystemService.js";
 import { IAgentHostFileSystemService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/common/agentHostFileSystemService.service";
 export { SYNCED_CUSTOMIZATION_SCHEME };
-interface ISyncableFile {
+export interface ISyncableFile {
     readonly uri: URI;
     readonly type: PromptsType;
+    /**
+     * Where this file originally came from (extension, plugin, built-in, ...).
+     * Optional because it is only used to populate the provenance reverse map;
+     * files without it simply have no recoverable {@link ISyncedCustomizationOrigin}.
+     */
+    readonly source?: AICustomizationSource;
+    /** Identifier of the contributing extension, when {@link source} is `extension`. */
+    readonly extensionId?: string;
+    /** Root URI of the contributing plugin, when {@link source} is `plugin`. */
+    readonly pluginUri?: URI;
+}
+/**
+ * Describes where a file bundled into the synthetic plugin originally came
+ * from. The bundle flattens files from many different sources (extensions,
+ * plugins, built-ins) into a single in-memory plugin, which erases their
+ * provenance. {@link SyncedCustomizationBundler.getOrigin} lets consumers
+ * recover it by mapping a synced (destination) URI back to this record.
+ */
+export interface ISyncedCustomizationOrigin {
+    /** The original local file URI before it was copied into the synthetic bundle. */
+    readonly uri: URI;
+    /** Where the file originally came from (extension, plugin, built-in, ...). */
+    readonly source: AICustomizationSource;
+    /** Identifier of the contributing extension, when {@link source} is `extension`. */
+    readonly extensionId?: string;
+    /** Root URI of the contributing plugin, when {@link source} is `plugin`. */
+    readonly pluginUri?: URI;
 }
 /**
  * An MCP server configured directly in VS Code (i.e. not contributed by an
@@ -19,6 +49,8 @@ interface ISyncableFile {
 export interface ISyncableMcpServer {
     readonly name: string;
     readonly configuration: IMcpServerConfiguration;
+    readonly defaultCwd?: URI;
+    readonly enablement: readonly CustomizationEnablement[];
 }
 interface IBundleResult {
     readonly ref: ClientPluginCustomization;
@@ -28,7 +60,8 @@ interface IBundleResult {
  * backed by an in-memory filesystem.
  *
  * Each bundler instance is namespaced by its authority string so that
- * multiple agents can coexist under the same scheme without conflicts.
+ * multiple agent workspace scopes can coexist under the same scheme without
+ * conflicts.
  * The plugin is mounted at `vscode-synced-customization:///{authority}/`
  * and structured as:
  *
@@ -38,36 +71,52 @@ interface IBundleResult {
  * rules/          ← instruction files
  * commands/       ← prompt files
  * agents/         ← agent files
- * skills/         ← skill files
+ * skills/         ← skill directories
  * ```
  *
- * The bundler computes a content-based nonce so the agent host can
+ * The bundler computes a metadata-based nonce so the agent host can
  * skip re-loading when nothing has changed.
  */
 export declare class SyncedCustomizationBundler extends Disposable {
     private readonly _fileService;
+    private readonly _logService;
+    private readonly _fileOperationLimiter;
     private readonly _authority;
     private _lastNonce;
     private _lastRef;
-    constructor(authority: string, _fileService: IFileService, agentHostFileSystemService: IAgentHostFileSystemService);
+    private _isDisposed;
+    /** Maps a synced (destination) URI string back to its original source location. Rebuilt on every {@link bundle}. */
+    private _originByDest;
+    constructor(authority: string, _fileService: IFileService, agentHostFileSystemService: IAgentHostFileSystemService, _logService: ILogService);
     /**
      * Root URI of the virtual plugin directory for this bundler.
      * The authority is encoded into the path (not the URI authority) because
      * {@link InMemoryFileSystemProvider} only routes by path.
      */
     private get _rootUri();
+    private _queueFileOperation;
+    private _throwIfDisposed;
     /**
      * Bundles the given files and MCP servers into the in-memory plugin
      * filesystem.
      *
      * Overwrites any previous bundle content. Returns a {@link ClientPluginCustomization}
-     * pointing at the virtual plugin directory with a content-based nonce.
+     * pointing at the virtual plugin directory with a metadata-based nonce.
      *
      * @returns The bundle result, or `undefined` if there is nothing to sync.
      */
     bundle(files: readonly ISyncableFile[], mcpServers?: readonly ISyncableMcpServer[]): Promise<IBundleResult | undefined>;
+    private _bundle;
     /**
      * Returns the last computed nonce, or `undefined` if no bundle has been created.
      */
     get lastNonce(): string | undefined;
+    isBundledMcpServer(pluginUri: string, serverName: string): boolean;
+    /**
+     * Recovers the original provenance of a file that was flattened into the
+     * synthetic bundle, given its synced (destination) URI. Returns `undefined`
+     * for URIs that are not part of the most recent bundle.
+     */
+    getOrigin(syncedUri: URI): ISyncedCustomizationOrigin | undefined;
+    dispose(): void;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/syncedCustomizationBundler.js

@@ -1,24 +1,37 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { SequencerByKey, Limiter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationError, isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { extUri, basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { hash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { toClientPluginMcpDefaultCwdsMeta } from '../../../../../../platform/agentHost/common/meta/clientPluginCustomizationMeta.js';
+import { withCustomizationEnablement } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/customizationEnablement';
 import { customizationId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
-import { CustomizationType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import { CustomizationEnablementKind, CustomizationType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
 import '../../../../../services/agentHost/common/agentHostFileSystemService.js';
 import { IAgentHostFileSystemService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/agentHost/common/agentHostFileSystemService.service';
+import { IgnoreFile } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/search/common/ignoreFile';
 import { SYNCED_CUSTOMIZATION_SCHEME } from '../../../../../../platform/agentHost/common/agentHostFileSystemService.js';
 
 const DISPLAY_NAME = "VS Code Synced Data";
+const FILE_OPERATION_CONCURRENCY = 10;
+const SKILL_DIRECTORY_IGNORE = ( new IgnoreFile(".git\nnode_modules\n", "/", undefined, true));
+const bundleSequencer = ( new SequencerByKey());
 const MANIFEST_CONTENT = JSON.stringify({
     name: DISPLAY_NAME,
     description: "Customization data synced from VS Code"
@@ -37,10 +50,74 @@ function pluginDirForType(type) {
         return undefined;
     }
 }
+class DrainingFileOperationLimiter {
+    constructor() {
+        this._limiter = ( new Limiter(FILE_OPERATION_CONCURRENCY));
+        this._isDisposed = false;
+    }
+    queue(operation) {
+        if (this._isDisposed) {
+            return Promise.reject(( new CancellationError()));
+        }
+        return this._limiter.queue(async () => {
+            if (this._isDisposed) {
+                throw ( new CancellationError());
+            }
+            return operation();
+        });
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        void this._disposeWhenIdle();
+    }
+    async _disposeWhenIdle() {
+        await this._limiter.whenIdle();
+        this._limiter.dispose();
+    }
+}
+async function collectDirectoryFiles(fileService, logService, root, directory, queueFileOperation) {
+    const stat = await queueFileOperation(() => fileService.resolve(directory));
+    const children = (await Promise.all(( (stat.children ?? []).map(async child => {
+        try {
+            return await queueFileOperation(() => fileService.stat(child.resource));
+        } catch (error) {
+            if (isCancellationError(error)) {
+                throw error;
+            }
+            logService.trace(
+                "[SyncedCustomizationBundler] Failed to stat skill resource",
+                ( child.resource.toString()),
+                error
+            );
+            return undefined;
+        }
+    })))).filter(child => child !== undefined);
+    const files = await Promise.all(( children.map(async child => {
+        const relativePath = extUri.relativePath(root, child.resource);
+        if (relativePath === undefined) {
+            throw ( new Error(`Unable to resolve skill resource path: ${( child.resource.toString())}`));
+        }
+        if (child.isSymbolicLink || !SKILL_DIRECTORY_IGNORE.isPathIncludedInTraversal(`/${relativePath}`, child.isDirectory)) {
+            return [];
+        }
+        if (child.isDirectory) {
+            return collectDirectoryFiles(fileService, logService, root, child.resource, queueFileOperation);
+        }
+        return child.isFile ? [child] : [];
+    })));
+    return files.flat();
+}
 let SyncedCustomizationBundler = class SyncedCustomizationBundler extends Disposable {
-    constructor(authority, _fileService, agentHostFileSystemService) {
+    constructor(authority, _fileService, agentHostFileSystemService, _logService) {
         super();
         this._fileService = _fileService;
+        this._logService = _logService;
+        this._fileOperationLimiter = this._register(( new DrainingFileOperationLimiter()));
+        this._isDisposed = false;
+        this._originByDest = ( new ResourceMap());
         this._authority = authority;
         agentHostFileSystemService.ensureSyncedCustomizationProvider();
     }
@@ -50,38 +127,106 @@ let SyncedCustomizationBundler = class SyncedCustomizationBundler extends Dispos
             path: `/${this._authority}`
         }));
     }
+    _queueFileOperation(operation) {
+        this._throwIfDisposed();
+        return this._fileOperationLimiter.queue(operation);
+    }
+    _throwIfDisposed() {
+        if (this._isDisposed) {
+            throw ( new CancellationError());
+        }
+    }
     async bundle(files, mcpServers = []) {
+        this._throwIfDisposed();
+        try {
+            const result = await bundleSequencer.queue(this._authority, () => this._bundle(files, mcpServers));
+            this._throwIfDisposed();
+            return result;
+        } catch (error) {
+            this._throwIfDisposed();
+            throw error;
+        }
+    }
+    async _bundle(files, mcpServers) {
+        this._throwIfDisposed();
         const syncable = files.filter(f => pluginDirForType(f.type) !== undefined);
         if (syncable.length === 0 && mcpServers.length === 0) {
             return undefined;
         }
         const entries = [];
+        const originByDest = ( new ResourceMap());
+        const addEntry = (file, source, destUri, hashKey) => {
+            entries.push({
+                sourceUri: source.resource,
+                destUri,
+                hashPart: `${hashKey}:${source.mtime}:${source.size}`
+            });
+            if (file.source !== undefined) {
+                originByDest.set(destUri, {
+                    uri: source.resource,
+                    source: file.source,
+                    extensionId: file.extensionId,
+                    pluginUri: file.pluginUri
+                });
+            }
+        };
         await Promise.all(( syncable.map(async file => {
             const dir = pluginDirForType(file.type);
             const fileName = basename(file.uri);
-            let destUri;
-            let hashKey;
             if (file.type === PromptsType.skill && fileName.toLowerCase() === "skill.md") {
-                const skillDirName = basename(dirname(file.uri));
-                destUri = URI.joinPath(this._rootUri, dir, skillDirName, fileName);
-                hashKey = `${dir}/${skillDirName}/${fileName}`;
+                const skillRoot = dirname(file.uri);
+                const skillDirName = basename(skillRoot);
+                const entrypoint = await this._queueFileOperation(() => this._fileService.stat(file.uri));
+                addEntry(
+                    file,
+                    entrypoint,
+                    URI.joinPath(this._rootUri, dir, skillDirName, fileName),
+                    `${dir}/${skillDirName}/${fileName}`
+                );
+                for (const source of await collectDirectoryFiles(
+                    this._fileService,
+                    this._logService,
+                    skillRoot,
+                    skillRoot,
+                    operation => this._queueFileOperation(operation)
+                )) {
+                    if (extUri.isEqual(source.resource, file.uri)) {
+                        continue;
+                    }
+                    const relativePath = extUri.relativePath(skillRoot, source.resource);
+                    if (relativePath === undefined) {
+                        throw ( new Error(`Unable to resolve skill resource path: ${( source.resource.toString())}`));
+                    }
+                    addEntry(
+                        file,
+                        source,
+                        URI.joinPath(this._rootUri, dir, skillDirName, relativePath),
+                        `${dir}/${skillDirName}/${relativePath}`
+                    );
+                }
             } else {
-                destUri = URI.joinPath(this._rootUri, dir, fileName);
-                hashKey = `${dir}/${fileName}`;
+                const source = await this._queueFileOperation(() => this._fileService.stat(file.uri));
+                addEntry(
+                    file,
+                    source,
+                    URI.joinPath(this._rootUri, dir, fileName),
+                    `${dir}/${fileName}`
+                );
             }
-            const content = await this._fileService.readFile(file.uri);
-            entries.push({
-                destUri,
-                content: content.value,
-                hashPart: `${hashKey}:${( content.value.toString())}`
-            });
         })));
+        this._throwIfDisposed();
         let mcpContent;
+        let mcpDefaultCwds;
+        const childEnablement = {};
         if (mcpServers.length > 0) {
             const servers = {};
+            const defaultCwds = {};
             for (const server of [...mcpServers].sort((a, b) => a.name.localeCompare(b.name))) {
                 servers[server.name] = server.configuration;
+                defaultCwds[server.name] = server.defaultCwd ?? null;
+                childEnablement[server.name] = server.enablement.slice();
             }
+            mcpDefaultCwds = defaultCwds;
             mcpContent = JSON.stringify({
                 mcpServers: servers
             }, null, "\t");
@@ -90,25 +235,50 @@ let SyncedCustomizationBundler = class SyncedCustomizationBundler extends Dispos
         if (mcpContent !== undefined) {
             hashParts.push(`.mcp.json:${mcpContent}`);
         }
+        if (mcpDefaultCwds !== undefined) {
+            hashParts.push(
+                `mcpDefaultCwds:${JSON.stringify(toClientPluginMcpDefaultCwdsMeta(mcpDefaultCwds))}`
+            );
+        }
         hashParts.sort();
         const nonce = String(hash(hashParts.join("\n")));
+        this._throwIfDisposed();
         if (nonce === this._lastNonce && this._lastRef) {
+            this._originByDest = originByDest;
+            if (mcpServers.length > 0 && !equals(childEnablement, this._lastRef.ref.childEnablement)) {
+                return {
+                    ref: {
+                        ...this._lastRef.ref,
+                        childEnablement
+                    }
+                };
+            }
             return this._lastRef;
         }
+        const fileContents = await Promise.all(( entries.map(async entry => ({
+            destUri: entry.destUri,
+            content: (await this._queueFileOperation(() => this._fileService.readFile(entry.sourceUri))).value
+        }))));
+        this._throwIfDisposed();
         try {
             await this._fileService.del(this._rootUri, {
                 recursive: true
             });
         } catch {}
+        this._throwIfDisposed();
         const manifestUri = URI.joinPath(this._rootUri, ".plugin", "plugin.json");
         await this._fileService.writeFile(manifestUri, VSBuffer.fromString(MANIFEST_CONTENT));
-        for (const entry of entries) {
+        for (const entry of fileContents) {
+            this._throwIfDisposed();
             await this._fileService.writeFile(entry.destUri, entry.content);
         }
         if (mcpContent !== undefined) {
+            this._throwIfDisposed();
             const mcpUri = URI.joinPath(this._rootUri, ".mcp.json");
             await this._fileService.writeFile(mcpUri, VSBuffer.fromString(mcpContent));
         }
+        this._throwIfDisposed();
+        this._originByDest = originByDest;
         this._lastNonce = nonce;
         const rootUriString = ( this._rootUri.toString());
         const result = {
@@ -117,8 +287,15 @@ let SyncedCustomizationBundler = class SyncedCustomizationBundler extends Dispos
                 id: customizationId(rootUriString),
                 uri: rootUriString,
                 name: DISPLAY_NAME,
-                enabled: true,
-                nonce
+                nonce,
+                _meta: mcpDefaultCwds ? toClientPluginMcpDefaultCwdsMeta(mcpDefaultCwds) : undefined,
+                enablement: withCustomizationEnablement(undefined, CustomizationEnablementKind.Global, {
+                    kind: CustomizationEnablementKind.Global,
+                    enabled: true
+                }),
+                ...(mcpServers.length > 0 ? {
+                    childEnablement
+                } : {})
             }
         };
         this._lastRef = result;
@@ -127,7 +304,20 @@ let SyncedCustomizationBundler = class SyncedCustomizationBundler extends Dispos
     get lastNonce() {
         return this._lastNonce;
     }
+    isBundledMcpServer(pluginUri, serverName) {
+        return this._lastRef?.ref.uri === pluginUri && Object.hasOwn(this._lastRef.ref.childEnablement ?? {}, serverName);
+    }
+    getOrigin(syncedUri) {
+        return this._originByDest.get(syncedUri);
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        super.dispose();
+    }
 };
-SyncedCustomizationBundler = ( __decorate([( __param(1, IFileService)), ( __param(2, IAgentHostFileSystemService))], SyncedCustomizationBundler));
+SyncedCustomizationBundler = ( __decorate([( __param(1, IFileService)), ( __param(2, IAgentHostFileSystemService)), ( __param(3, ILogService))], SyncedCustomizationBundler));
 
 export { SYNCED_CUSTOMIZATION_SCHEME, SyncedCustomizationBundler };