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

package/vscode/src/vs/platform/agentHost/common/agentMerge.d.ts

@@ -0,0 +1,261 @@
+import { GitHubActor, PullRequestCheck, PullRequestChecks, PullRequestSnapshot } from "@codingame/monaco-vscode-api/vscode/vs/platform/github/common/githubPullRequestService";
+export declare const AgentMergeConfigKey: {
+    readonly Enabled: "agentMerge.enabled";
+    readonly AddressReviews: "agentMerge.addressReviews";
+    readonly FixCI: "agentMerge.fixCI";
+    readonly ResolveConflicts: "agentMerge.resolveConflicts";
+    readonly MergePullRequest: "agentMerge.mergePullRequest";
+    readonly MergeMethod: "agentMerge.mergeMethod";
+    readonly ReplyAttribution: "agentMerge.replyAttribution";
+};
+export declare const AgentMergeSettingId: {
+    readonly Enabled: "chat.agentMerge.enabled";
+    readonly AddressReviews: "chat.agentMerge.addressReviews";
+    readonly FixCI: "chat.agentMerge.fixCI";
+    readonly ResolveConflicts: "chat.agentMerge.resolveConflicts";
+    readonly MergePullRequest: "chat.agentMerge.mergePullRequest";
+    readonly MergeMethod: "chat.agentMerge.mergeMethod";
+    readonly ReplyAttribution: "chat.agentMerge.replyAttribution";
+};
+/**
+ * Settings-editor tag carried by every Agent Merge setting, so the UI can open
+ * settings filtered to exactly this group with `@tag:agentMerge`.
+ */
+export declare const AGENT_MERGE_SETTING_TAG = "agentMerge";
+/**
+ * Work the agent itself can be asked to perform. Merging is deliberately absent:
+ * it is executed by the host, never delegated to a model.
+ */
+export type AgentMergeRepairAction = "addressReviews" | "fixCI" | "resolveConflicts";
+/** A user-authorizable Agent Merge action, including the host-executed merge. */
+export type AgentMergeAction = AgentMergeRepairAction | "mergePullRequest";
+export type AgentMergeMethod = "auto" | "squash" | "merge" | "rebase";
+/**
+ * When Agent Merge may merge the pull request once it is ready.
+ *
+ * `ifUnchanged` is self-demoting rather than evaluated at merge time: the
+ * moment a repair turn lands a commit the session's value is rewritten to
+ * `never`, so the chosen value always reflects what will actually happen.
+ * Re-selecting `ifUnchanged` starts a fresh baseline from that point.
+ */
+export type AgentMergeMergePullRequest = "always" | "ifUnchanged" | "never";
+export declare const agentMergeMergePullRequestValues: readonly AgentMergeMergePullRequest[];
+export interface AgentMergeActions {
+    readonly addressReviews: boolean;
+    readonly fixCI: boolean;
+    readonly resolveConflicts: boolean;
+    readonly mergePullRequest: AgentMergeMergePullRequest;
+}
+export interface AgentMergeConfiguration extends AgentMergeActions {
+    readonly mergeMethod: AgentMergeMethod;
+    readonly replyAttribution: boolean;
+}
+export interface AgentMergeSessionOverrides {
+    readonly addressReviews?: boolean;
+    readonly fixCI?: boolean;
+    readonly resolveConflicts?: boolean;
+    readonly mergePullRequest?: AgentMergeMergePullRequest;
+}
+export interface AgentMergeTarget {
+    readonly branchName: string;
+    readonly pullRequestUrl?: string;
+    readonly enabledAt: string;
+    readonly commentWatermark: string;
+}
+export interface AgentMergeReviewThreadContext {
+    readonly id: string;
+    readonly path?: string;
+    readonly line?: number;
+    /** Authorized comments in the thread, oldest first, so later follow-ups are visible. */
+    readonly comments: readonly AgentMergeFeedbackComment[];
+}
+export interface AgentMergeFeedbackComment {
+    readonly author?: string;
+    readonly body: string;
+}
+export interface AgentMergeInjectedConfiguration {
+    readonly previous: Readonly<Record<string, unknown>>;
+    readonly applied: Readonly<Record<string, unknown>>;
+}
+export interface AgentMergeSessionState {
+    readonly enabled: boolean;
+    readonly overrides?: AgentMergeSessionOverrides;
+    readonly target?: AgentMergeTarget;
+    readonly injectedConfiguration?: AgentMergeInjectedConfiguration;
+    readonly lastPromptFingerprint?: string;
+    readonly lastPromptAt?: string;
+    readonly repeatedPromptCount?: number;
+    readonly totalPromptCount?: number;
+    /**
+     * Local worktree commit observed when the most recent repair turn started.
+     * A different local commit afterwards means that turn produced work, which
+     * is what demotes an `ifUnchanged` session to `never`.
+     *
+     * Deliberately the local commit rather than the pull request's published
+     * head: GitHub reports a push only after some replication delay, and a turn
+     * ends by evaluating immediately, so a published comparison would routinely
+     * read a stale head and merge changes it should have held back.
+     */
+    readonly repairBaseCommit?: string;
+}
+export interface AgentMergeControllerState {
+    readonly target?: AgentMergeTarget;
+    readonly injectedConfiguration?: AgentMergeInjectedConfiguration;
+    readonly lastPromptFingerprint?: string;
+    readonly lastPromptAt?: string;
+    readonly repeatedPromptCount?: number;
+    readonly totalPromptCount?: number;
+    readonly repairBaseCommit?: string;
+}
+export type AgentMergeRequiredChecks = {
+    readonly kind: "ready";
+    readonly failed: readonly PullRequestCheck[];
+    readonly pending: boolean;
+} | {
+    readonly kind: "indeterminate";
+    readonly reason: string;
+};
+export declare const agentMergeRootConfigSchema: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchema<{
+    "agentMerge.enabled": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+    "agentMerge.addressReviews": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+    "agentMerge.fixCI": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+    "agentMerge.resolveConflicts": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+    "agentMerge.mergePullRequest": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<AgentMergeMergePullRequest>;
+    "agentMerge.mergeMethod": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<AgentMergeMethod>;
+    "agentMerge.replyAttribution": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
+}>;
+export declare const defaultAgentMergeConfiguration: AgentMergeConfiguration;
+export type AgentMergeGateResult = {
+    readonly kind: "indeterminate";
+    readonly reason: string;
+    readonly cause: string;
+} | {
+    readonly kind: "terminal";
+} | {
+    readonly kind: "noWork";
+    readonly waitingOnChecks: boolean;
+    readonly fingerprint: string;
+} | {
+    readonly kind: "prompt";
+    readonly actions: readonly AgentMergeRepairAction[];
+    readonly fingerprint: string;
+    readonly context: AgentMergePromptContext;
+} | {
+    readonly kind: "merge";
+    readonly fingerprint: string;
+};
+export interface AgentMergePromptContext {
+    readonly pullRequestUrl: string;
+    readonly title: string;
+    readonly headSha: string;
+    readonly baseRef: string;
+    readonly headRef: string;
+    readonly reviewThreads: readonly AgentMergeReviewThreadContext[];
+    readonly reviewSummaries: readonly AgentMergeFeedbackComment[];
+    readonly newComments: readonly AgentMergeFeedbackComment[];
+    readonly failedChecks: readonly string[];
+    readonly behind: boolean;
+    readonly conflicting: boolean;
+    readonly commentWatermark: string;
+}
+export declare function resolveAgentMergeConfiguration(defaults: AgentMergeConfiguration, overrides: AgentMergeSessionOverrides | undefined): AgentMergeConfiguration;
+/**
+ * Maps the configured merge method onto a method the repository actually
+ * allows. `auto` prefers squash, then a merge commit, then rebase; an
+ * explicitly configured method is only used when the repository permits it.
+ */
+export declare function resolveMergeMethod(configured: AgentMergeMethod, allowed: readonly ("MERGE" | "SQUASH" | "REBASE")[]): "MERGE" | "SQUASH" | "REBASE" | undefined;
+/**
+ * Why Agent Merge stopped monitoring a session. Keeping both strings together
+ * lets the controller log a stable English detail while the transcript shows a
+ * localized sentence, without either drifting from the other.
+ */
+export interface AgentMergeDisableReason {
+    /** Stable English detail appended to the host log line. */
+    readonly log: string;
+    /** Localized sentence shown to the user in the session transcript. */
+    readonly notice: string;
+}
+/** Every reason the Agent Merge controller can stop monitoring a session on its own. */
+export declare const agentMergeDisableReasons: {
+    readonly sessionArchived: () => AgentMergeDisableReason;
+    readonly branchChanged: (from: string, to: string) => AgentMergeDisableReason;
+    readonly branchChangedWhileRefreshing: () => AgentMergeDisableReason;
+    readonly differentPullRequest: () => AgentMergeDisableReason;
+    readonly invalidPullRequestUrl: () => AgentMergeDisableReason;
+    readonly differentGitHubHost: () => AgentMergeDisableReason;
+    readonly indeterminate: (minutes: number, reason: string) => AgentMergeDisableReason;
+    readonly pullRequestClosed: () => AgentMergeDisableReason;
+    readonly pullRequestAlreadyMerged: (pullRequestNumber: number, pullRequestUrl: string) => AgentMergeDisableReason;
+    readonly repairBudgetExhausted: () => AgentMergeDisableReason;
+    readonly pullRequestMerged: (pullRequestNumber: number, pullRequestUrl: string) => AgentMergeDisableReason;
+};
+/** The transcript notice shown once Agent Merge starts watching a branch. */
+export declare function agentMergeEnabledNotice(target: Pick<AgentMergeTarget, "branchName" | "pullRequestUrl">, configuration: AgentMergeConfiguration): string;
+/**
+ * Whether a configuration change was made for one session alone, or to the
+ * defaults every session follows.
+ */
+export type AgentMergeConfigurationChangeScope = "session" | "global";
+/**
+ * The transcript notice shown when effective Agent Merge behavior changes. The
+ * scope is named up front because the same change reads very differently
+ * depending on whether it was made for this session or for all of them.
+ */
+export declare function agentMergeConfigurationChangedNotice(previous: AgentMergeConfiguration, current: AgentMergeConfiguration, scope: AgentMergeConfigurationChangeScope): string | undefined;
+/** The transcript notice shown when the user, rather than the controller, disables Agent Merge. */
+export declare function agentMergeDisabledNotice(): string;
+/**
+ * The transcript notice shown when Agent Merge stops merging automatically
+ * because its own repair work changed the pull request.
+ */
+export declare function agentMergeMergePullRequestDemotedNotice(): string;
+export declare function readAgentMergeSessionState(values: Record<string, unknown> | undefined): AgentMergeSessionState | undefined;
+/**
+ * Returns session config values with Agent Merge injected overrides removed,
+ * so callers can read the user's own picker selections while merge is active.
+ */
+export declare function getNonMergeSessionConfigValues(values: Readonly<Record<string, unknown>> | undefined): Readonly<Record<string, unknown>>;
+export declare function isAgentMergeFeedbackAuthor(actor: GitHubActor | undefined): boolean;
+/**
+ * Recorded as the repair baseline when the session worktree cannot be read.
+ * No git object id can equal it, so a session that reached this state always
+ * counts as changed — see {@link shouldStopMergingAfterAgentChanges}.
+ */
+export declare const AGENT_MERGE_UNKNOWN_COMMIT = "unknown";
+/**
+ * Whether a session that only authorized merging while the pull request is
+ * unchanged must stop merging automatically, because a repair turn produced
+ * work since it started.
+ *
+ * Compares local worktree commits, not the pull request's published head: the
+ * commit exists locally the moment the agent makes it, whereas GitHub reports
+ * it only after a replication delay that a turn-completion check would race.
+ *
+ * Fails closed. Once a repair turn has run, a commit that cannot be resolved
+ * counts as a change: a missed automatic merge is cheap, whereas merging
+ * agent-written changes the user wanted to review first is not.
+ *
+ * Callers rewrite the chosen value to `never` rather than gating on this, so
+ * the value always reflects what will actually happen. Clearing
+ * {@link AgentMergeSessionState.repairBaseCommit} at the same time is what lets
+ * a later re-selection start from a fresh baseline.
+ */
+export declare function shouldStopMergingAfterAgentChanges(configuration: AgentMergeConfiguration, agentMerge: AgentMergeSessionState, currentCommit: string | undefined): boolean;
+export declare function isAgentMergeMergePullRequest(value: unknown): value is AgentMergeMergePullRequest;
+export declare function evaluateAgentMerge(snapshot: PullRequestSnapshot, configuration: AgentMergeConfiguration, commentWatermark: string, deferredCheckIds?: ReadonlySet<string>): AgentMergeGateResult;
+/** Fragments the gate must be able to read before it can decide anything. */
+export declare const agentMergeGateFragments: readonly [
+    "core",
+    "topLevelComments",
+    "submittedReviews",
+    "reviewThreads",
+    "checks",
+    "mergeability"
+];
+/**
+ * Returns whether a draft pull request has no pending or failed required checks
+ * and no actionable review feedback, or `undefined` while that state is incomplete.
+ */
+export declare function isAgentMergePullRequestReadyForReview(snapshot: PullRequestSnapshot, commentWatermark: string): boolean | undefined;
+export declare function classifyAgentMergeRequiredChecks(checks: PullRequestChecks): AgentMergeRequiredChecks;

