@codingame/monaco-vscode-chat-service-override 31.0.0 → 32.0.0

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

@@ -77,12 +77,12 @@ let ChatWindowNotifier = class ChatWindowNotifier extends Disposable {
                 mode: FocusMode.Notify
             });
         }
-        const notificationTitle = info.title ? ( localize(6470, "Session: {0}", info.title)) : ( localize(6471, "Untitled Session"));
+        const notificationTitle = info.title ? ( localize(6702, "Session: {0}", info.title)) : ( localize(6703, "Untitled Session"));
         const cts = ( new CancellationTokenSource());
         this._activeNotifications.set(sessionResource, toDisposable(() => cts.dispose(true)));
         const isQuestionCarousel = this._isQuestionCarouselPending(sessionResource);
         try {
-            const actionLabel = isQuestionCarousel ? ( localize(6472, "Open Session")) : ( localize(6473, "Allow"));
+            const actionLabel = isQuestionCarousel ? ( localize(6704, "Open Session")) : ( localize(6705, "Allow"));
             const result = await this._hostService.showToast({
                 title: this._sanitizeOSToastText(notificationTitle),
                 body: this._getNotificationBody(sessionResource, info, isQuestionCarousel),
@@ -121,7 +121,7 @@ let ChatWindowNotifier = class ChatWindowNotifier extends Disposable {
     }
     _getNotificationBody(sessionResource, info, isQuestionCarousel) {
         if (isQuestionCarousel) {
-            return localize(6474, "Questions need your input.");
+            return localize(6706, "Questions need your input.");
         }
         const terminalCommand = this._getPendingTerminalCommand(sessionResource);
         if (terminalCommand) {
@@ -130,7 +130,7 @@ let ChatWindowNotifier = class ChatWindowNotifier extends Disposable {
         if (info.detail) {
             return this._sanitizeOSToastText(info.detail);
         }
-        return localize(6475, "Approval needed to continue.");
+        return localize(6707, "Approval needed to continue.");
     }
     _getPendingTerminalCommand(sessionResource) {
         const model = this._chatService.getSession(sessionResource);

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

@@ -51,8 +51,8 @@ let AgentPluginRecommendations = class AgentPluginRecommendations extends Dispos
         if (uninstalledCount === 0) {
             return;
         }
-        this._notificationService.prompt(Severity.Info, uninstalledCount === 1 ? ( localize(6476, "This workspace recommends 1 agent plugin.")) : ( localize(6477, "This workspace recommends {0} agent plugins.", uninstalledCount)), [{
-            label: ( localize(6478, "Show Plugins")),
+        this._notificationService.prompt(Severity.Info, uninstalledCount === 1 ? ( localize(6708, "This workspace recommends 1 agent plugin.")) : ( localize(6709, "This workspace recommends {0} agent plugins.", uninstalledCount)), [{
+            label: ( localize(6710, "Show Plugins")),
             run: () => {
                 this._extensionsWorkbenchService.openSearch("@agentPlugins @recommended");
             }

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

@@ -13,8 +13,8 @@ const configurationRegistry = ( Registry.as(Extensions.Configuration));
 function createDefaultModelArrays() {
     return {
         modelIds: [""],
-        modelLabels: [( localize(6479, "Auto (Vendor Default)"))],
-        modelDescriptions: [( localize(6480, "Use the vendor's default model"))]
+        modelLabels: [( localize(6711, "Auto (Vendor Default)"))],
+        modelDescriptions: [( localize(6712, "Use the vendor's default model"))]
     };
 }
 let DefaultModelContribution = class DefaultModelContribution extends Disposable {
@@ -46,8 +46,8 @@ let DefaultModelContribution = class DefaultModelContribution extends Disposable
             modelLabels.length = 0;
             modelDescriptions.length = 0;
             modelIds.push("");
-            modelLabels.push(( localize(6479, "Auto (Vendor Default)")));
-            modelDescriptions.push(( localize(6480, "Use the vendor's default model")));
+            modelLabels.push(( localize(6711, "Auto (Vendor Default)")));
+            modelDescriptions.push(( localize(6712, "Use the vendor's default model")));
             const models = [];
             const allModelIds = this._languageModelsService.getLanguageModelIds();
             for (const modelId of allModelIds) {

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

@@ -5,16 +5,16 @@ import { WorkbenchState } from '@codingame/monaco-vscode-api/vscode/vs/platform/
 import { ContributionEnablementState, isContributionDisabled } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/enablement';
 
 function createEnablementActions(key, enablementModel, idPrefix) {
-    return [( new Action(`${idPrefix}.enable`, ( localize(6481, "Enable")), undefined, true, () => {
+    return [( new Action(`${idPrefix}.enable`, ( localize(6713, "Enable")), undefined, true, () => {
         enablementModel.setEnabled(key, ContributionEnablementState.EnabledProfile);
         return Promise.resolve();
-    })), ( new Action(`${idPrefix}.enableForWorkspace`, ( localize(6482, "Enable (Workspace)")), undefined, true, () => {
+    })), ( new Action(`${idPrefix}.enableForWorkspace`, ( localize(6714, "Enable (Workspace)")), undefined, true, () => {
         enablementModel.setEnabled(key, ContributionEnablementState.EnabledWorkspace);
         return Promise.resolve();
-    })), ( new Action(`${idPrefix}.disable`, ( localize(6483, "Disable")), undefined, true, () => {
+    })), ( new Action(`${idPrefix}.disable`, ( localize(6715, "Disable")), undefined, true, () => {
         enablementModel.setEnabled(key, ContributionEnablementState.DisabledProfile);
         return Promise.resolve();
-    })), ( new Action(`${idPrefix}.disableForWorkspace`, ( localize(6484, "Disable (Workspace)")), undefined, true, () => {
+    })), ( new Action(`${idPrefix}.disableForWorkspace`, ( localize(6716, "Disable (Workspace)")), undefined, true, () => {
         enablementModel.setEnabled(key, ContributionEnablementState.DisabledWorkspace);
         return Promise.resolve();
     }))];

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

@@ -46,8 +46,8 @@ let EnablementStatusWidget = class EnablementStatusWidget extends Disposable {
 };
 EnablementStatusWidget = ( __decorate([( __param(3, IMarkdownRendererService))], EnablementStatusWidget));
 const pluginEnablementLabels = {
-    disabledProfile: ( localize(6485, "This plugin is disabled.")),
-    disabledWorkspace: ( localize(6486, "This plugin is disabled for this workspace."))
+    disabledProfile: ( localize(6717, "This plugin is disabled.")),
+    disabledWorkspace: ( localize(6718, "This plugin is disabled for this workspace."))
 };
 
 export { EnablementStatusWidget, pluginEnablementLabels };

package/vscode/src/vs/workbench/contrib/chat/browser/githubRepoFetcher.d.ts

@@ -0,0 +1,58 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+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 { IRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request.service";
+/**
+ * GitHub `owner/repo` parsed from a clone URL. Only `https://github.com/...` URLs
+ * are supported in the browser implementation.
+ */
+export interface IGitHubRepoRef {
+    readonly owner: string;
+    readonly repo: string;
+}
+/**
+ * Parse a clone URL into an `owner/repo` pair.
+ * @returns the parsed reference, or `undefined` if the URL is not a recognised
+ * GitHub HTTPS clone URL.
+ */
+export declare function parseGitHubCloneUrl(cloneUrl: string): IGitHubRepoRef | undefined;
+/**
+ * Resolve a ref (branch / tag / SHA / undefined for default branch) to a
+ * commit SHA via the GitHub commits API.
+ */
+export declare function resolveGitHubRefToSha(requestService: IRequestService, repo: IGitHubRepoRef, ref: string | undefined, authToken: string | undefined, token: CancellationToken): Promise<string>;
+/**
+ * Thrown when GitHub responds with 401/403 to indicate the caller needs to
+ * sign in (or has insufficient permissions) for a private repository.
+ */
+export declare class GitHubAuthRequiredError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when GitHub responds with 403 + `X-RateLimit-Remaining: 0` to
+ * indicate the caller has exhausted the request quota for the current
+ * window. Distinct from {@link GitHubAuthRequiredError} so callers don't
+ * push users to sign in when the actual fix is "wait".
+ */
+export declare class GitHubRateLimitError extends Error {
+    readonly retryAfterSeconds?: number | undefined;
+    constructor(message: string, retryAfterSeconds?: number | undefined);
+}
+/**
+ * Fetches the file tree of a GitHub repository at the given SHA and writes
+ * each blob into {@link targetDir} via {@link IFileService}.
+ *
+ * Uses two CORS-friendly endpoints on `api.github.com` (the `/tarball/` host
+ * has no CORS, and `raw.githubusercontent.com` rejects the OPTIONS preflight
+ * forced by an `Authorization` header):
+ *
+ *  - `GET /repos/{owner}/{repo}/git/trees/{sha}?recursive=1` for the listing.
+ *  - `GET /repos/{owner}/{repo}/git/blobs/{blob_sha}` for each blob (base64).
+ *
+ * Extraction is staged to a sibling directory and atomically swapped into
+ * place on success; failures clean up the staging dir and leave `targetDir`
+ * untouched. Symlinks (`mode === '120000'`) and submodules (`type === 'commit'`)
+ * are skipped — neither is representable in the workbench virtual file system.
+ */
+export declare function fetchAndExtractGitHubRepo(requestService: IRequestService, fileService: IFileService, logService: ILogService, repo: IGitHubRepoRef, sha: string, targetDir: URI, authToken: string | undefined, token: CancellationToken): Promise<void>;

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

@@ -0,0 +1,339 @@
+
+import { Limiter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { decodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { joinPath, dirname, isEqualOrParent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { isSuccess, isClientError, asJson } from '@codingame/monaco-vscode-api/vscode/vs/platform/request/common/request';
+
+const GITHUB_HOSTS = ( new Set(["github.com", "www.github.com"]));
+function parseGitHubCloneUrl(cloneUrl) {
+    let url;
+    try {
+        url = ( new URL(cloneUrl));
+    } catch {
+        return undefined;
+    }
+    if (url.protocol !== "https:" || !( GITHUB_HOSTS.has(url.hostname.toLowerCase()))) {
+        return undefined;
+    }
+    const path = url.pathname.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
+    const segments = path.split("/");
+    if (segments.length !== 2 || !segments[0] || !segments[1]) {
+        return undefined;
+    }
+    return {
+        owner: segments[0],
+        repo: segments[1]
+    };
+}
+async function loggedRequest(requestService, options, token) {
+    try {
+        return await requestService.request({
+            type: "GET",
+            url: options.url,
+            headers: options.headers,
+            callSite: options.callSite
+        }, token);
+    } catch (err) {
+        const reason = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+        throw ( new Error(
+            `Network error during ${options.callSite} (GET ${options.url}): ${reason}`,
+            {
+                cause: err instanceof Error ? err : undefined
+            }
+        ));
+    }
+}
+async function resolveGitHubRefToSha(requestService, repo, ref, authToken, token) {
+    const refSegment = ref && ref.length > 0 ? encodeURIComponent(ref) : "HEAD";
+    const url = `https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}/commits/${refSegment}`;
+    const headers = {
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28"
+    };
+    if (authToken) {
+        headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    const ctx = await loggedRequest(requestService, {
+        url,
+        headers,
+        callSite: "pluginGit.resolveSha"
+    }, token);
+    if (token.isCancellationRequested) {
+        throw ( new CancellationError());
+    }
+    const status = ctx.res.statusCode ?? 0;
+    if (status === 403 && isRateLimited(ctx.res.headers)) {
+        throw ( new GitHubRateLimitError(
+            `GitHub rate limit hit resolving ref '${ref ?? "HEAD"}' on ${repo.owner}/${repo.repo}`,
+            retryAfterFromHeaders(ctx.res.headers)
+        ));
+    }
+    if (status === 401 || status === 403) {
+        throw ( new GitHubAuthRequiredError(
+            `GitHub returned ${status} resolving ref '${ref ?? "HEAD"}' on ${repo.owner}/${repo.repo}`
+        ));
+    }
+    if (status === 404) {
+        throw ( new Error(
+            `GitHub repository or ref not found: ${repo.owner}/${repo.repo}@${ref ?? "HEAD"}`
+        ));
+    }
+    if (!isSuccess(ctx)) {
+        throw ( new Error(
+            `GitHub returned ${status}${isClientError(ctx) ? " (client error)" : ""} resolving ref for ${repo.owner}/${repo.repo}`
+        ));
+    }
+    const body = await asJson(ctx);
+    if (!body || typeof body.sha !== "string") {
+        throw ( new Error(
+            `GitHub commit response for ${repo.owner}/${repo.repo} missing 'sha' field`
+        ));
+    }
+    return body.sha;
+}
+class GitHubAuthRequiredError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GitHubAuthRequiredError";
+    }
+}
+class GitHubRateLimitError extends Error {
+    constructor(message, retryAfterSeconds) {
+        super(message);
+        this.retryAfterSeconds = retryAfterSeconds;
+        this.name = "GitHubRateLimitError";
+    }
+}
+function isRateLimited(headers) {
+    if (!headers) {
+        return false;
+    }
+    if (readHeader(headers, "x-ratelimit-remaining") === "0") {
+        return true;
+    }
+    return readHeader(headers, "retry-after") !== undefined;
+}
+function retryAfterFromHeaders(headers) {
+    if (!headers) {
+        return undefined;
+    }
+    const value = readHeader(headers, "retry-after");
+    if (!value) {
+        return undefined;
+    }
+    const parsed = parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function readHeader(headers, name) {
+    const value = headers[name] ?? headers[name.toLowerCase()];
+    if (Array.isArray(value)) {
+        return value[0];
+    }
+    return value;
+}
+async function fetchAndExtractGitHubRepo(
+    requestService,
+    fileService,
+    logService,
+    repo,
+    sha,
+    targetDir,
+    authToken,
+    token
+) {
+    const tree = await fetchGitHubTree(requestService, repo, sha, authToken, token);
+    if (tree.truncated) {
+        logService.warn(
+            `[GitHubRepoFetcher] Tree for ${repo.owner}/${repo.repo}@${sha} is truncated; some files will be missing from the install`
+        );
+    }
+    const stagingDir = joinPath(dirname(targetDir), `.staging-${generateUuid()}`);
+    try {
+        await fileService.createFolder(stagingDir);
+        const blobsToFetch = [];
+        const createdDirs = ( new Set([( stagingDir.toString())]));
+        for (const entry of tree.tree) {
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            if (entry.type === "commit") {
+                logService.trace(`[GitHubRepoFetcher] Skipping submodule entry ${entry.path}`);
+                continue;
+            }
+            if (entry.mode === "120000") {
+                logService.trace(`[GitHubRepoFetcher] Skipping symlink entry ${entry.path}`);
+                continue;
+            }
+            const dest = safeJoinUnderTarget(stagingDir, entry.path);
+            if (!dest) {
+                logService.warn(`[GitHubRepoFetcher] Skipping unsafe tree entry path: ${entry.path}`);
+                continue;
+            }
+            if (entry.type === "tree") {
+                if (!( createdDirs.has(( dest.toString())))) {
+                    await fileService.createFolder(dest);
+                    createdDirs.add(( dest.toString()));
+                }
+                continue;
+            }
+            if (entry.type !== "blob") {
+                logService.trace(
+                    `[GitHubRepoFetcher] Skipping tree entry with unsupported type '${entry.type}': ${entry.path}`
+                );
+                continue;
+            }
+            const parent = dirname(dest);
+            if (( parent.toString()) !== ( dest.toString()) && !( createdDirs.has(( parent.toString())))) {
+                await fileService.createFolder(parent);
+                createdDirs.add(( parent.toString()));
+            }
+            blobsToFetch.push({
+                entry,
+                dest
+            });
+        }
+        const limiter = ( new Limiter(MAX_PARALLEL_BLOB_FETCHES));
+        await Promise.all(( blobsToFetch.map((
+            {
+                entry,
+                dest
+            }
+        ) => limiter.queue(async () => {
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const content = await fetchGitHubBlob(requestService, repo, sha, entry, authToken, token);
+            await fileService.writeFile(dest, content);
+        }))));
+        await fileService.move(stagingDir, targetDir, true);
+    } catch (err) {
+        try {
+            if (await fileService.exists(stagingDir)) {
+                await fileService.del(stagingDir, {
+                    recursive: true
+                });
+            }
+        } catch (cleanupErr) {
+            logService.warn(`[GitHubRepoFetcher] Failed to clean up staging dir ${( stagingDir.toString())}:`, cleanupErr);
+        }
+        throw err;
+    }
+}
+const MAX_PARALLEL_BLOB_FETCHES = 10;
+async function fetchGitHubTree(requestService, repo, sha, authToken, token) {
+    const url = `https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}/git/trees/${encodeURIComponent(sha)}?recursive=1`;
+    const headers = {
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28"
+    };
+    if (authToken) {
+        headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    const ctx = await loggedRequest(requestService, {
+        url,
+        headers,
+        callSite: "pluginGit.tree"
+    }, token);
+    if (token.isCancellationRequested) {
+        throw ( new CancellationError());
+    }
+    const status = ctx.res.statusCode ?? 0;
+    if (status === 403 && isRateLimited(ctx.res.headers)) {
+        throw ( new GitHubRateLimitError(
+            `GitHub rate limit hit fetching tree for ${repo.owner}/${repo.repo}@${sha}`,
+            retryAfterFromHeaders(ctx.res.headers)
+        ));
+    }
+    if (status === 401 || status === 403) {
+        throw ( new GitHubAuthRequiredError(
+            `GitHub returned ${status} fetching tree for ${repo.owner}/${repo.repo}@${sha}`
+        ));
+    }
+    if (status === 404) {
+        throw ( new Error(`GitHub repository or commit not found: ${repo.owner}/${repo.repo}@${sha}`));
+    }
+    if (!isSuccess(ctx)) {
+        throw ( new Error(
+            `GitHub returned ${status}${isClientError(ctx) ? " (client error)" : ""} fetching tree for ${repo.owner}/${repo.repo}@${sha}`
+        ));
+    }
+    const body = await asJson(ctx);
+    if (!body || !Array.isArray(body.tree)) {
+        throw ( new Error(
+            `GitHub tree response for ${repo.owner}/${repo.repo}@${sha} missing 'tree' array`
+        ));
+    }
+    return body;
+}
+async function fetchGitHubBlob(requestService, repo, commitSha, entry, authToken, token) {
+    const url = `https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}/git/blobs/${encodeURIComponent(entry.sha)}`;
+    const headers = {
+        "Accept": "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28"
+    };
+    if (authToken) {
+        headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    const ctx = await loggedRequest(requestService, {
+        url,
+        headers,
+        callSite: "pluginGit.blob"
+    }, token);
+    if (token.isCancellationRequested) {
+        throw ( new CancellationError());
+    }
+    const status = ctx.res.statusCode ?? 0;
+    if (status === 403 && isRateLimited(ctx.res.headers)) {
+        throw ( new GitHubRateLimitError(
+            `GitHub rate limit hit fetching blob '${entry.path}' for ${repo.owner}/${repo.repo}@${commitSha}`,
+            retryAfterFromHeaders(ctx.res.headers)
+        ));
+    }
+    if (status === 401 || status === 403) {
+        throw ( new GitHubAuthRequiredError(
+            `GitHub returned ${status} fetching blob '${entry.path}' for ${repo.owner}/${repo.repo}@${commitSha}`
+        ));
+    }
+    if (!isSuccess(ctx)) {
+        throw ( new Error(
+            `GitHub returned ${status} fetching blob '${entry.path}' for ${repo.owner}/${repo.repo}@${commitSha}`
+        ));
+    }
+    const body = await asJson(ctx);
+    if (!body || typeof body.content !== "string") {
+        throw ( new Error(`GitHub blob response for '${entry.path}' missing 'content' field`));
+    }
+    if (body.encoding !== "base64") {
+        throw ( new Error(
+            `GitHub blob response for '${entry.path}' has unsupported encoding '${body.encoding}'`
+        ));
+    }
+    return decodeBase64(body.content.replace(/\s+/g, ""));
+}
+function safeJoinUnderTarget(targetDir, inner) {
+    if (inner.includes("\u0000") || inner.startsWith("/") || inner.startsWith("\\")) {
+        return undefined;
+    }
+    const segments = [];
+    for (const seg of inner.split("/")) {
+        if (seg.length === 0 || seg === ".") {
+            continue;
+        }
+        if (seg === ".." || seg.includes("\\")) {
+            return undefined;
+        }
+        segments.push(seg);
+    }
+    if (segments.length === 0) {
+        return undefined;
+    }
+    const dest = joinPath(targetDir, ...segments);
+    if (!isEqualOrParent(dest, targetDir)) {
+        return undefined;
+    }
+    return dest;
+}
+
+export { GitHubAuthRequiredError, GitHubRateLimitError, fetchAndExtractGitHubRepo, parseGitHubCloneUrl, resolveGitHubRefToSha };

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

@@ -340,7 +340,7 @@ let ChatLanguageModelsDataContribution = class ChatLanguageModelsDataContributio
                     },
                     settings: {
                         type: "object",
-                        description: ( localize(6487, "Per-model settings"))
+                        description: ( localize(6719, "Per-model settings"))
                     }
                 },
                 allOf: [...( vendors.map(vendor => ({

package/vscode/src/vs/workbench/contrib/chat/browser/planReviewFeedback/media/planReviewFeedback.css

@@ -0,0 +1,160 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+.plan-review-feedback-input-widget {
+	position: absolute;
+	z-index: 10000;
+	background-color: var(--vscode-panel-background);
+	border: 1px solid var(--vscode-editorWidget-border, var(--vscode-contrastBorder));
+	box-shadow: var(--vscode-shadow-lg);
+	border-radius: 8px;
+	padding: 4px;
+	display: flex;
+	flex-direction: row;
+	align-items: flex-end;
+	animation: planReviewFeedbackInputAppear 0.15s ease-out;
+}
+
+@keyframes planReviewFeedbackInputAppear {
+	from {
+		opacity: 0;
+		transform: translateY(4px);
+	}
+	to {
+		opacity: 1;
+		transform: translateY(0);
+	}
+}
+
+@media (prefers-reduced-motion: reduce) {
+	.plan-review-feedback-input-widget {
+		animation: none;
+		transform: none;
+	}
+}
+
+.plan-review-feedback-input-widget textarea {
+	background-color: var(--vscode-panel-background);
+	border: none;
+	color: var(--vscode-input-foreground);
+	font: inherit;
+	border-radius: 4px;
+	padding: 0 0 0 6px;
+	outline: none;
+	min-width: 150px;
+	max-width: 400px;
+	resize: none;
+	overflow-y: hidden;
+	white-space: pre-wrap;
+	word-wrap: break-word;
+	box-sizing: border-box;
+	display: block;
+	flex: 1;
+}
+
+.plan-review-feedback-input-widget textarea:focus {
+	border-color: var(--vscode-focusBorder);
+	outline: none !important;
+}
+
+.plan-review-feedback-input-widget textarea::placeholder {
+	color: var(--vscode-input-placeholderForeground);
+}
+
+.plan-review-feedback-input-widget .plan-review-feedback-input-measure {
+	position: absolute;
+	visibility: hidden;
+	height: 0;
+	overflow: hidden;
+	white-space: pre;
+	font: inherit;
+	font-size: 13px;
+}
+
+.plan-review-feedback-input-widget .plan-review-feedback-input-actions {
+	display: flex;
+	align-items: center;
+	margin-left: 2px;
+	flex-shrink: 0;
+}
+
+.plan-review-feedback-input-widget .plan-review-feedback-input-actions .action-bar .action-item .action-label {
+	width: 16px;
+	height: 16px;
+}
+
+/* Overlay toolbar (submit / navigate / clear actions) */
+.plan-review-feedback-overlay-widget {
+	padding: 2px 4px;
+	color: var(--vscode-foreground);
+	background-color: var(--vscode-editorWidget-background);
+	border-radius: 6px;
+	border: 1px solid var(--vscode-editorHoverWidget-border);
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	gap: 4px;
+	z-index: 10;
+	box-shadow: var(--vscode-shadow-lg);
+	overflow: hidden;
+}
+
+.plan-review-feedback-overlay-widget .action-item > .action-label {
+	padding: 4px 6px;
+	font-size: 11px;
+	line-height: 14px;
+	border-radius: 4px;
+}
+
+.plan-review-feedback-overlay-widget .monaco-action-bar .actions-container {
+	gap: 4px;
+}
+
+.plan-review-feedback-overlay-widget .action-item.primary > .action-label {
+	background-color: var(--vscode-button-background);
+	color: var(--vscode-button-foreground);
+}
+
+.monaco-workbench .plan-review-feedback-overlay-widget .monaco-action-bar .action-item.primary > .action-label:hover {
+	background-color: var(--vscode-button-hoverBackground);
+}
+
+.plan-review-feedback-overlay-widget .action-item > .action-label.codicon:not(.separator) {
+	color: var(--vscode-foreground);
+	width: 22px;
+	height: 22px;
+	padding: 0;
+	font-size: 16px;
+	line-height: 22px;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+}
+
+.plan-review-feedback-overlay-widget .monaco-action-bar .action-item.disabled {
+
+	> .action-label.codicon::before,
+	> .action-label.codicon,
+	> .action-label,
+	> .action-label:hover {
+		color: var(--vscode-button-separator);
+		opacity: 1;
+	}
+}
+
+.plan-review-feedback-overlay-widget .action-item.label-item {
+	font-variant-numeric: tabular-nums;
+}
+
+.plan-review-feedback-overlay-widget .monaco-action-bar .action-item.label-item > .action-label,
+.plan-review-feedback-overlay-widget .monaco-action-bar .action-item.label-item > .action-label:hover {
+	color: var(--vscode-foreground);
+	opacity: 1;
+}
+
+/* Gutter decoration for feedback lines */
+.plan-review-feedback-line-number {
+	color: var(--vscode-editorInfo-foreground);
+}

package/vscode/src/vs/workbench/contrib/chat/browser/planReviewFeedback/planReviewFeedbackEditorActions.d.ts

@@ -0,0 +1,9 @@
+import { MenuId } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+export declare const PlanReviewFeedbackMenuId: MenuId;
+export declare const hasPlanReviewFeedback: RawContextKey<boolean>;
+export declare const navigatePreviousPlanReviewFeedbackActionId = "planReviewFeedback.action.navigatePrevious";
+export declare const navigateNextPlanReviewFeedbackActionId = "planReviewFeedback.action.navigateNext";
+export declare const clearAllPlanReviewFeedbackActionId = "planReviewFeedback.action.clearAll";
+export declare const navigationBearingFakeActionId = "planReviewFeedback.navigation.bearings";
+export declare function registerPlanReviewFeedbackEditorActions(): void;