package/vscode/src/vs/platform/agentHost/common/agentMerge.js

@@ -0,0 +1,67 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { createSchema, schemaProperty } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+
+const AgentMergeConfigKey = {
+    Enabled: "agentMerge.enabled",
+    AddressReviews: "agentMerge.addressReviews",
+    FixCI: "agentMerge.fixCI",
+    ResolveConflicts: "agentMerge.resolveConflicts",
+    MergePullRequest: "agentMerge.mergePullRequest",
+    MergeMethod: "agentMerge.mergeMethod",
+    ReplyAttribution: "agentMerge.replyAttribution"
+};
+const AgentMergeSettingId = {
+    Enabled: "chat.agentMerge.enabled",
+    AddressReviews: "chat.agentMerge.addressReviews",
+    FixCI: "chat.agentMerge.fixCI",
+    ResolveConflicts: "chat.agentMerge.resolveConflicts",
+    MergePullRequest: "chat.agentMerge.mergePullRequest",
+    MergeMethod: "chat.agentMerge.mergeMethod",
+    ReplyAttribution: "chat.agentMerge.replyAttribution"
+};
+const AGENT_MERGE_SETTING_TAG = "agentMerge";
+createSchema({
+    [AgentMergeConfigKey.Enabled]: schemaProperty({
+        type: "boolean",
+        title: ( localize(2027, "Agent Merge")),
+        default: false
+    }),
+    [AgentMergeConfigKey.AddressReviews]: schemaProperty({
+        type: "boolean",
+        title: ( localize(2028, "Address Reviews")),
+        default: true
+    }),
+    [AgentMergeConfigKey.FixCI]: schemaProperty({
+        type: "boolean",
+        title: ( localize(2029, "Fix CI Failures")),
+        default: true
+    }),
+    [AgentMergeConfigKey.ResolveConflicts]: schemaProperty({
+        type: "boolean",
+        title: ( localize(2030, "Resolve Conflicts")),
+        default: true
+    }),
+    [AgentMergeConfigKey.MergePullRequest]: schemaProperty({
+        type: "string",
+        title: ( localize(2031, "Merge Pull Request")),
+        enum: ["always", "ifUnchanged", "never"],
+        default: "never"
+    }),
+    [AgentMergeConfigKey.MergeMethod]: schemaProperty({
+        type: "string",
+        title: ( localize(2032, "Merge Method")),
+        enum: ["auto", "squash", "merge", "rebase"],
+        default: "auto"
+    }),
+    [AgentMergeConfigKey.ReplyAttribution]: schemaProperty({
+        type: "boolean",
+        title: ( localize(2033, "Reply Attribution")),
+        default: true
+    })
+});
+
+export { AGENT_MERGE_SETTING_TAG, AgentMergeConfigKey, AgentMergeSettingId };

package/vscode/src/vs/platform/agentHost/common/agentSdkSetup.d.ts

@@ -0,0 +1,53 @@
+import type { RootState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+export declare const AGENT_SDK_SETUP_DOWNLOAD_REQUEST_KEY = "vscode.agentSdkSetup.downloadRequest";
+/**
+ * Ask an agent to look again at a setup the user completed outside the app
+ * (`claude login`, an exported key) — the only completion signal there is.
+ */
+export declare const AGENT_SDK_SETUP_RELOAD_REQUEST_KEY = "vscode.agentSdkSetup.reloadRequest";
+export declare function agentSdkSetupStatusKey(agent: string): string;
+/**
+ * Whether the agent's SDK can be loaded without a network fetch.
+ *
+ * `downloadOnUse` means the SDK is absent, but this host remembers consent and
+ * will fetch it only when an agent turn needs it.
+ *
+ * Deliberately the *only* thing on the wire: account state is derivable from the
+ * model list, which already flows over AHP — `ready` plus zero models means "no
+ * account" — and publishing it too would be two sources for one truth.
+ */
+export type AgentSdkDownloadStatus = "notDownloaded" | "downloadOnUse" | "downloading" | "ready";
+/**
+ * What an agent declares about its own setup. Capabilities, never UI: no
+ * user-facing strings ride this channel, because localization belongs in the
+ * workbench.
+ */
+export interface IAgentSdkSetupInfo {
+    /** Agent/provider id, e.g. `'claude'`. */
+    readonly agent: string;
+    readonly download: AgentSdkDownloadStatus;
+    /**
+     * Where the user goes to finish setup, for the agents whose setup happens
+     * outside the app (`claude login`, an exported API key).
+     */
+    readonly setupDocsUrl?: string;
+    /**
+     * Display name of the provider this agent can sign in to in-app, e.g.
+     * `'ChatGPT'`; absent means it has no such flow. A proper noun the workbench
+     * cannot invent, so it crosses the wire like `displayName` does and is
+     * interpolated into a localized template rather than shown raw.
+     */
+    readonly signInProviderName?: string;
+}
+/** A request the workbench addresses to one agent, made unique so a repeat press is not swallowed. */
+export interface IAgentSdkSetupRequest {
+    readonly agent: string;
+    readonly request: string;
+}
+export declare function isAgentSdkSetupRequestFor(value: unknown, agent: string): value is IAgentSdkSetupRequest;
+/**
+ * Every agent that has published a setup status, in root-state key order. Agents
+ * that have not published are absent rather than guessed at — there is no honest
+ * default for "we were never told".
+ */
+export declare function readAgentSdkSetupInfos(state: RootState | undefined): readonly IAgentSdkSetupInfo[];

package/vscode/src/vs/platform/agentHost/common/agentSdkSetup.js

@@ -0,0 +1,45 @@
+
+
+const AGENT_SDK_SETUP_STATUS_KEY_PREFIX = "vscode.agentSdkSetup.status.";
+const AGENT_SDK_SETUP_DOWNLOAD_REQUEST_KEY = "vscode.agentSdkSetup.downloadRequest";
+const AGENT_SDK_SETUP_RELOAD_REQUEST_KEY = "vscode.agentSdkSetup.reloadRequest";
+function readOne(value, agent) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const info = value;
+    if (info.download !== "notDownloaded" && info.download !== "downloadOnUse" && info.download !== "downloading" && info.download !== "ready") {
+        return undefined;
+    }
+    return {
+        agent,
+        download: info.download,
+        setupDocsUrl: typeof info.setupDocsUrl === "string" ? info.setupDocsUrl : undefined,
+        signInProviderName: typeof info.signInProviderName === "string" && info.signInProviderName.length > 0 ? info.signInProviderName : undefined
+    };
+}
+function readAgentSdkSetupInfos(state) {
+    const meta = state?._meta;
+    const values = state?.config?.values;
+    const infos = [];
+    const seen = ( new Set());
+    for (const bag of [values, meta]) {
+        for (const key of ( Object.keys(bag ?? {}))) {
+            if (!key.startsWith(AGENT_SDK_SETUP_STATUS_KEY_PREFIX)) {
+                continue;
+            }
+            const agent = key.slice(AGENT_SDK_SETUP_STATUS_KEY_PREFIX.length);
+            if (!agent || ( seen.has(agent))) {
+                continue;
+            }
+            const info = readOne(bag?.[key], agent);
+            if (info) {
+                seen.add(agent);
+                infos.push(info);
+            }
+        }
+    }
+    return infos;
+}
+
+export { AGENT_SDK_SETUP_DOWNLOAD_REQUEST_KEY, AGENT_SDK_SETUP_RELOAD_REQUEST_KEY, readAgentSdkSetupInfos };

package/vscode/src/vs/platform/agentHost/common/changesetUri.d.ts

@@ -0,0 +1,130 @@
+import { type Changeset, type ISessionGitState, type ISessionWithDefaultChat, type URI } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+/** Stable id and change kind of the Agent Merge changeset. */
+export declare const AGENT_MERGE_CHANGESET_ID = "agent-merge";
+/** Localized human-readable label for the branch changeset entry. */
+export declare const branchChangesetLabel: () => string;
+/** Localized human-readable label for the session-wide changeset entry. */
+export declare const sessionChangesetLabel: () => string;
+/** Localized human-readable description for the session-wide changeset entry. */
+export declare const sessionChangesetDescription: () => string;
+/** Localized human-readable label for the uncommitted-changes changeset entry. */
+export declare const uncommittedChangesetLabel: () => string;
+/** Localized human-readable description for the uncommitted-changes changeset entry. */
+export declare const uncommittedChangesetDescription: () => string;
+/** Localized human-readable label for the per-turn changeset template entry. */
+export declare const thisTurnChangesetLabel: () => string;
+/** Localized human-readable description for the per-turn changeset template entry. */
+export declare const thisTurnChangesetDescription: () => string;
+/** Localized human-readable label for the compare-turns changeset template entry. */
+export declare const compareTurnsChangesetLabel: () => string;
+/** Localized human-readable description for the compare-turns changeset template entry. */
+export declare const compareTurnsChangesetDescription: () => string;
+/**
+ * Returns the description shown next to the `Branch Changes` catalogue
+ * entry. Prefers `${branchName} → ${baseBranchName}` when both values
+ * are known (typical worktree-isolation case). If `baseBranchName` is
+ * unknown, falls back to `${branchName} → ${upstreamBranchName}` when an
+ * upstream is available. Finally falls back to `branchName` alone.
+ * Returns `undefined` only when no branch name is known at all, so
+ * callers can omit the description entirely.
+ */
+export declare function formatBranchChangesetDescription(gitState: ISessionGitState): string | undefined;
+/** Discriminates the well-known changeset URI shapes. */
+export declare enum ChangesetKind {
+    Branch = "branch",
+    Uncommitted = "uncommitted",
+    Session = "session",
+    Turn = "turn",
+    Compare = "compare-turns",
+    /** Producer-defined id we don't recognise (single-segment only). */
+    Unknown = "unknown"
+}
+/** Changeset kinds that can represent a session's default changes view. */
+export type DefaultChangesetKind = ChangesetKind.Branch | ChangesetKind.Uncommitted | ChangesetKind.Session;
+/** Selects the configured default changeset, falling back to the first catalogue entry. */
+export declare function selectDefaultChangeset<T extends Pick<Changeset, "changeKind">>(changesets: readonly T[] | undefined, defaultKind?: DefaultChangesetKind): T | undefined;
+/**
+ * Resolve a {@link Changeset.uriTemplate} from a session's catalogue into a
+ * subscribable URI template.
+ *
+ * A host may publish the template relative to the session channel
+ * (`changeset/branch`); used verbatim that addresses the client's own
+ * filesystem. Templates that already carry a scheme are returned unchanged.
+ */
+export declare function resolveChangesetUriTemplate(sessionUri: URI, uriTemplate: string): string;
+export declare function buildBranchChangesetUri(sessionUri: URI): URI;
+/** Returns the subscribable URI for the session-wide changeset. */
+export declare function buildSessionChangesetUri(sessionUri: URI): URI;
+/** Returns the subscribable URI for the uncommitted-changes changeset. */
+export declare function buildUncommittedChangesetUri(sessionUri: URI): URI;
+/**
+ * Returns the URI _template_ that catalogue entries advertise for the
+ * per-turn changeset; clients expand `{turnId}` to build the
+ * subscribable URI via {@link buildTurnChangesetUri}.
+ */
+export declare function buildTurnChangesetUriTemplate(sessionUri: URI): URI;
+/** Returns the subscribable URI for the per-turn changeset of `turnId`. */
+export declare function buildTurnChangesetUri(sessionUri: URI, turnId: string): URI;
+/**
+ * Returns the URI _template_ that catalogue entries advertise for the
+ * compare-turns changeset; clients expand both `{originalTurnId}` and
+ * `{modifiedTurnId}` to build the subscribable URI via
+ * {@link buildCompareTurnsChangesetUri}.
+ */
+export declare function buildCompareTurnsChangesetUriTemplate(sessionUri: URI): URI;
+/**
+ * Returns the subscribable URI for the compare-turns changeset between
+ * `originalTurnId` (the "from" endpoint) and `modifiedTurnId` (the "to"
+ * endpoint). Diff direction is `originalTurnId → modifiedTurnId`.
+ */
+export declare function buildCompareTurnsChangesetUri(sessionUri: URI, originalTurnId: string, modifiedTurnId: string): URI;
+/**
+ * Returns the subscribable URI for an opaque, producer-defined
+ * `changesetId`. The id must not contain `/` — well-known multi-segment
+ * shapes have dedicated builders (e.g. {@link buildTurnChangesetUri}).
+ */
+export declare function buildChangesetUri(sessionUri: URI, changesetId: string): URI;
+/**
+ * Parses a changeset URI back into `(sessionUri, changesetId, kind)`,
+ * or returns `undefined` if `uri` is not a changeset URI we recognise.
+ */
+export declare function parseChangesetUri(uri: URI): {
+    sessionUri: URI;
+    changesetId: string;
+    kind: ChangesetKind;
+    turnId?: string;
+    originalTurnId?: string;
+    modifiedTurnId?: string;
+} | undefined;
+/** Returns `true` iff `uri` looks like a changeset URI we recognise. */
+export declare function isChangesetUri(uri: URI): boolean;
+/** Returns `true` iff `uri` is the session-wide changeset URI. */
+export declare function isSessionChangesetUri(uri: URI): boolean;
+/** Returns `true` iff `uri` is the uncommitted-changes changeset URI. */
+export declare function isUncommittedChangesetUri(uri: URI): boolean;
+/** Returns the parsed turn id when `uri` is a per-turn changeset URI. */
+export declare function parseTurnChangesetUri(uri: URI): {
+    sessionUri: URI;
+    turnId: string;
+} | undefined;
+/** Returns the parsed turn ids when `uri` is a compare-turns changeset URI. */
+export declare function parseCompareTurnsChangesetUri(uri: URI): {
+    sessionUri: URI;
+    originalTurnId: string;
+    modifiedTurnId: string;
+} | undefined;
+/**
+ * Builds the ordered `summary.changesets` catalogue for a session. Aggregate
+ * counts are filled in later by the diff producer as compute passes complete.
+ *
+ * The first two entries (`Branch Changes`, `Uncommitted Changes`) are
+ * git-only; `AgentService._attachGitState` strips them asynchronously
+ * for sessions whose working directory is not a git repo. The backing
+ * per-changeset states are still registered for every session — only
+ * the catalogue advertisements are stripped.
+ *
+ * The Agent Merge entry reuses the compare-turns URI template. It is advertised
+ * after Agent Merge is enabled and remains available for the rest of the
+ * session, including after Agent Merge is disabled.
+ */
+export declare function buildDefaultChangesetCatalog(sessionUri: URI, state?: ISessionWithDefaultChat): Changeset[];

package/vscode/src/vs/platform/agentHost/common/changesetUri.js

@@ -0,0 +1,27 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/nls';
+import './agentMerge.js';
+import '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/meta/agentSystemNotificationMeta';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+
+var ChangesetKind;
+(function(ChangesetKind) {
+    ChangesetKind["Branch"] = "branch";
+    ChangesetKind["Uncommitted"] = "uncommitted";
+    ChangesetKind["Session"] = "session";
+    ChangesetKind["Turn"] = "turn";
+    ChangesetKind["Compare"] = "compare-turns";
+    ChangesetKind["Unknown"] = "unknown";
+})(ChangesetKind || (ChangesetKind = {}));
+function selectDefaultChangeset(changesets, defaultKind = ChangesetKind.Branch) {
+    return changesets?.find(changeset => changeset.changeKind === defaultKind) ?? changesets?.[0];
+}
+const URI_SCHEME_PREFIX = /^[a-zA-Z][a-zA-Z0-9+.\-]*:/;
+function resolveChangesetUriTemplate(sessionUri, uriTemplate) {
+    if (URI_SCHEME_PREFIX.test(uriTemplate)) {
+        return uriTemplate;
+    }
+    return `${sessionUri.replace(/\/+$/, "")}/${uriTemplate.replace(/^\/+/, "")}`;
+}
+
+export { ChangesetKind, resolveChangesetUriTemplate, selectDefaultChangeset };

package/vscode/src/vs/platform/agentHost/common/customAgents.d.ts

@@ -1,5 +1,5 @@
-import type { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { type AgentCustomization, type Customization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type AgentCustomization, type ClientPluginCustomization, type Customization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
 /**
  * Computes the effective set of selectable custom agents for a session.
  *
@@ -15,6 +15,12 @@ import { type AgentCustomization, type Customization } from "@codingame/monaco-v
  * duplicates within the session's customization list are coalesced.
  */
 export declare function getEffectiveAgents(sessionCustomizations: readonly Customization[] | undefined): readonly AgentCustomization[];
+/**
+ * Filters draft agents by their published plugin container enablement.
+ * Unmatched agents remain selectable because they may be loose agents or precede
+ * their plugin ref during a client update.
+ */
+export declare function getEffectiveClientAgents(clientCustomizations: readonly ClientPluginCustomization[] | undefined, clientAgents: readonly AgentCustomization[]): readonly AgentCustomization[];
 /**
  * Storage key used by the custom-agent pickers to remember the user's last
  * selection per session-resource scheme. Shared between the Agents Window

package/vscode/src/vs/platform/agentHost/common/customAgents.js

@@ -1,10 +1,17 @@
 
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
 import '@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';
 
 function agentHostAgentPickerStorageKey(resourceScheme) {
     return `workbench.agentsession.agentHostAgentPicker.${resourceScheme}.selectedAgentUri`;