flowseeker 0.1.7

package/dist/ui/chatViewProvider.js

@@ -0,0 +1,3899 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatViewProvider = void 0;
+const vscode = __importStar(require("vscode"));
+const aiProviders_1 = require("../gateway/aiProviders");
+const commandRunner_1 = require("../agent/commandRunner");
+const mcpToolRunner_1 = require("../agent/mcpToolRunner");
+const approvalPolicy_1 = require("../agent/approvalPolicy");
+const editProposalStore_1 = require("../gateway/editProposalStore");
+const agentPrompts_1 = require("../gateway/agentPrompts");
+const contextExpansion_1 = require("../gateway/contextExpansion");
+const mcpConfig_1 = require("../mcp/mcpConfig");
+const agentPrompt_1 = require("../pipeline/agentPrompt");
+const diffPreview_1 = require("../pipeline/diffPreview");
+const feedback_1 = require("../pipeline/feedback");
+const fileGroups_1 = require("../pipeline/fileGroups");
+const runPipeline_1 = require("../pipeline/runPipeline");
+const tokenSavings_1 = require("../pipeline/tokenSavings");
+const verifyAfterApply_1 = require("../pipeline/verifyAfterApply");
+const logger_1 = require("../utils/logger");
+const legacyHistoryStateKey = "flowseeker.chat.history";
+const threadsStateKey = "flowseeker.chat.threads.v1";
+const activeThreadStateKey = "flowseeker.chat.activeThreadId.v1";
+const maxHistoryMessages = 80;
+const maxChatThreads = 40;
+class ChatViewProvider {
+    constructor(context, resultProvider, gateway, editStore, planStore, quotaTracker) {
+        this.context = context;
+        this.resultProvider = resultProvider;
+        this.gateway = gateway;
+        this.editStore = editStore;
+        this.planStore = planStore;
+        this.quotaTracker = quotaTracker;
+        const loaded = this.loadThreads();
+        this.threads = loaded.threads;
+        this.activeThreadId = loaded.activeThreadId;
+        this.context.subscriptions.push(vscode.workspace.onDidChangeConfiguration((event) => {
+            if (event.affectsConfiguration("flowseeker.agent")) {
+                this.postAgentPolicyState();
+            }
+        }));
+        if (quotaTracker) {
+            this.context.subscriptions.push(quotaTracker.onDidChange(() => {
+                void this.refreshConnectionState();
+            }));
+        }
+    }
+    resolveWebviewView(webviewView) {
+        this.view = webviewView;
+        webviewView.webview.options = {
+            enableScripts: true
+        };
+        webviewView.webview.html = this.renderHtml(webviewView.webview);
+        webviewView.webview.onDidReceiveMessage((message) => {
+            void this.handleMessage(message);
+        });
+    }
+    async handleMessage(message) {
+        try {
+            switch (message.type) {
+                case "ready":
+                    await this.restoreThreads();
+                    await this.postConnectionState();
+                    this.postAgentPolicyState();
+                    return;
+                case "newThread":
+                    await this.createNewThread();
+                    return;
+                case "selectThread":
+                    await this.selectThread(message.threadId);
+                    return;
+                case "deleteThread":
+                    await this.deleteThread(message.threadId);
+                    return;
+                case "connect":
+                    {
+                        const input = toProviderInput(message);
+                        let probeWarning;
+                        try {
+                            await this.gateway.configureProvider(input);
+                            if (shouldProbeQuotaOnConnect(input.provider)) {
+                                try {
+                                    await this.gateway.testProvider(input);
+                                }
+                                catch (error) {
+                                    probeWarning = formatQuotaProbeWarning(error);
+                                }
+                            }
+                            await this.postConnectionState();
+                            this.postGatewayFeedback(probeWarning ? "warning" : "success", probeWarning
+                                ? `Profile saved, but quota probe failed. ${probeWarning}`
+                                : "AI provider profile saved and active.");
+                        }
+                        catch (error) {
+                            await this.postConnectionState();
+                            this.postGatewayFeedback("error", formatErrorMessage(error));
+                        }
+                    }
+                    return;
+                case "testProvider": {
+                    try {
+                        this.postGatewayFeedback("info", "Testing AI provider...");
+                        const connection = await this.gateway.testProvider(toProviderInput(message));
+                        this.postGatewayFeedback("success", `${connection.providerLabel ?? "AI provider"} test succeeded${connection.model ? ` with ${connection.model}` : ""}.`);
+                    }
+                    catch (error) {
+                        this.postGatewayFeedback("error", formatErrorMessage(error));
+                    }
+                    return;
+                }
+                case "fetchModels": {
+                    const input = toProviderInput(message);
+                    const models = await this.gateway.listModelsForInput(input);
+                    this.post({ type: "models", provider: input.provider, model: input.model ?? "", models });
+                    return;
+                }
+                case "disconnect":
+                    try {
+                        await this.gateway.disconnect();
+                        await this.postConnectionState();
+                        this.postGatewayFeedback("info", "AI provider disconnected. Local retrieval remains available.");
+                    }
+                    catch (error) {
+                        await this.postConnectionState();
+                        this.postGatewayFeedback("error", formatErrorMessage(error));
+                    }
+                    return;
+                case "selectProviderProfile": {
+                    try {
+                        const connection = await this.gateway.setActiveProviderProfile(message.profileId);
+                        await this.postConnectionState();
+                        this.postGatewayFeedback("success", `Switched to ${connection.providerLabel ?? "AI provider"}${connection.model ? ` / ${connection.model}` : ""}.`);
+                    }
+                    catch (error) {
+                        await this.postConnectionState();
+                        this.postGatewayFeedback("error", formatErrorMessage(error));
+                    }
+                    return;
+                }
+                case "removeProviderProfile":
+                    try {
+                        await this.gateway.removeProviderProfile(message.profileId);
+                        await this.postConnectionState();
+                        this.postGatewayFeedback("info", "AI provider profile removed.");
+                    }
+                    catch (error) {
+                        await this.postConnectionState();
+                        this.postGatewayFeedback("error", formatErrorMessage(error));
+                    }
+                    return;
+                case "ask":
+                    await this.ask(message.task, message.mode);
+                    return;
+                case "feedback":
+                    await this.saveFeedback(message.runId, message.kind);
+                    return;
+                case "copyAgentPrompt":
+                    await this.copyAgentPrompt();
+                    return;
+                case "copyTokenProof":
+                    await this.copyTokenProof();
+                    return;
+                case "approvePlan":
+                    await this.approvePlan(message.planId);
+                    return;
+                case "openDiff":
+                    await this.openDiff(message.proposalId);
+                    return;
+                case "applyEdits":
+                    await this.applyEdits(message.proposalId);
+                    return;
+                case "verifyFiles":
+                    await this.verifyFiles(message.files);
+                    return;
+                case "runAgentCommand":
+                    await this.runAgentCommand(message.command);
+                    return;
+                case "runMcpTool":
+                    await this.runMcpTool(message.tool);
+                    return;
+                case "openAgentSettings":
+                    await this.openAgentSettings();
+                    return;
+                case "updateAgentPolicy":
+                    await this.updateAgentPolicy(message);
+                    return;
+                case "cancel":
+                    await this.cancelActiveRequest();
+                    return;
+                case "startOAuth":
+                    await vscode.commands.executeCommand("flowseeker.startOAuth", message.provider);
+                    return;
+                case "openFile":
+                    await this.openFile(message.file);
+                    return;
+                case "openMcpConfig":
+                    await vscode.commands.executeCommand("flowseeker.openMcpConfig");
+                    return;
+            }
+        }
+        catch (error) {
+            (0, logger_1.logError)("FlowSeeker chat action failed.", error);
+            const text = error instanceof Error ? error.message : String(error);
+            await this.postChat({ kind: "error", text });
+        }
+    }
+    async ask(task, mode) {
+        const cleanTask = task.trim();
+        if (!cleanTask) {
+            this.post({ type: "error", text: "Enter a task first." });
+            return;
+        }
+        // Chat mode: bypass FlowSeeker retrieval, go straight to AI provider
+        if (mode === "chat") {
+            const conn = await this.gateway.getConnection();
+            if (!conn.connected) {
+                await this.postChat({ kind: "error", text: "Connect an AI provider before using Chat mode." }, this.activeThread().id);
+                return;
+            }
+            this.askCancellation?.cancel();
+            this.askCancellation?.dispose();
+            const requestCancellation = new vscode.CancellationTokenSource();
+            this.askCancellation = requestCancellation;
+            const requestThreadId = this.activeThread().id;
+            try {
+                await this.postChat({ kind: "user", text: cleanTask }, requestThreadId);
+                if (requestCancellation.token.isCancellationRequested) {
+                    await this.postChat({ kind: "status", text: "Cancelled." }, requestThreadId);
+                    return;
+                }
+                await this.postChat({ kind: "status", text: "Asking AI provider..." }, requestThreadId);
+                const abortController = new AbortController();
+                const abortSubscription = requestCancellation.token.onCancellationRequested(() => abortController.abort());
+                try {
+                    this.post({ type: "assistantStart" });
+                    const chatAnswer = await this.gateway.askDirectChatStream(cleanTask, (chunk) => this.post({ type: "assistantDelta", text: chunk }), abortController.signal, conn.provider);
+                    if (requestCancellation.token.isCancellationRequested) {
+                        await this.postChat({ kind: "status", text: "Cancelled." }, requestThreadId);
+                        return;
+                    }
+                    await this.postChat({ kind: "assistant", text: chatAnswer.message }, requestThreadId);
+                }
+                finally {
+                    abortSubscription.dispose();
+                }
+            }
+            catch (error) {
+                if (requestCancellation.token.isCancellationRequested || isCancellationError(error)) {
+                    await this.postChat({ kind: "status", text: "Cancelled." }, requestThreadId);
+                    return;
+                }
+                const msg = error instanceof Error ? error.message : String(error);
+                await this.postChat({ kind: "error", text: msg }, requestThreadId);
+            }
+            finally {
+                if (this.askCancellation === requestCancellation) {
+                    this.askCancellation = undefined;
+                }
+                requestCancellation.dispose();
+            }
+            return;
+        }
+        const folders = vscode.workspace.workspaceFolders;
+        if (!folders || folders.length === 0) {
+            await this.postChat({ kind: "error", text: "Open a workspace folder before using FlowSeeker Chat." });
+            return;
+        }
+        this.askCancellation?.cancel();
+        this.askCancellation?.dispose();
+        const requestCancellation = new vscode.CancellationTokenSource();
+        this.askCancellation = requestCancellation;
+        const requestThreadId = this.activeThread().id;
+        try {
+            await this.postChat({ kind: "user", text: cleanTask }, requestThreadId);
+            await this.postChat({ kind: "status", text: "Finding relevant files before contacting the agent..." }, requestThreadId);
+            (0, logger_1.logInfo)(`Chat scan started for task: ${cleanTask}`);
+            const result = await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Notification,
+                title: "FlowSeeker is preparing agent context",
+                cancellable: true
+            }, async (progress, progressToken) => {
+                progress.report({ message: "Retrieving relevant context..." });
+                const linkedCancellation = new vscode.CancellationTokenSource();
+                const disposables = [
+                    progressToken.onCancellationRequested(() => linkedCancellation.cancel()),
+                    requestCancellation.token.onCancellationRequested(() => linkedCancellation.cancel())
+                ];
+                try {
+                    return await (0, runPipeline_1.runFlowSeeker)(cleanTask, { progress, token: linkedCancellation.token });
+                }
+                finally {
+                    disposables.forEach((disposable) => disposable.dispose());
+                    linkedCancellation.dispose();
+                }
+            });
+            if (requestCancellation.token.isCancellationRequested) {
+                await this.postChat({ kind: "status", text: "Cancelled." }, requestThreadId);
+                return;
+            }
+            this.resultProvider.setResult(result);
+            const fileSummary = formatFileSummary(result);
+            const tokenMetric = formatTokenMetric(result);
+            const workspace = folders[0];
+            const feedback = (0, feedback_1.createFeedbackSnapshot)(result, workspace.uri.fsPath, workspace.name);
+            await this.postChat({
+                kind: "retrieval",
+                text: fileSummary,
+                metric: tokenMetric,
+                feedback,
+                files: (0, fileGroups_1.aggregateEvidenceFiles)(result.units)
+                    .slice(0, 12)
+                    .map((group) => ({
+                    path: group.relativePath,
+                    role: group.role,
+                    score: group.score.toFixed(1),
+                    evidence: group.unitCount
+                }))
+            }, requestThreadId);
+            const connection = await this.gateway.getConnection();
+            if (!connection.connected) {
+                await this.postChat({
+                    kind: "assistant",
+                    text: "Retrieval is ready. Configure an AI provider to ask an agent, or copy the agent prompt and paste it into your current AI tool."
+                }, requestThreadId);
+                return;
+            }
+            await this.postChat({ kind: "status", text: mode === "auto" ? "Asking AI provider for a reviewable plan..." : "Asking AI provider for guidance..." }, requestThreadId);
+            if (requestCancellation.token.isCancellationRequested) {
+                await this.postChat({ kind: "status", text: "Cancelled." }, requestThreadId);
+                return;
+            }
+            let answer;
+            if (mode === "auto") {
+                answer = await this.gateway.ask(result, mode);
+            }
+            else {
+                const abortController = new AbortController();
+                const abortSubscription = requestCancellation.token.onCancellationRequested(() => abortController.abort());
+                try {
+                    this.post({ type: "assistantStart" });
+                    answer = await this.gateway.askStream(result, mode, (chunk) => this.post({ type: "assistantDelta", text: chunk }), abortController.signal);
+                }
+                finally {
+                    abortSubscription.dispose();
+                }
+            }
+            if (requestCancellation.token.isCancellationRequested) {
+                await this.postChat({ kind: "status", text: "Cancelled." }, requestThreadId);
+                return;
+            }
+            if (mode === "auto" && !answer.edits?.length && (0, contextExpansion_1.isMissingContextRequest)(answer.message)) {
+                const expanded = await this.expandContextAndRetryPlan(result, answer, requestThreadId);
+                if (expanded) {
+                    answer = expanded;
+                }
+                if (requestCancellation.token.isCancellationRequested) {
+                    await this.postChat({ kind: "status", text: "Cancelled." }, requestThreadId);
+                    return;
+                }
+            }
+            const editProposalId = answer.edits?.length ? this.editStore.store(answer.edits) : undefined;
+            const planProposalId = mode === "auto" && !answer.edits?.length && (0, contextExpansion_1.isReviewablePlan)(answer.message)
+                ? this.planStore.store(result, answer.message)
+                : undefined;
+            const diff = answer.edits?.length ? (0, diffPreview_1.renderDiffPreviewMarkdown)(answer.edits) : "";
+            const planWarning = mode === "auto" && !answer.edits?.length && !planProposalId
+                ? "FlowSeeker did not receive a reviewable implementation plan, so approval is disabled for this response."
+                : "";
+            await this.postChat({
+                kind: "assistant",
+                text: [
+                    answer.patch ? `${answer.message}\n\nPatch proposal:\n\n${answer.patch}` : answer.message,
+                    diff,
+                    planWarning
+                ].filter(Boolean).join("\n\n"),
+                proposal: editProposalId
+                    ? {
+                        id: editProposalId,
+                        kind: "edits",
+                        edits: answer.edits?.map((edit) => ({
+                            file: edit.file,
+                            range: edit.range ? `${edit.range.startLine}:${edit.range.startColumn ?? 1}-${edit.range.endLine}:${edit.range.endColumn ?? 1}` : edit.replaceWholeFile ? "whole file" : "missing range"
+                        }))
+                    }
+                    : planProposalId
+                        ? {
+                            id: planProposalId,
+                            kind: "plan"
+                        }
+                        : undefined,
+                commands: answer.commands,
+                mcpTools: answer.mcpTools
+            }, requestThreadId);
+        }
+        catch (error) {
+            if (requestCancellation.token.isCancellationRequested || isCancellationError(error)) {
+                await this.postChat({ kind: "status", text: "Cancelled." }, requestThreadId);
+                return;
+            }
+            throw error;
+        }
+        finally {
+            if (this.askCancellation === requestCancellation) {
+                this.askCancellation = undefined;
+            }
+            requestCancellation.dispose();
+        }
+    }
+    async cancelActiveRequest() {
+        if (!this.askCancellation) {
+            return;
+        }
+        this.askCancellation.cancel();
+        await this.postChat({ kind: "status", text: "Cancelling current request..." });
+    }
+    async applyEdits(proposalId) {
+        const summary = await this.editStore.apply(proposalId);
+        const policy = (0, approvalPolicy_1.getApprovalPolicy)();
+        const parts = [`Applied ${summary.editCount} edit(s) to ${summary.files.length} file(s).`];
+        if (summary.failedFiles.length > 0) {
+            parts.push(`\n**${summary.failedFiles.length} file(s) failed:**`);
+            for (const failed of summary.failedFiles) {
+                parts.push(`- \`${failed.file}\`: ${failed.reason}`);
+            }
+        }
+        await this.postChat({
+            kind: summary.failedFiles.length > 0 ? "error" : "assistant",
+            text: [
+                parts.join("\n"),
+                policy.safeCommands || policy.allCommands ? "Auto-running verification because safe command auto-approval is enabled." : "Run verification when you are ready."
+            ].join(" "),
+            trace: [
+                "Structured edits applied",
+                ...(summary.failedFiles.length > 0 ? [`${summary.failedFiles.length} file(s) failed to apply`] : []),
+                policy.safeCommands || policy.allCommands ? "Verification auto-started by policy" : "Verification waiting for user"
+            ],
+            verificationFiles: summary.files
+        });
+        if (policy.safeCommands || policy.allCommands) {
+            await this.runVerificationForChat(summary.files);
+        }
+    }
+    async expandContextAndRetryPlan(result, answer, threadId) {
+        const paths = (0, contextExpansion_1.selectContextExpansionPaths)(answer.message, result);
+        if (paths.length === 0) {
+            await this.postChat({
+                kind: "status",
+                text: "The AI requested more context, but FlowSeeker could not identify a bounded file set to read."
+            }, threadId);
+            return undefined;
+        }
+        await this.postChat({
+            kind: "status",
+            text: `AI requested more context. Reading ${paths.length} bounded file(s) and retrying the plan...`
+        }, threadId);
+        const expandedContext = await (0, contextExpansion_1.readWorkspaceContextFiles)(paths);
+        if (!expandedContext.trim()) {
+            await this.postChat({
+                kind: "status",
+                text: "FlowSeeker could not read the requested context files safely."
+            }, threadId);
+            return undefined;
+        }
+        return this.gateway.askWithInstruction(result, "auto", (0, contextExpansion_1.createExpandedPlanInstruction)(answer.message, expandedContext), { stage: "expanded_plan", requestedFiles: paths });
+    }
+    async expandContextAndRetryApprovedEdits(result, approvedPlan, answer, threadId) {
+        const paths = (0, contextExpansion_1.selectContextExpansionPaths)(answer.message, result);
+        if (paths.length === 0) {
+            await this.postChat({
+                kind: "status",
+                text: "The AI requested more edit context, but FlowSeeker could not identify a bounded file set to read."
+            }, threadId);
+            return undefined;
+        }
+        await this.postChat({
+            kind: "status",
+            text: `AI requested more edit context. Reading ${paths.length} bounded file(s) and retrying structured edits...`
+        }, threadId);
+        const expandedContext = await (0, contextExpansion_1.readWorkspaceContextFiles)(paths);
+        if (!expandedContext.trim()) {
+            await this.postChat({
+                kind: "status",
+                text: "FlowSeeker could not read the requested edit context files safely."
+            }, threadId);
+            return undefined;
+        }
+        return this.gateway.askWithInstruction(result, "auto", (0, contextExpansion_1.createExpandedApprovedEditInstruction)(approvedPlan, answer.message, expandedContext), { stage: "expanded_approved_edits", requestedFiles: paths, approvedPlan });
+    }
+    async approvePlan(planId) {
+        const proposal = this.planStore.get(planId);
+        if (!proposal) {
+            await this.postChat({ kind: "error", text: "This plan is no longer available. Run the request again to regenerate it." });
+            return;
+        }
+        const connection = await this.gateway.getConnection();
+        if (!connection.connected) {
+            await this.postChat({ kind: "error", text: "Connect an AI provider before generating edits from the approved plan." });
+            return;
+        }
+        await this.postChat({ kind: "status", text: "Plan approved. Asking AI provider for structured edits..." });
+        let answer = await this.gateway.askWithInstruction(proposal.result, "auto", (0, agentPrompts_1.createApprovedEditInstruction)(proposal.plan), { stage: "approved_edits", approvedPlan: proposal.plan });
+        if (!answer.edits?.length && (0, contextExpansion_1.isMissingContextRequest)(answer.message)) {
+            const expanded = await this.expandContextAndRetryApprovedEdits(proposal.result, proposal.plan, answer, this.activeThread().id);
+            if (expanded) {
+                answer = expanded;
+            }
+        }
+        if (!answer.edits?.length) {
+            await this.postChat({
+                kind: "error",
+                text: [
+                    "The AI provider did not return structured edits FlowSeeker can apply.",
+                    "",
+                    "**What happened:** The provider responded but the output was not in the expected JSON format with file edits.",
+                    "",
+                    "**What to do:**",
+                    "- Try expanding context first (the plan may have mentioned files FlowSeeker did not retrieve yet).",
+                    "- Switch to Guide mode for a text explanation instead of structured edits.",
+                    "- Try a different model — some smaller models struggle with structured JSON output.",
+                    "",
+                    "**Expected JSON shape:**",
+                    '```json',
+                    '{"message":"explanation","edits":[{"file":"relative/path","range":{"startLine":1,"endLine":1},"text":"replacement"}],"commands":[],"mcpTools":[]}',
+                    '```',
+                    answer.message ? `**Provider response preview:**\n\`\`\`\n${(0, contextExpansion_1.truncateForAgent)(answer.message, 1200)}\n\`\`\`` : ""
+                ].filter(Boolean).join("\n"),
+                trace: [
+                    "Plan approved",
+                    "AI response did not contain valid structured edits",
+                    "No workspace files were changed"
+                ],
+                commands: answer.commands,
+                mcpTools: answer.mcpTools
+            });
+            return;
+        }
+        const editProposalId = answer.edits?.length ? this.editStore.store(answer.edits, proposal.allowedFiles) : undefined;
+        const diff = answer.edits?.length ? (0, diffPreview_1.renderDiffPreviewMarkdown)(answer.edits) : "";
+        if (editProposalId && (0, approvalPolicy_1.getApprovalPolicy)().editWorkspace) {
+            const summary = await this.editStore.apply(editProposalId);
+            const policy = (0, approvalPolicy_1.getApprovalPolicy)();
+            await this.postChat({
+                kind: "assistant",
+                text: [
+                    answer.message,
+                    diff,
+                    `Auto-approved and applied ${summary.editCount} edit(s) to ${summary.fileCount} file(s).`,
+                    policy.safeCommands || policy.allCommands ? "Auto-running verification because safe command auto-approval is enabled." : "Run verification when you are ready."
+                ].filter(Boolean).join("\n\n"),
+                trace: [
+                    "Plan approved",
+                    "Structured edits generated",
+                    "Edits applied by auto-approve policy",
+                    policy.safeCommands || policy.allCommands ? "Verification auto-started by policy" : "Verification waiting for user"
+                ],
+                commands: answer.commands,
+                mcpTools: answer.mcpTools,
+                verificationFiles: summary.files
+            });
+            if (policy.safeCommands || policy.allCommands) {
+                await this.runVerificationForChat(summary.files);
+            }
+            return;
+        }
+        await this.postChat({
+            kind: "assistant",
+            text: [
+                answer.message,
+                diff,
+                editProposalId ? "Review the proposed diff before applying. Files are scope-locked to the approved plan." : ""
+            ].filter(Boolean).join("\n\n"),
+            proposal: editProposalId
+                ? {
+                    id: editProposalId,
+                    kind: "edits",
+                    edits: answer.edits?.map((edit) => ({
+                        file: edit.file,
+                        range: edit.range ? `${edit.range.startLine}:${edit.range.startColumn ?? 1}-${edit.range.endLine}:${edit.range.endColumn ?? 1}` : edit.replaceWholeFile ? "whole file" : "missing range"
+                    }))
+                }
+                : undefined,
+            commands: answer.commands,
+            mcpTools: answer.mcpTools
+        });
+    }
+    async openDiff(proposalId) {
+        const folders = vscode.workspace.workspaceFolders;
+        if (!folders?.[0]) {
+            await this.postChat({ kind: "error", text: "Open a workspace folder before previewing edits." });
+            return;
+        }
+        const files = this.editStore.listFiles(proposalId);
+        if (files.length === 0) {
+            await this.postChat({ kind: "error", text: "Diff preview is no longer available." });
+            return;
+        }
+        const file = files.length === 1
+            ? files[0]
+            : await vscode.window.showQuickPick(files, {
+                title: "FlowSeeker Diff",
+                placeHolder: "Choose a file to preview"
+            });
+        if (!file) {
+            return;
+        }
+        const preview = await this.editStore.previewFile(folders[0].uri, proposalId, file);
+        const document = await vscode.workspace.openTextDocument({
+            language: preview.languageId,
+            content: preview.text
+        });
+        await vscode.commands.executeCommand("vscode.diff", preview.originalUri, document.uri, `FlowSeeker Diff: ${preview.file}`, { preview: false, viewColumn: vscode.ViewColumn.Beside });
+    }
+    async verifyFiles(files) {
+        const changedFiles = [...new Set((files ?? []).filter(Boolean))];
+        if (changedFiles.length === 0) {
+            await this.postChat({ kind: "error", text: "No changed files were provided for verification." });
+            return;
+        }
+        await this.runVerificationForChat(changedFiles);
+    }
+    async runAgentCommand(command) {
+        if (!command?.command?.trim()) {
+            await this.postChat({ kind: "error", text: "No agent command was provided." });
+            return;
+        }
+        await this.postChat({
+            kind: "status",
+            text: `Running agent command: ${command.command}`,
+            trace: ["Agent command requested"]
+        });
+        const run = await (0, commandRunner_1.runAgentCommandProposal)(command);
+        if (!run) {
+            await this.postChat({
+                kind: "status",
+                text: "Agent command was cancelled.",
+                trace: ["Agent command cancelled"]
+            });
+            return;
+        }
+        await this.postChat({
+            kind: run.exitCode === 0 ? "assistant" : "error",
+            text: `${(0, commandRunner_1.summarizeAgentCommandRun)(run)} Review the command result document opened beside the editor.`,
+            trace: [
+                run.classification.safe ? "Command classified as safe" : "Command required explicit approval",
+                "Command completed"
+            ]
+        });
+    }
+    async runMcpTool(tool) {
+        if (!tool?.tool?.trim()) {
+            await this.postChat({ kind: "error", text: "No MCP/tool proposal was provided." });
+            return;
+        }
+        await this.postChat({
+            kind: "status",
+            text: `Invoking MCP/tool: ${tool.tool}`,
+            trace: ["MCP/tool invocation requested"]
+        });
+        const run = await (0, mcpToolRunner_1.runMcpToolProposal)(tool);
+        if (!run) {
+            await this.postChat({
+                kind: "status",
+                text: "MCP/tool invocation was cancelled or unavailable.",
+                trace: ["MCP/tool invocation not completed"]
+            });
+            return;
+        }
+        await this.postChat({
+            kind: "assistant",
+            text: `${(0, mcpToolRunner_1.summarizeMcpToolRun)(run)} Review the tool result document opened beside the editor.`,
+            trace: ["MCP/tool invoked", "Tool result captured"]
+        });
+    }
+    async runVerificationForChat(files) {
+        const changedFiles = [...new Set((files ?? []).filter(Boolean))];
+        await this.postChat({ kind: "status", text: `Running verification for ${changedFiles.length} changed file(s)...` });
+        const run = await (0, verifyAfterApply_1.verifyAfterEdits)(changedFiles);
+        await this.postChat({
+            kind: run ? "assistant" : "error",
+            text: run
+                ? `${(0, verifyAfterApply_1.summarizeVerificationRun)(run)} Review the results document opened beside the editor.`
+                : "Verification could not complete. Check the FlowSeeker log for details.",
+            trace: [
+                "Verification commands detected",
+                run ? "Verification completed" : "Verification failed to run"
+            ],
+            verificationFiles: changedFiles
+        });
+    }
+    async saveFeedback(runId, rawKind) {
+        const kind = (0, feedback_1.normalizeFeedbackKind)(rawKind);
+        if (!kind) {
+            await this.postChat({ kind: "error", text: "Feedback could not be saved because the feedback type was not recognized." });
+            return;
+        }
+        const snapshot = this.findFeedbackSnapshot(runId);
+        if (!snapshot) {
+            await this.postChat({ kind: "error", text: "Feedback could not be saved because this retrieval snapshot is no longer available." });
+            return;
+        }
+        const note = kind === "relevant"
+            ? undefined
+            : await vscode.window.showInputBox({
+                title: "FlowSeeker Feedback",
+                prompt: "Optional: what was missing or wrong?",
+                placeHolder: "Example: missing route file, wrong module, AI needed model/schema...",
+                ignoreFocusOut: true
+            });
+        const record = (0, feedback_1.createFeedbackRecord)(snapshot, kind, { source: "sidebar_chat", note });
+        const savedPath = await (0, feedback_1.writeFeedbackRecord)(snapshot.workspacePath, record);
+        (0, logger_1.logInfo)(`FlowSeeker feedback saved: ${savedPath}`);
+        const replayHint = `Run "FlowSeeker: Run Real-World Replay" to include this feedback in replay metrics.`;
+        await this.postChat({ kind: "assistant", text: `Feedback saved: ${(0, feedback_1.feedbackKindLabel)(kind)}. Saved to ${savedPath}. ${replayHint}` });
+    }
+    async copyAgentPrompt() {
+        const result = this.resultProvider.getResult();
+        if (!result) {
+            await this.postChat({ kind: "error", text: "Run a chat request first." });
+            return;
+        }
+        await vscode.env.clipboard.writeText((0, agentPrompt_1.createAgentSolvePrompt)(result, this.resultProvider.getSelectedUnits()));
+        await this.postChat({ kind: "assistant", text: "Agent prompt copied to clipboard." });
+    }
+    async copyTokenProof() {
+        const result = this.resultProvider.getResult();
+        if (!result) {
+            await this.postChat({ kind: "error", text: "Run a chat request first." });
+            return;
+        }
+        const task = result.profile?.intent ?? "Unknown task";
+        const summary = (0, tokenSavings_1.formatTokenProofSummary)(task, result.tokenSavings, result.contextCoverage);
+        await vscode.env.clipboard.writeText(summary);
+        await this.postChat({ kind: "assistant", text: "Token proof copied to clipboard." });
+    }
+    async openFile(relativePath) {
+        const folders = vscode.workspace.workspaceFolders;
+        if (!folders?.[0]) {
+            return;
+        }
+        const uri = (0, editProposalStore_1.resolveWorkspaceFile)(folders[0].uri, relativePath);
+        await vscode.window.showTextDocument(uri, { preview: true });
+    }
+    async postConnectionState() {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let connection = { connected: false };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let profilesState = { profiles: [] };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let models = [];
+        let usagePayload = undefined;
+        let quotaDebug = -1;
+        try {
+            connection = await this.gateway.getConnection();
+        }
+        catch { /* keep defaults */ }
+        try {
+            profilesState = await this.gateway.listProviderProfiles();
+        }
+        catch { /* keep defaults */ }
+        const providerId = connection.provider;
+        try {
+            if (providerId)
+                models = await this.gateway.listModels(providerId);
+        }
+        catch { /* keep defaults */ }
+        try {
+            if (this.quotaTracker) {
+                const usageSummary = this.quotaTracker.getSummary();
+                usagePayload = this.postUsagePayload(usageSummary ?? null, profilesState.profiles);
+                quotaDebug = usageSummary?.totalRequests ?? -1;
+            }
+        }
+        catch { /* keep defaults */ }
+        this.post({
+            type: "connection",
+            profileId: connection.profileId ?? profilesState.activeProfileId ?? "",
+            connected: connection.connected,
+            endpoint: connection.endpoint ?? "",
+            provider: connection.provider ?? "",
+            providerLabel: connection.providerLabel ?? "",
+            model: connection.model ?? "",
+            baseUrl: connection.baseUrl ?? connection.endpoint ?? "",
+            requiresApiKey: connection.requiresApiKey ?? true,
+            activeProfileId: profilesState.activeProfileId ?? "",
+            profiles: profilesState.profiles,
+            models,
+            usage: usagePayload,
+            quotaDebug
+        });
+    }
+    async refreshConnectionState() {
+        await this.postConnectionState();
+    }
+    postAgentPolicyState() {
+        void this.postAgentPolicyStateAsync();
+    }
+    async postAgentPolicyStateAsync() {
+        const policy = (0, approvalPolicy_1.getApprovalPolicy)();
+        const rules = policy.rules.map((rule) => rule.trim()).filter(Boolean);
+        const servers = await (0, mcpConfig_1.loadMcpServerConfigs)().catch(() => []);
+        const enabledServers = servers.filter((server) => server.enabled !== false);
+        const mcpServerCount = enabledServers.length;
+        const mcpServers = servers.map((server) => ({
+            name: server.name,
+            type: server.type,
+            enabled: server.enabled !== false,
+            valid: server.enabled === false ? true : server.type === "http" ? Boolean(server.url?.trim()) : Boolean(server.command?.trim())
+        }));
+        this.post({
+            type: "agentPolicy",
+            readWorkspace: policy.readWorkspace,
+            editWorkspace: policy.editWorkspace,
+            safeCommands: policy.safeCommands,
+            allCommands: policy.allCommands,
+            mcpTools: policy.mcpTools,
+            mcpServerCount,
+            mcpServers,
+            rules,
+            rulesCount: rules.length
+        });
+    }
+    async openAgentSettings() {
+        await vscode.commands.executeCommand("workbench.action.openSettings", "@ext:everestt2806.flowseeker agent");
+    }
+    async updateAgentPolicy(message) {
+        const current = (0, approvalPolicy_1.getApprovalPolicy)();
+        if (message.allCommands && !current.allCommands) {
+            const action = await vscode.window.showWarningMessage("FlowSeeker will be allowed to auto-approve non-destructive arbitrary commands. Destructive commands still require explicit approval.", { modal: true }, "Enable", "Cancel");
+            if (action !== "Enable") {
+                this.postAgentPolicyState();
+                return;
+            }
+        }
+        const config = vscode.workspace.getConfiguration("flowseeker");
+        const target = vscode.ConfigurationTarget.Global;
+        const rules = (message.rulesText ?? "")
+            .split(/\r?\n/)
+            .map((rule) => rule.trim())
+            .filter(Boolean);
+        await config.update("agent.autoApprove.readWorkspace", Boolean(message.readWorkspace), target);
+        await config.update("agent.autoApprove.editWorkspace", Boolean(message.editWorkspace), target);
+        await config.update("agent.autoApprove.safeCommands", Boolean(message.safeCommands), target);
+        await config.update("agent.autoApprove.allCommands", Boolean(message.allCommands), target);
+        await config.update("agent.autoApprove.mcpTools", Boolean(message.mcpTools), target);
+        await config.update("agent.rules", rules, target);
+        this.postAgentPolicyState();
+    }
+    post(message) {
+        void this.view?.webview.postMessage(message);
+    }
+    postGatewayFeedback(status, text) {
+        this.post({ type: "gatewayFeedback", status, text });
+    }
+    postUsagePayload(usageSummary, profiles) {
+        const now = Date.now();
+        const todayStart = new Date();
+        todayStart.setHours(0, 0, 0, 0);
+        const tomorrow = new Date(todayStart);
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        const nextMonth = new Date(todayStart.getFullYear(), todayStart.getMonth() + 1, 1);
+        const dailyResetMs = tomorrow.getTime();
+        const monthlyResetMs = nextMonth.getTime();
+        if (!usageSummary) {
+            // Return empty usage with just connected profiles
+            if (!profiles.length)
+                return undefined;
+            return {
+                todayCostUSD: 0,
+                weekCostUSD: 0,
+                totalCostUSD: 0,
+                totalRequests: 0,
+                models: profiles.map((p) => ({
+                    provider: p.provider,
+                    model: p.model,
+                    dailyTokensUsed: -1,
+                    dailyTokenLimit: -1,
+                    dailyPct: -1,
+                    quotaSource: "unknown",
+                    monthlyCostUsed: 0,
+                    monthlyCostLimit: 10,
+                    monthlyPct: 0,
+                    requestsToday: 0,
+                    dailyResetMs,
+                    monthlyResetMs
+                }))
+            };
+        }
+        // Merge usage data with all connected profiles
+        const usageByKey = new Map();
+        for (const m of usageSummary.models) {
+            usageByKey.set(`${m.provider}|${m.model}`, m);
+        }
+        const mergedModels = profiles.map((p) => {
+            const key = `${p.provider}|${p.model}`;
+            const existing = usageByKey.get(key);
+            if (existing)
+                return existing;
+            return {
+                provider: p.provider,
+                model: p.model,
+                dailyTokensUsed: -1,
+                dailyTokenLimit: -1,
+                dailyPct: -1,
+                quotaSource: "unknown",
+                monthlyCostUsed: 0,
+                monthlyCostLimit: 10,
+                monthlyPct: 0,
+                requestsToday: 0,
+                dailyResetMs,
+                monthlyResetMs
+            };
+        });
+        // Also include any models with usage that aren't in profiles
+        for (const m of usageSummary.models) {
+            const key = `${m.provider}|${m.model}`;
+            if (!profiles.some((p) => `${p.provider}|${p.model}` === key)) {
+                mergedModels.push(m);
+            }
+        }
+        return {
+            todayCostUSD: usageSummary.todayCostUSD,
+            weekCostUSD: usageSummary.thisWeekCostUSD,
+            totalCostUSD: usageSummary.totalCostUSD,
+            totalRequests: usageSummary.totalRequests,
+            models: mergedModels
+        };
+    }
+    async postChat(message, threadId = this.activeThreadId) {
+        const thread = this.threadById(threadId) ?? this.ensureActiveThread();
+        thread.messages.push(message);
+        if (thread.messages.length > maxHistoryMessages) {
+            thread.messages = thread.messages.slice(-maxHistoryMessages);
+        }
+        if (message.kind === "user" && (thread.title === "New chat" || thread.messages.filter((item) => item.kind === "user").length === 1)) {
+            thread.title = titleFromMessage(message.text);
+        }
+        thread.updatedAt = new Date().toISOString();
+        this.sortThreads();
+        await this.saveThreads();
+        if (thread.id === this.activeThreadId) {
+            this.post(renderHistoryMessage(message));
+        }
+        this.postThreadList();
+    }
+    async restoreThreads() {
+        const loaded = this.loadThreads();
+        this.threads = loaded.threads;
+        this.activeThreadId = loaded.activeThreadId;
+        await this.saveThreads();
+        this.postThreadState();
+    }
+    async createNewThread() {
+        const thread = createThread();
+        this.threads.unshift(thread);
+        this.trimThreads();
+        this.activeThreadId = thread.id;
+        await this.saveThreads();
+        this.postThreadState();
+    }
+    async selectThread(threadId) {
+        if (!this.threads.some((thread) => thread.id === threadId)) {
+            return;
+        }
+        this.activeThreadId = threadId;
+        await this.context.workspaceState.update(activeThreadStateKey, this.activeThreadId);
+        this.postThreadState();
+    }
+    async deleteThread(threadId) {
+        this.threads = this.threads.filter((thread) => thread.id !== threadId);
+        if (this.threads.length === 0) {
+            this.threads = [createThread()];
+        }
+        if (this.activeThreadId === threadId || !this.threads.some((thread) => thread.id === this.activeThreadId)) {
+            this.activeThreadId = this.threads[0].id;
+        }
+        await this.saveThreads();
+        this.postThreadState();
+    }
+    loadThreads() {
+        let threads = this.context.workspaceState.get(threadsStateKey, []);
+        const legacyHistory = this.context.workspaceState.get(legacyHistoryStateKey, []);
+        if (threads.length === 0 && legacyHistory.length > 0) {
+            const now = new Date().toISOString();
+            threads = [{
+                    id: createThreadId(),
+                    title: titleFromMessage(legacyHistory.find((message) => message.kind === "user")?.text ?? "Imported chat"),
+                    createdAt: now,
+                    updatedAt: now,
+                    messages: legacyHistory.slice(-maxHistoryMessages)
+                }];
+        }
+        if (threads.length === 0) {
+            threads = [createThread()];
+        }
+        threads = normalizeThreads(threads);
+        const storedActive = this.context.workspaceState.get(activeThreadStateKey);
+        const activeThreadId = storedActive && threads.some((thread) => thread.id === storedActive)
+            ? storedActive
+            : threads[0].id;
+        return { threads, activeThreadId };
+    }
+    ensureActiveThread() {
+        const existing = this.threads.find((thread) => thread.id === this.activeThreadId);
+        if (existing) {
+            return existing;
+        }
+        const thread = createThread();
+        this.threads.unshift(thread);
+        this.activeThreadId = thread.id;
+        return thread;
+    }
+    activeThread() {
+        return this.ensureActiveThread();
+    }
+    threadById(threadId) {
+        return this.threads.find((thread) => thread.id === threadId);
+    }
+    async saveThreads() {
+        this.sortThreads();
+        this.trimThreads();
+        await this.context.workspaceState.update(threadsStateKey, this.threads);
+        await this.context.workspaceState.update(activeThreadStateKey, this.activeThreadId);
+    }
+    sortThreads() {
+        this.threads = [...this.threads].sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+    }
+    trimThreads() {
+        if (this.threads.length <= maxChatThreads) {
+            return;
+        }
+        const active = this.threads.find((thread) => thread.id === this.activeThreadId);
+        this.threads = this.threads.slice(0, maxChatThreads);
+        if (active && !this.threads.some((thread) => thread.id === active.id)) {
+            this.threads[this.threads.length - 1] = active;
+        }
+    }
+    postThreadState() {
+        const active = this.activeThread();
+        this.post({
+            type: "threadState",
+            activeThreadId: active.id,
+            threads: this.threadSummaries(),
+            messages: active.messages.map(renderHistoryMessage)
+        });
+    }
+    postThreadList() {
+        this.post({
+            type: "threads",
+            activeThreadId: this.activeThreadId,
+            threads: this.threadSummaries()
+        });
+    }
+    threadSummaries() {
+        return this.threads.map((thread) => ({
+            id: thread.id,
+            title: thread.title,
+            updatedAt: thread.updatedAt,
+            messageCount: thread.messages.length
+        }));
+    }
+    findFeedbackSnapshot(runId) {
+        for (const thread of this.threads) {
+            const snapshot = [...thread.messages].reverse().find((message) => message.feedback?.id === runId)?.feedback;
+            if (snapshot) {
+                return snapshot;
+            }
+        }
+        return undefined;
+    }
+    renderHtml(webview) {
+        const nonce = getNonce();
+        const logoUri = webview.asWebviewUri(vscode.Uri.joinPath(this.context.extensionUri, "resources", "flowseeker-logo-vector-v2.svg"));
+        const providerOptions = aiProviders_1.AI_PROVIDER_DEFINITIONS.map((provider) => `<option value="${provider.id}">${escapeHtml(provider.label)}</option>`).join("");
+        const providerMeta = JSON.stringify(Object.fromEntries(aiProviders_1.AI_PROVIDER_DEFINITIONS.map((provider) => [
+            provider.id,
+            {
+                label: provider.label,
+                defaultBaseUrl: provider.defaultBaseUrl,
+                defaultModel: provider.defaultModel,
+                requiresApiKey: provider.requiresApiKey,
+                apiKeyLabel: provider.apiKeyLabel,
+                apiKeyHint: provider.apiKeyHint ?? "",
+                authMethod: provider.authMethod,
+                oauthConfig: provider.oauthConfig ?? null,
+                supportsModelList: provider.supportsModelList,
+                modelLabel: provider.id === "codexCli" || provider.id === "claudeCode" ? "Model / args" : "Model",
+                baseUrlLabel: provider.id === "codexCli" || provider.id === "claudeCode" ? "Command" : "Base URL",
+                modelPlaceholder: provider.id === "customGateway" ? "deepseek-v4-pro[1m]" : provider.id === "customAnthropic" ? "claude-sonnet-4-5" : provider.id === "codexCli" || provider.id === "claudeCode" ? "default or model name" : provider.defaultModel,
+                baseUrlPlaceholder: provider.id === "customGateway" ? "https://api.example.com/v1" : provider.id === "customAnthropic" ? "https://api.example.com/v1" : provider.defaultBaseUrl
+            }
+        ])));
+        const csp = [
+            "default-src 'none'",
+            `img-src ${webview.cspSource}`,
+            `style-src ${webview.cspSource} 'unsafe-inline'`,
+            `script-src 'nonce-${nonce}'`
+        ].join("; ");
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta http-equiv="Content-Security-Policy" content="${csp}">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>FlowSeeker Chat</title>
+  <style>
+    :root {
+      color-scheme: light dark;
+      --border: var(--vscode-widget-border, color-mix(in srgb, var(--vscode-foreground) 17%, transparent));
+      --muted: var(--vscode-descriptionForeground);
+      --bg: var(--vscode-sideBar-background);
+      --panel: var(--vscode-editor-background);
+      --panel-alt: var(--vscode-editorWidget-background, var(--vscode-sideBar-background));
+      --input: var(--vscode-input-background);
+      --input-border: var(--vscode-input-border, var(--vscode-widget-border));
+      --button: color-mix(in srgb, var(--vscode-foreground) 14%, var(--panel-alt));
+      --button-hover: color-mix(in srgb, var(--vscode-foreground) 20%, var(--panel-alt));
+      --button-fg: var(--vscode-foreground);
+      --surface: color-mix(in srgb, var(--panel) 44%, var(--bg));
+      --surface-raised: color-mix(in srgb, var(--panel-alt) 72%, var(--bg));
+      --surface-hover: color-mix(in srgb, var(--vscode-foreground) 7%, transparent);
+      --hairline: color-mix(in srgb, var(--border) 68%, transparent);
+      --secondary-button: var(--vscode-button-secondaryBackground);
+      --secondary-button-fg: var(--vscode-button-secondaryForeground);
+      --focus: var(--vscode-focusBorder);
+      --danger: var(--vscode-errorForeground);
+      --link: var(--vscode-textLink-foreground);
+      --success: var(--vscode-testing-iconPassed, #2ea043);
+      --success-bg: color-mix(in srgb, var(--success) 10%, var(--bg));
+      --success-border: color-mix(in srgb, var(--success) 36%, transparent);
+      --row-hover: var(--vscode-list-hoverBackground, color-mix(in srgb, var(--vscode-foreground) 7%, transparent));
+      --row-active: color-mix(in srgb, var(--vscode-foreground) 12%, transparent);
+      --toggle-active: color-mix(in srgb, var(--vscode-foreground) 16%, var(--panel-alt));
+      --accent-bg: color-mix(in srgb, var(--vscode-foreground) 6%, transparent);
+      --assistant-bg: transparent;
+      --user-bg: color-mix(in srgb, var(--vscode-foreground) 8%, var(--panel));
+      --font: var(--vscode-font-family, system-ui, -apple-system, sans-serif);
+      --mono: var(--vscode-editor-font-family, 'Cascadia Code', 'Fira Code', 'JetBrains Mono', monospace);
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      background: color-mix(in srgb, var(--bg) 74%, var(--panel));
+      color: var(--vscode-foreground);
+      font-family: var(--font);
+      font-size: 13px;
+      line-height: 1.5;
+      height: 100vh;
+      min-width: 300px;
+      display: flex;
+      flex-direction: column;
+      overflow: hidden;
+    }
+
+    /* Header */
+    .header {
+      display: flex; align-items: center; gap: 8px;
+      min-height: 40px;
+      padding: 7px 10px;
+      border-bottom: 1px solid var(--hairline);
+      background: color-mix(in srgb, var(--panel) 62%, var(--bg));
+      flex-shrink: 0;
+    }
+    .brand {
+      width: 24px; height: 24px;
+      border-radius: 6px;
+      display: flex; align-items: center; justify-content: center;
+      background: var(--surface-raised);
+      border: 1px solid var(--hairline);
+      flex-shrink: 0;
+      overflow: hidden;
+    }
+    .brand img { width: 18px; height: 18px; display: block; }
+    .wordmark {
+      font-family: var(--mono);
+      font-size: 14px;
+      font-weight: 1000;
+      line-height: .95;
+      letter-spacing: .045em;
+      text-transform: uppercase;
+      transform: scaleX(1.08) scaleY(1.2);
+      transform-origin: left center;
+      position: relative;
+      display: inline-block;
+      color: var(--vscode-foreground);
+      -webkit-text-fill-color: var(--vscode-foreground);
+      -webkit-text-stroke: .45px color-mix(in srgb, var(--vscode-foreground) 62%, transparent);
+      text-shadow:
+        1px 0 0 #ff004c,
+        -1px 0 0 #00e5ff,
+        0 1px 0 #7cff00,
+        0 0 8px color-mix(in srgb, #00e5ff 44%, transparent),
+        0 0 18px color-mix(in srgb, #ff004c 32%, transparent);
+      image-rendering: pixelated;
+      animation: wordmarkRgbPulse 2.8s ease-in-out infinite;
+    }
+    .wordmark::before,
+    .wordmark::after {
+      content: attr(data-text);
+      position: absolute;
+      inset: 0;
+      pointer-events: none;
+      -webkit-text-fill-color: transparent;
+      color: transparent;
+      mix-blend-mode: screen;
+      opacity: .9;
+    }
+    .wordmark::before {
+      -webkit-text-stroke: 1px #ff004c;
+      text-shadow: 0 0 8px #ff004c, 0 0 18px #ff004c;
+      animation: wordmarkRgbRed 1.8s steps(2, end) infinite;
+    }
+    .wordmark::after {
+      -webkit-text-stroke: 1px #00e5ff;
+      text-shadow: 0 0 8px #00e5ff, 0 0 18px #00e5ff;
+      animation: wordmarkRgbCyan 1.8s steps(2, end) infinite;
+    }
+    @keyframes wordmarkRgbPulse {
+      0%, 100% {
+        text-shadow:
+          1px 0 0 #ff004c,
+          -1px 0 0 #00e5ff,
+          0 1px 0 #7cff00,
+          0 0 8px color-mix(in srgb, #00e5ff 44%, transparent),
+          0 0 18px color-mix(in srgb, #ff004c 32%, transparent);
+      }
+      50% {
+        text-shadow:
+          2px 0 0 #ff004c,
+          -2px 0 0 #00e5ff,
+          0 1px 0 #7cff00,
+          0 0 12px color-mix(in srgb, #7cff00 42%, transparent),
+          0 0 24px color-mix(in srgb, #00e5ff 34%, transparent);
+      }
+    }
+    @keyframes wordmarkRgbRed {
+      0%, 100% { transform: translate(-1px, 0); opacity: .55; }
+      50% { transform: translate(1px, -1px); opacity: .95; }
+    }
+    @keyframes wordmarkRgbCyan {
+      0%, 100% { transform: translate(1px, 0); opacity: .55; }
+      50% { transform: translate(-1px, 1px); opacity: .95; }
+    }
+    .title { font-weight: 650; font-size: 13px; letter-spacing: 0; }
+    .spacer { flex: 1; }
+    .header button {
+      width: 26px; height: 26px;
+      border: 0; border-radius: 6px;
+      background: transparent;
+      color: var(--muted);
+      cursor: pointer;
+      display: flex; align-items: center; justify-content: center;
+      font-size: 14px;
+      transition: background .15s, color .15s;
+    }
+    .header button:hover { background: var(--surface-hover); color: var(--vscode-foreground); }
+
+    .status-line {
+      display: flex;
+      align-items: center;
+      gap: 7px;
+      padding: 5px 10px;
+      font-size: 11px; color: var(--muted);
+      border-bottom: 1px solid var(--hairline);
+      background: color-mix(in srgb, var(--panel) 28%, var(--bg));
+      flex-shrink: 0;
+      overflow: hidden;
+    }
+    .status-badge {
+      font-size: 9px;
+      font-weight: 700;
+      text-transform: uppercase;
+      letter-spacing: 0.5px;
+      padding: 1px 6px;
+      border-radius: 4px;
+      background: color-mix(in srgb, var(--muted) 25%, transparent);
+      color: var(--muted);
+      flex: 0 0 auto;
+    }
+    .status-line.connected .status-badge {
+      background: color-mix(in srgb, var(--vscode-terminal-ansiGreen) 25%, transparent);
+      color: var(--vscode-terminal-ansiGreen);
+    }
+    .status-text { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+
+    .quota-panel {
+      display: none;
+      border-bottom: 1px solid var(--hairline);
+      background: var(--surface);
+      flex-shrink: 0;
+    }
+    .quota-panel.open { display: block; }
+    .quota-header {
+      display: flex; align-items: center; gap: 6px;
+      padding: 6px 10px;
+      cursor: pointer;
+      font-size: 11px; color: var(--muted);
+      user-select: none;
+    }
+    .quota-header:hover { color: var(--vscode-foreground); }
+    .quota-header .chevron { font-size: 9px; transition: transform .15s; }
+    .quota-header .chevron.open { transform: rotate(90deg); }
+    .quota-summary-text { flex: 1; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+    .quota-badge {
+      padding: 1px 7px; border-radius: 999px;
+      font-size: 10px; font-weight: 700;
+    }
+    .quota-badge.ok { background: color-mix(in srgb, var(--vscode-foreground) 10%, transparent); color: var(--vscode-foreground); }
+    .quota-badge.warn { background: color-mix(in srgb, #d29922 15%, transparent); color: #d29922; }
+    .quota-badge.danger { background: color-mix(in srgb, var(--danger) 15%, transparent); color: var(--danger); }
+    .quota-detail {
+      display: none;
+      padding: 0 10px 8px;
+    }
+    .quota-detail.open { display: block; }
+    .quota-row {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      gap: 4px 10px;
+      align-items: center;
+      padding: 4px 0;
+      font-size: 11px;
+      border-bottom: 1px solid color-mix(in srgb, var(--hairline) 50%, transparent);
+    }
+    .quota-row:last-child { border-bottom: 0; }
+    .quota-model-name { font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+    .quota-stats { color: var(--muted); font-size: 10px; grid-column: 1 / -1; }
+    .quota-bar-wrap {
+      grid-column: 1 / -1;
+      height: 4px;
+      border-radius: 2px;
+      background: color-mix(in srgb, var(--vscode-foreground) 8%, transparent);
+      overflow: hidden;
+    }
+    .quota-bar-fill {
+      height: 100%;
+      border-radius: 2px;
+      transition: width .4s ease;
+    }
+    .quota-bar-fill.low { background: var(--vscode-foreground); opacity: .6; }
+    .quota-bar-fill.mid { background: #d29922; }
+    .quota-bar-fill.high { background: var(--danger); }
+
+    .agent-policy {
+      display: grid;
+      grid-template-columns: auto minmax(0, 1fr);
+      grid-template-areas:
+        "main main"
+        "actions quota";
+      align-items: center;
+      gap: 5px 8px;
+      padding: 6px 10px;
+      border-top: 1px solid var(--hairline);
+      background: color-mix(in srgb, var(--panel) 38%, var(--bg));
+      color: var(--muted);
+      font-size: 11px;
+      flex-shrink: 0;
+    }
+    .agent-policy-main {
+      grid-area: main;
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      min-width: 0;
+    }
+    .agent-policy-actions {
+      grid-area: actions;
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 6px;
+      width: 132px;
+    }
+    .agent-policy-label {
+      color: var(--vscode-foreground);
+      font-weight: 700;
+      flex: 0 0 auto;
+    }
+    .agent-policy-text {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      min-width: 0;
+    }
+    .agent-policy button {
+      width: 100%;
+      border: 0;
+      border-radius: 5px;
+      background: transparent;
+      color: var(--muted);
+      cursor: pointer;
+      font-size: 11px;
+      padding: 3px 6px;
+      text-align: center;
+    }
+    .agent-policy button:hover {
+      background: var(--surface-hover);
+      color: var(--vscode-foreground);
+    }
+    .agent-policy .quota-panel {
+      grid-area: quota;
+      display: block;
+      min-width: 0;
+      border: 0;
+      background: transparent;
+    }
+    .agent-policy .quota-panel:not(.open) {
+      display: block;
+    }
+    .agent-policy .quota-header {
+      min-height: 23px;
+      padding: 2px 0;
+    }
+    .agent-policy .quota-detail {
+      grid-column: 1 / -1;
+      padding: 4px 0 0;
+    }
+    .agent-policy.relaxed .agent-policy-label { color: var(--success); }
+    .agent-policy.risky .agent-policy-label { color: var(--vscode-testing-iconQueued, #d29922); }
+
+
+    .thread-panel {
+      display: none;
+      border-bottom: 1px solid var(--hairline);
+      background: var(--surface);
+      max-height: 300px;
+      overflow-y: auto;
+      flex-shrink: 0;
+    }
+    .thread-panel.open { display: block; }
+    .thread-panel-head {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      padding: 8px 10px 4px;
+      color: var(--muted);
+      font-size: 11px;
+      font-weight: 650;
+      text-transform: uppercase;
+      letter-spacing: .04em;
+    }
+    .thread-list {
+      display: flex;
+      flex-direction: column;
+      gap: 2px;
+      padding: 0 8px 8px;
+    }
+    .thread-row {
+      display: grid;
+      grid-template-columns: 1fr auto;
+      gap: 8px;
+      align-items: center;
+      padding: 8px;
+      border-radius: 6px;
+      cursor: pointer;
+      color: var(--vscode-foreground);
+    }
+    .thread-row:hover { background: var(--surface-hover); }
+    .thread-row.active { background: var(--row-active); }
+    .thread-main { min-width: 0; }
+    .thread-title {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      font-size: 12px;
+      font-weight: 600;
+    }
+    .thread-meta {
+      color: var(--muted);
+      font-size: 10px;
+      margin-top: 1px;
+    }
+    .thread-delete {
+      width: 22px;
+      height: 22px;
+      padding: 0;
+      border-radius: 5px;
+      opacity: .55;
+      color: var(--muted);
+      background: transparent;
+    }
+    .thread-row:hover .thread-delete { opacity: 1; }
+    .thread-delete:hover { color: var(--danger); background: color-mix(in srgb, var(--danger) 10%, transparent); }
+
+    .login-panel {
+      display: none;
+      border-bottom: 1px solid var(--hairline);
+      padding: 0 10px 10px;
+      background: var(--bg);
+      gap: 8px;
+      overflow-y: auto;
+      max-height: min(58vh, 520px);
+      flex-shrink: 0;
+    }
+    .login-panel.open { display: grid; }
+    .panel-head {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      align-items: center;
+      gap: 8px;
+      margin: 0 -10px 2px;
+      padding: 8px 10px;
+      border-bottom: 1px solid var(--hairline);
+      background: color-mix(in srgb, var(--panel) 38%, var(--bg));
+    }
+    .panel-head-main { min-width: 0; }
+    .panel-head-title {
+      color: var(--vscode-foreground);
+      font-size: 11px;
+      font-weight: 800;
+      text-transform: uppercase;
+      letter-spacing: .04em;
+    }
+    .panel-head-subtitle {
+      margin-top: 1px;
+      color: var(--muted);
+      font-size: 10px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .panel-close {
+      width: 24px;
+      height: 24px;
+      padding: 0;
+      border-radius: 6px;
+      background: transparent;
+      color: var(--muted);
+    }
+    .panel-close:hover { background: var(--surface-hover); color: var(--vscode-foreground); }
+    .login-panel label {
+      display: grid;
+      gap: 3px;
+      color: var(--muted);
+      font-size: 11px;
+      font-weight: 600;
+    }
+    .login-panel input,
+    .login-panel select {
+      border: 1px solid var(--hairline);
+      background: var(--input);
+      color: var(--vscode-input-foreground);
+      border-radius: 7px; padding: 6px 8px;
+      font-size: 12px; font-family: var(--font);
+      min-width: 0;
+    }
+    .login-row {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 6px;
+    }
+    .login-row button {
+      flex: 1 1 110px;
+      min-width: 0;
+    }
+    .key-saved { color: var(--vscode-terminal-ansiGreen); }
+    .key-saved::placeholder { color: var(--vscode-terminal-ansiGreen); opacity: 0.7; }
+    .agent-control-panel {
+      display: grid;
+      gap: 7px;
+      margin-top: 4px;
+      padding-top: 9px;
+      border-top: 1px solid var(--hairline);
+    }
+    #agentControls {
+      display: none;
+      border-bottom: 1px solid var(--hairline);
+      padding: 0 10px 10px;
+      background: var(--bg);
+      gap: 8px;
+      overflow-y: auto;
+      max-height: min(58vh, 520px);
+      flex-shrink: 0;
+    }
+    #agentControls.open { display: grid; }
+    .panel-section-title {
+      color: var(--vscode-foreground);
+      font-size: 11px;
+      font-weight: 800;
+      text-transform: uppercase;
+      letter-spacing: .04em;
+    }
+    .toggle-row {
+      display: grid !important;
+      grid-template-columns: auto minmax(0, 1fr);
+      align-items: start;
+      gap: 8px !important;
+      color: var(--vscode-foreground) !important;
+      font-size: 12px !important;
+      font-weight: 500 !important;
+      line-height: 1.35;
+    }
+    .toggle-row input {
+      width: 14px;
+      height: 14px;
+      margin: 1px 0 0;
+      accent-color: var(--vscode-foreground);
+    }
+    .toggle-row strong {
+      display: block;
+      font-size: 12px;
+      font-weight: 650;
+    }
+    .toggle-row span span {
+      display: block;
+      margin-top: 1px;
+      color: var(--muted);
+      font-size: 10px;
+    }
+    .agent-rules {
+      display: grid;
+      gap: 4px;
+    }
+    .agent-rules textarea {
+      min-height: 68px;
+      max-height: 160px;
+      resize: vertical;
+      border: 1px solid var(--hairline);
+      background: var(--input);
+      color: var(--vscode-input-foreground);
+      border-radius: 7px;
+      padding: 7px 8px;
+      font-size: 12px;
+      font-family: var(--font);
+      line-height: 1.4;
+      outline: none;
+    }
+    .agent-rules textarea:focus {
+      border-color: color-mix(in srgb, var(--vscode-foreground) 28%, var(--hairline));
+    }
+    .gateway-status {
+      display: grid;
+      grid-template-columns: auto minmax(0, 1fr);
+      align-items: center;
+      gap: 8px;
+      border: 1px solid var(--hairline);
+      border-radius: 7px;
+      background: color-mix(in srgb, var(--panel) 46%, transparent);
+      padding: 8px;
+      color: var(--muted);
+      font-size: 11px;
+    }
+    .gateway-dot {
+      width: 9px;
+      height: 9px;
+      border-radius: 999px;
+      background: color-mix(in srgb, var(--muted) 55%, transparent);
+    }
+    .gateway-status.connected .gateway-dot { background: var(--success); }
+    .gateway-status.testing .gateway-dot {
+      background: var(--vscode-testing-iconQueued, #d29922);
+      animation: pulseDot 1s ease-in-out infinite;
+    }
+    @keyframes pulseDot { 50% { opacity: .35; transform: scale(.8); } }
+    .gateway-status-text {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .gateway-feedback {
+      display: none;
+      border: 1px solid var(--hairline);
+      border-radius: 7px;
+      padding: 8px;
+      font-size: 11px;
+      line-height: 1.35;
+    }
+    .gateway-feedback.show { display: block; }
+    .gateway-feedback.success {
+      color: var(--success);
+      border-color: var(--success-border);
+      background: var(--success-bg);
+    }
+    .gateway-feedback.error {
+      color: var(--danger);
+      border-color: color-mix(in srgb, var(--danger) 35%, transparent);
+      background: color-mix(in srgb, var(--danger) 8%, var(--bg));
+    }
+    .gateway-feedback.warning {
+      color: var(--vscode-testing-iconQueued, #d29922);
+      border-color: color-mix(in srgb, var(--vscode-testing-iconQueued, #d29922) 35%, transparent);
+      background: color-mix(in srgb, var(--vscode-testing-iconQueued, #d29922) 10%, var(--bg));
+    }
+    .gateway-feedback.info {
+      color: var(--muted);
+      background: color-mix(in srgb, var(--panel) 46%, transparent);
+    }
+    .profile-list {
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+      margin-bottom: 4px;
+    }
+    .profile-empty {
+      color: var(--muted);
+      font-size: 11px;
+      padding: 6px 2px 2px;
+    }
+    .profile-row {
+      display: grid;
+      grid-template-columns: 1fr auto;
+      gap: 8px;
+      align-items: center;
+      border: 1px solid var(--hairline);
+      background: color-mix(in srgb, var(--panel) 46%, transparent);
+      border-radius: 7px;
+      padding: 8px;
+      cursor: pointer;
+    }
+    .profile-row:hover { background: var(--surface-hover); }
+    .profile-row.active {
+      border-color: color-mix(in srgb, var(--vscode-foreground) 20%, var(--hairline));
+      background: color-mix(in srgb, var(--vscode-foreground) 8%, var(--panel-alt));
+    }
+    .profile-main { min-width: 0; }
+    .profile-name {
+      font-size: 12px;
+      font-weight: 700;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .profile-meta {
+      margin-top: 1px;
+      color: var(--muted);
+      font-size: 10px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      font-family: var(--mono);
+    }
+    .profile-actions {
+      display: flex;
+      gap: 4px;
+      align-items: center;
+    }
+    .profile-state {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: color-mix(in srgb, var(--muted) 55%, transparent);
+    }
+    .profile-row.connected .profile-state { background: var(--success); }
+
+    /* Messages area */
+    .messages {
+      flex: 1; overflow-y: auto;
+      padding: 10px 10px 14px;
+      display: flex; flex-direction: column; gap: 4px;
+      background: color-mix(in srgb, var(--bg) 70%, var(--panel));
+    }
+    .messages::-webkit-scrollbar { width: 6px; }
+    .messages::-webkit-scrollbar-thumb {
+      background: color-mix(in srgb, var(--muted) 35%, transparent);
+      border-radius: 3px;
+    }
+
+    .empty-state {
+      margin: auto;
+      text-align: center;
+      color: var(--muted);
+      padding: 24px 16px;
+    }
+    .empty-state .brand-lg {
+      display: none;
+    }
+    .brand-lg img { width: 32px; height: 32px; display: block; }
+    .empty-title .wordmark {
+      display: inline-block;
+      font-size: clamp(30px, 12vw, 46px);
+      letter-spacing: .035em;
+      transform: scaleX(1.12) scaleY(1.24);
+      margin-bottom: 10px;
+    }
+    .empty-title { margin-bottom: 12px; }
+    .empty-title { font-weight: 650; font-size: 15px; color: var(--vscode-foreground); }
+    .empty-hint { font-size: 12px; line-height: 1.6; }
+
+    /* Message row */
+    .msg-row {
+      display: flex;
+      gap: 9px;
+      padding: 8px 2px;
+      animation: fadeIn .16s ease;
+    }
+    @keyframes fadeIn { from { opacity: 0; transform: translateY(3px); } }
+    .msg-row.user { flex-direction: row-reverse; }
+    .msg-avatar {
+      width: 24px; height: 24px;
+      border-radius: 7px;
+      display: flex; align-items: center; justify-content: center;
+      flex-shrink: 0;
+      font-weight: 650; font-size: 10px;
+      border: 1px solid var(--hairline);
+      user-select: none;
+      overflow: hidden;
+    }
+    .msg-avatar img { width: 17px; height: 17px; display: block; }
+    .msg-row.assistant .msg-avatar,
+    .msg-row.status .msg-avatar,
+    .msg-row.retrieval .msg-avatar {
+      background: var(--surface-raised);
+      color: var(--vscode-foreground);
+      border-color: var(--hairline);
+    }
+    .msg-row.user .msg-avatar {
+      background: color-mix(in srgb, var(--vscode-foreground) 9%, var(--surface-raised));
+      color: var(--vscode-foreground);
+      border-color: var(--hairline);
+    }
+    .msg-row.error .msg-avatar {
+      color: var(--danger); border-color: var(--danger);
+      background: color-mix(in srgb, var(--danger) 10%, var(--bg));
+    }
+
+    .msg-body { flex: 1; min-width: 0; max-width: calc(100% - 33px); }
+    .msg-row.user .msg-body { display: flex; flex-direction: column; align-items: flex-end; }
+    .msg-label {
+      color: var(--muted);
+      font-size: 10px;
+      font-weight: 650;
+      line-height: 1.2;
+      margin: 0 0 4px;
+      text-transform: uppercase;
+      letter-spacing: .04em;
+    }
+
+    /* Chat bubbles */
+    .bubble {
+      border-radius: 8px;
+      padding: 8px 10px;
+      line-height: 1.55;
+      overflow-wrap: anywhere;
+      position: relative;
+    }
+    .msg-row.assistant .bubble,
+    .msg-row.retrieval .bubble {
+      background: var(--assistant-bg);
+      border: 0;
+      padding: 0 2px;
+      border-radius: 0;
+    }
+    .msg-row.user .bubble {
+      background: var(--user-bg);
+      border: 1px solid var(--hairline);
+      max-width: 92%;
+    }
+    .msg-row.status .bubble {
+      color: var(--muted); font-size: 12px;
+      background: transparent; border: 0;
+      padding: 0 2px;
+    }
+    .msg-row.error .bubble {
+      background: color-mix(in srgb, var(--danger) 8%, var(--bg));
+      border: 1px solid color-mix(in srgb, var(--danger) 35%, transparent);
+    }
+
+    /* Markdown content */
+    .content h1, .content h2, .content h3 { font-size: 1.05em; margin: 12px 0 4px; line-height: 1.3; }
+    .content h4, .content h5, .content h6 { font-size: 1em; margin: 8px 0 2px; }
+    .content p { margin: 0 0 8px; }
+    .content p:last-child { margin-bottom: 0; }
+    .content ul, .content ol { margin: 0 0 8px; padding-left: 20px; }
+    .content li { margin-bottom: 2px; }
+    .content strong { font-weight: 700; }
+    .content em { font-style: italic; }
+    .content a { color: var(--link); text-decoration: none; }
+    .content a:hover { text-decoration: underline; }
+    .content blockquote {
+      border-left: 2px solid var(--border);
+      padding: 2px 0 2px 12px; margin: 8px 0;
+      color: var(--muted);
+    }
+    .content hr { border: 0; border-top: 1px solid var(--border); margin: 12px 0; }
+    .content table { border-collapse: collapse; width: 100%; margin: 8px 0; font-size: 12px; }
+    .content th, .content td { border: 1px solid var(--border); padding: 4px 8px; text-align: left; }
+    .content th { background: color-mix(in srgb, var(--panel-alt) 50%, var(--bg)); }
+    .content code:not(.hljs) {
+      background: color-mix(in srgb, var(--input) 80%, var(--bg));
+      border: 1px solid color-mix(in srgb, var(--border) 70%, transparent);
+      border-radius: 4px; padding: 1px 5px;
+      font-family: var(--mono); font-size: .9em;
+    }
+
+    /* Code blocks */
+    .code-block {
+      margin: 10px 0;
+      border: 1px solid var(--border);
+      border-radius: 10px;
+      overflow: hidden;
+      background: color-mix(in srgb, #000 5%, var(--panel));
+    }
+    .code-header {
+      display: flex; align-items: center;
+      padding: 5px 8px 4px 14px;
+      background: color-mix(in srgb, var(--panel-alt) 60%, var(--bg));
+      border-bottom: 1px solid var(--border);
+      font-size: 11px; color: var(--muted);
+      font-family: var(--mono);
+    }
+    .code-header .lang { flex: 1; }
+    .code-header button {
+      border: 0; border-radius: 4px;
+      background: transparent; color: var(--muted);
+      cursor: pointer; padding: 3px 10px;
+      font-size: 11px; font-family: var(--font);
+      transition: background .15s, color .15s;
+    }
+    .code-header button:hover { background: var(--row-hover); color: var(--vscode-foreground); }
+    .code-header button.copied { color: var(--success); }
+    .code-block pre {
+      margin: 0; padding: 12px 14px;
+      overflow-x: auto;
+      font-family: var(--mono); font-size: 12px; line-height: 1.5;
+    }
+    .code-block pre code { font-family: var(--mono); }
+
+    /* Syntax highlighting */
+    .hljs-keyword { color: var(--vscode-symbolIcon-keywordForeground, #569cd6); }
+    .hljs-string { color: var(--vscode-symbolIcon-stringForeground, #ce9178); }
+    .hljs-number { color: var(--vscode-symbolIcon-numberForeground, #b5cea8); }
+    .hljs-comment { color: var(--vscode-symbolIcon-commentForeground, #6a9955); font-style: italic; }
+    .hljs-function { color: var(--vscode-symbolIcon-functionForeground, #dcdcaa); }
+    .hljs-type { color: var(--vscode-symbolIcon-classForeground, #4ec9b0); }
+    .hljs-variable { color: var(--vscode-symbolIcon-variableForeground, #9cdcfe); }
+    .hljs-operator { color: var(--vscode-symbolIcon-operatorForeground, #d4d4d4); }
+    .hljs-built_in { color: var(--vscode-symbolIcon-classForeground, #4ec9b0); }
+    .hljs-attr { color: var(--vscode-symbolIcon-variableForeground, #9cdcfe); }
+    .hljs-literal { color: var(--vscode-symbolIcon-constantForeground, #569cd6); }
+    .hljs-meta { color: var(--muted); }
+    .hljs-regexp { color: var(--vscode-symbolIcon-stringForeground, #d16969); }
+
+    /* Metric card */
+    .metric-card {
+      margin-top: 10px;
+      border: 1px solid var(--success-border);
+      background: var(--success-bg);
+      border-radius: 10px;
+      padding: 10px 14px;
+    }
+    .metric-card.partial {
+      border-color: var(--warn-border, #d7a53c);
+      background: var(--warn-bg, rgba(215,165,60,.1));
+    }
+    .metric-card.unavailable {
+      border-color: var(--error-border, #e51400);
+      background: var(--error-bg, rgba(229,20,0,.08));
+    }
+    .metric-header {
+      color: var(--success); font-size: 11px; font-weight: 800;
+      text-transform: uppercase; letter-spacing: .04em;
+      margin-bottom: 4px;
+    }
+    .metric-card.partial .metric-header { color: var(--warn, #d7a53c); }
+    .metric-card.unavailable .metric-header { color: var(--error, #e51400); }
+    .metric-main { color: var(--success); font-weight: 700; font-size: 16px; }
+    .metric-card.partial .metric-main { color: var(--warn, #d7a53c); }
+    .metric-card.unavailable .metric-main { color: var(--error, #e51400); }
+    .metric-detail { color: var(--muted); font-size: 11px; line-height: 1.5; margin-top: 2px; }
+    .metric-status {
+      font-size: 10px; font-weight: 600; margin-top: 4px;
+      padding: 2px 8px; border-radius: 999px; display: inline-block;
+    }
+    .metric-status.complete { background: var(--success); color: #fff; }
+    .metric-status.partial { background: var(--warn, #d7a53c); color: #000; }
+    .metric-status.unavailable { background: var(--error, #e51400); color: #fff; }
+    .metric-warnings { margin-top: 6px; font-size: 10px; color: var(--warn, #d7a53c); line-height: 1.4; }
+    .metric-warning { display: flex; gap: 4px; align-items: flex-start; }
+    .metric-warning::before { content: '!'; font-weight: 700; flex-shrink: 0; }
+
+    /* File list */
+    .file-list { margin-top: 10px; display: flex; flex-direction: column; gap: 2px; }
+    .file-row {
+      display: flex; align-items: center; gap: 8px;
+      padding: 5px 8px; border-radius: 6px;
+      cursor: pointer; transition: background .12s; font-size: 12px;
+    }
+    .file-row:hover { background: var(--row-hover); }
+    .file-row .path {
+      flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+      font-family: var(--mono); font-size: 11px;
+    }
+    .file-row .tag {
+      border-radius: 999px; padding: 1px 7px;
+      font-size: 10px; font-weight: 600;
+      border: 1px solid var(--border); white-space: nowrap;
+    }
+    .file-row .score { color: var(--muted); font-size: 10px; min-width: 32px; text-align: right; }
+
+    /* Feedback bar */
+    .feedback-bar { margin-top: 10px; display: flex; flex-wrap: wrap; gap: 4px; font-size: 11px; }
+    .feedback-label { width: 100%; color: var(--muted); margin-bottom: 2px; }
+    .trace-list {
+      margin-top: 10px;
+      display: grid;
+      gap: 4px;
+      color: var(--muted);
+      font-size: 11px;
+    }
+    .trace-row {
+      display: grid;
+      grid-template-columns: 14px minmax(0, 1fr);
+      align-items: center;
+      gap: 5px;
+    }
+    .trace-dot {
+      width: 7px;
+      height: 7px;
+      border-radius: 999px;
+      background: var(--success);
+      justify-self: center;
+    }
+    .trace-text {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .command-list {
+      margin-top: 10px;
+      display: grid;
+      gap: 6px;
+    }
+    .command-row {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      gap: 8px;
+      align-items: center;
+      border: 1px solid var(--hairline);
+      border-radius: 7px;
+      padding: 7px 8px;
+      background: color-mix(in srgb, var(--panel) 42%, transparent);
+    }
+    .command-main {
+      min-width: 0;
+    }
+    .command-text {
+      display: block;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      font-family: var(--mono);
+      font-size: 11px;
+    }
+    .command-reason {
+      display: block;
+      margin-top: 2px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      color: var(--muted);
+      font-size: 10px;
+    }
+
+    /* Composer */
+    .composer {
+      flex-shrink: 0;
+      border-top: 1px solid var(--hairline);
+      padding: 9px 10px 10px;
+      background: color-mix(in srgb, var(--panel) 36%, var(--bg));
+    }
+    .composer-box {
+      border: 1px solid var(--hairline);
+      border-radius: 10px;
+      background: color-mix(in srgb, var(--input) 86%, var(--panel));
+      overflow: hidden;
+      transition: border-color .2s, box-shadow .2s;
+    }
+    .composer-box:focus-within {
+      border-color: color-mix(in srgb, var(--vscode-foreground) 28%, var(--hairline));
+      box-shadow: 0 0 0 1px color-mix(in srgb, var(--vscode-foreground) 8%, transparent);
+    }
+    .composer-box textarea {
+      width: 100%; border: 0; border-radius: 0;
+      background: transparent;
+      color: var(--vscode-input-foreground);
+      font-family: var(--font); font-size: 13px; line-height: 1.5;
+      padding: 10px 11px 4px;
+      min-height: 56px; max-height: 190px;
+      resize: none; outline: none; overflow-y: auto;
+    }
+    .composer-box textarea::placeholder { color: var(--muted); opacity: .65; }
+    .composer-toolbar {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto 28px;
+      grid-template-areas: "model mode action";
+      align-items: center;
+      gap: 6px;
+      padding: 3px 8px 8px;
+    }
+    .composer-toolbar .spacer { display: none; }
+    .model-select {
+      grid-area: model;
+      position: relative;
+      width: 100%;
+      min-width: 0;
+      max-width: none;
+    }
+    .model-picker {
+      width: 100%;
+      min-width: 0;
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      align-items: center;
+      gap: 6px;
+      border: 1px solid transparent;
+      background: color-mix(in srgb, var(--vscode-foreground) 5%, transparent);
+      color: var(--muted);
+      font-family: var(--font);
+      font-size: 11px;
+      font-weight: 600;
+      padding: 4px 7px;
+      border-radius: 7px;
+      outline: none;
+      cursor: pointer;
+      text-align: left;
+    }
+    .model-picker:hover:not(:disabled),
+    .model-picker[aria-expanded="true"] {
+      color: var(--vscode-foreground);
+      background: var(--surface-hover);
+      border-color: var(--hairline);
+    }
+    .model-picker:disabled { opacity: .55; cursor: default; }
+    .model-picker-label {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .model-chevron {
+      color: var(--muted);
+      font-size: 10px;
+      line-height: 1;
+    }
+    .model-menu {
+      position: fixed;
+      width: min(290px, calc(100vw - 24px));
+      max-height: 300px;
+      display: none;
+      flex-direction: column;
+      gap: 2px;
+      padding: 6px;
+      overflow-y: auto;
+      z-index: 100;
+      border: 1px solid var(--hairline);
+      border-radius: 9px;
+      background: var(--panel);
+      box-shadow: 0 10px 30px color-mix(in srgb, #000 35%, transparent);
+    }
+    .model-menu.open { display: flex; }
+    .model-option {
+      width: 100%;
+      display: grid;
+      grid-template-columns: auto minmax(0, 1fr) auto;
+      gap: 8px;
+      align-items: center;
+      border: 0;
+      border-radius: 7px;
+      background: transparent;
+      color: var(--vscode-foreground);
+      padding: 7px 8px;
+      text-align: left;
+      cursor: pointer;
+    }
+    .model-option:hover { background: var(--surface-hover); }
+    .model-option.active { background: var(--row-active); }
+    .model-option-dot {
+      width: 7px;
+      height: 7px;
+      border-radius: 999px;
+      background: color-mix(in srgb, var(--muted) 55%, transparent);
+    }
+    .model-option.connected .model-option-dot { background: var(--vscode-foreground); }
+    .model-option-main {
+      display: block;
+      min-width: 0;
+    }
+    .model-option-name {
+      display: block;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      font-size: 12px;
+      font-weight: 650;
+    }
+    .model-option-meta {
+      display: block;
+      margin-top: 1px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      color: var(--muted);
+      font-family: var(--mono);
+      font-size: 10px;
+      font-weight: 400;
+    }
+    .model-option-check {
+      width: 12px;
+      height: 12px;
+      color: var(--muted);
+      opacity: 0;
+    }
+    .model-option-check::before {
+      content: "";
+      display: block;
+      width: 5px;
+      height: 9px;
+      margin: 0 auto;
+      border: solid currentColor;
+      border-width: 0 1.5px 1.5px 0;
+      transform: rotate(45deg);
+    }
+    .model-option.active .model-option-check { opacity: 1; }
+
+    /* Buttons */
+    button {
+      border: 0; border-radius: 7px;
+      cursor: pointer;
+      font-family: var(--font); font-size: 12px; font-weight: 600;
+      padding: 5px 12px;
+      transition: opacity .15s, background .15s, color .15s;
+      white-space: nowrap;
+    }
+    button:disabled { cursor: default; opacity: .5; }
+    button.primary {
+      background: var(--button);
+      color: var(--button-fg);
+      border: 1px solid color-mix(in srgb, var(--vscode-foreground) 18%, transparent);
+    }
+    button.primary:hover:not(:disabled) { background: var(--button-hover); opacity: 1; }
+    button.secondary { background: var(--secondary-button); color: var(--secondary-button-fg); }
+    button.secondary:hover:not(:disabled) { opacity: .85; }
+    button.ghost { background: transparent; color: var(--muted); }
+    button.ghost:hover:not(:disabled) { background: var(--row-hover); color: var(--vscode-foreground); }
+    button.positive { background: var(--success); color: #fff; }
+    button.tiny { padding: 3px 8px; font-size: 11px; border-radius: 5px; }
+
+    /* Mode dropdown */
+    .mode-select {
+      grid-area: mode;
+      position: relative;
+      min-width: 118px;
+    }
+    .mode-picker {
+      width: 100%;
+      min-width: 0;
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      align-items: center;
+      gap: 6px;
+      border: 1px solid var(--hairline);
+      background: color-mix(in srgb, var(--vscode-foreground) 5%, transparent);
+      color: var(--muted);
+      font-family: var(--font);
+      font-size: 11px;
+      font-weight: 600;
+      padding: 4px 7px;
+      border-radius: 7px;
+      outline: none;
+      cursor: pointer;
+      text-align: left;
+    }
+    .mode-picker:hover,
+    .mode-picker[aria-expanded="true"] {
+      color: var(--vscode-foreground);
+      background: var(--surface-hover);
+      border-color: var(--hairline);
+    }
+    .mode-picker-label {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .mode-menu {
+      position: fixed;
+      width: min(220px, calc(100vw - 24px));
+      display: none;
+      flex-direction: column;
+      gap: 2px;
+      padding: 6px;
+      z-index: 100;
+      border: 1px solid var(--hairline);
+      border-radius: 9px;
+      background: var(--panel);
+      box-shadow: 0 10px 30px color-mix(in srgb, #000 35%, transparent);
+    }
+    .mode-menu.open { display: flex; }
+    .mode-option {
+      width: 100%;
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) auto;
+      gap: 8px;
+      align-items: center;
+      border: 0;
+      border-radius: 7px;
+      background: transparent;
+      color: var(--vscode-foreground);
+      padding: 7px 8px;
+      text-align: left;
+      cursor: pointer;
+    }
+    .mode-option:hover { background: var(--surface-hover); }
+    .mode-option.active { background: var(--row-active); }
+    .mode-option-main { min-width: 0; }
+    .mode-option-name { display: block; font-size: 12px; font-weight: 650; }
+    .mode-option-meta {
+      display: block;
+      margin-top: 1px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      color: var(--muted);
+      font-size: 10px;
+      font-weight: 400;
+    }
+    .mode-option-check { width: 12px; height: 12px; color: var(--muted); opacity: 0; }
+    .mode-option-check::before {
+      content: "";
+      display: block;
+      width: 5px;
+      height: 9px;
+      margin: 0 auto;
+      border: solid currentColor;
+      border-width: 0 1.5px 1.5px 0;
+      transform: rotate(45deg);
+    }
+    .mode-option.active .mode-option-check { opacity: 1; }
+
+    .stop-btn, .send-btn {
+      grid-area: action;
+      justify-self: end;
+      width: 28px; height: 28px;
+      min-width: 28px;
+      border-radius: 7px;
+      display: flex; align-items: center; justify-content: center;
+      flex-shrink: 0; font-size: 14px; padding: 0;
+      cursor: pointer;
+      transition: background .15s, color .15s, border-color .15s;
+    }
+    .stop-btn {
+      background: transparent;
+      border: 1px solid var(--hairline);
+      color: var(--muted);
+      font-size: 10px;
+    }
+    .stop-btn:hover { background: var(--surface-hover); color: var(--vscode-foreground); }
+    .send-btn {
+      background: var(--button);
+      color: var(--button-fg);
+      border: 1px solid color-mix(in srgb, var(--vscode-foreground) 18%, transparent);
+    }
+    .send-btn:hover:not(:disabled) { background: var(--button-hover); }
+    .send-btn:disabled { opacity: .4; }
+
+    @media (max-width: 340px) {
+      .composer { padding: 8px; }
+      .composer-box textarea {
+        min-height: 50px;
+        padding: 9px 10px 3px;
+      }
+      .composer-toolbar {
+        grid-template-columns: minmax(0, 1fr) 28px;
+        grid-template-areas:
+          "model action"
+          "mode mode";
+        gap: 6px;
+        padding: 3px 8px 8px;
+      }
+      .mode-select {
+        width: 100%;
+        min-width: 0;
+      }
+      .mode-menu {
+        width: calc(100vw - 20px);
+      }
+      .model-menu {
+        width: calc(100vw - 20px);
+        max-height: 220px;
+      }
+    }
+
+    /* Hover actions on messages */
+    .msg-actions {
+      display: flex; gap: 4px; margin-top: 6px;
+      opacity: 0; transition: opacity .2s;
+    }
+    .msg-body:hover .msg-actions { opacity: 1; }
+    .msg-row.user .msg-actions { flex-direction: row-reverse; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <div class="brand"><img src="${logoUri}" alt=""></div>
+    <div class="title wordmark" data-text="FlowSeeker">FlowSeeker</div>
+    <div class="spacer"></div>
+    <button id="newThread" title="New chat">+</button>
+    <button id="toggleThreads" title="Chat history">&#9776;</button>
+    <button id="toggleLogin" title="AI Provider">&#9881;</button>
+  </div>
+  <div class="status-line" id="connection">
+    <span class="status-badge" id="statusBadge">Disconnected</span>
+    <span class="status-text" id="statusText">Checking AI provider...</span>
+  </div>
+  <div class="thread-panel" id="threadPanel">
+    <div class="thread-panel-head">
+      <span>Chat history</span>
+      <div class="spacer"></div>
+      <button class="ghost tiny" id="newThreadPanel">New</button>
+    </div>
+    <div class="thread-list" id="threadList"></div>
+  </div>
+  <div class="login-panel" id="login">
+    <div class="panel-head">
+      <div class="panel-head-main">
+        <div class="panel-head-title">AI Provider</div>
+        <div class="panel-head-subtitle">Connect model profiles without writing status messages into chat.</div>
+      </div>
+      <button class="panel-close" id="closeLogin" title="Close AI Provider">x</button>
+    </div>
+    <div class="gateway-status" id="gatewayStatus">
+      <span class="gateway-dot" aria-hidden="true"></span>
+      <span class="gateway-status-text" id="gatewayStatusText">Disconnected · local retrieval only</span>
+    </div>
+    <div class="gateway-feedback" id="gatewayFeedback" role="status"></div>
+    <div class="profile-list" id="profileList"></div>
+    <label>Provider
+      <select id="provider">${providerOptions}</select>
+    </label>
+    <label><span id="modelLabel">Model</span>
+      <input id="model" placeholder="Model">
+    </label>
+    <label><span id="baseUrlLabel">Base URL</span>
+      <input id="baseUrl" placeholder="Provider base URL">
+    </label>
+    <label id="apiKeyLabel">API Key / Token
+      <input id="token" placeholder="API key" type="password">
+    </label>
+    <label id="modelSelectLabel" style="display:none">Model
+      <select id="oauthModelSelect"></select>
+    </label>
+    <div class="login-row">
+      <button class="primary" id="connect">Save profile</button>
+      <button class="secondary" id="fetchModels">Load models</button>
+      <button class="secondary" id="testProvider">Test</button>
+      <button class="secondary" id="disconnect">Disconnect</button>
+      <button class="primary" id="oauthAuthorize" style="display:none">Sign in with browser</button>
+    </div>
+  </div>
+  <div class="agent-control-panel" id="agentControls">
+      <div class="panel-head">
+        <div class="panel-head-main">
+          <div class="panel-head-title">Agent controls</div>
+          <div class="panel-head-subtitle">Separate workspace, command, and MCP permissions.</div>
+        </div>
+        <button class="panel-close" id="closeAgentControls" title="Close agent controls">x</button>
+      </div>
+      <label class="toggle-row">
+        <input id="policyReadWorkspace" type="checkbox">
+        <span><strong>Read workspace</strong><span>Allow Solve Packet retrieval and workspace reads without asking.</span></span>
+      </label>
+      <label class="toggle-row">
+        <input id="policyEditWorkspace" type="checkbox">
+        <span><strong>Auto-apply edits</strong><span>Skip the final Apply button after an approved plan.</span></span>
+      </label>
+      <label class="toggle-row">
+        <input id="policySafeCommands" type="checkbox">
+        <span><strong>Auto-run safe checks</strong><span>Allow build, lint, test, status, and typecheck commands.</span></span>
+      </label>
+      <label class="toggle-row">
+        <input id="policyAllCommands" type="checkbox">
+        <span><strong>Auto-run other commands</strong><span>Higher risk. Destructive commands still require explicit approval.</span></span>
+      </label>
+      <label class="toggle-row">
+        <input id="policyMcpTools" type="checkbox">
+        <span><strong>Auto-use MCP tools</strong><span>Allow configured MCP tools without a separate approval prompt.</span></span>
+      </label>
+      <label class="agent-rules">Rules
+        <textarea id="agentRules" placeholder="One rule per line. Example: Always explain missing context before asking for more files."></textarea>
+      </label>
+      <div class="login-row">
+        <button class="primary" id="saveAgentPolicy">Save agent controls</button>
+        <button class="secondary" id="openMcpConfig">MCP config</button>
+      </div>
+    </div>
+  <div class="messages" id="messages">
+    <div class="empty-state" id="empty">
+      <div class="brand-lg"><img src="${logoUri}" alt=""></div>
+      <div class="empty-title"><span class="wordmark" data-text="FlowSeeker">FlowSeeker</span></div>
+      <div class="empty-hint">New session</div>
+    </div>
+  </div>
+  <div class="agent-policy" id="agentPolicy">
+    <div class="agent-policy-main">
+      <span class="agent-policy-label">Agent</span>
+      <span class="agent-policy-text" id="agentPolicyText">Review edits before apply</span>
+    </div>
+    <div class="agent-policy-actions">
+      <button id="openAgentSettings" title="Open FlowSeeker agent settings">Settings</button>
+      <button id="toggleAgentControls" class="ghost" title="Agent controls">Controls</button>
+    </div>
+    <div class="quota-panel" id="quotaPanel">
+      <div class="quota-header" id="quotaHeader">
+        <span class="chevron" id="quotaChevron">&#9654;</span>
+        <span class="quota-summary-text" id="quotaSummaryText">No usage yet</span>
+        <span class="quota-badge ok" id="quotaBadge">0%</span>
+      </div>
+      <div class="quota-detail" id="quotaDetail"></div>
+    </div>
+  </div>
+  <div class="composer">
+    <div class="composer-box">
+      <textarea id="task" placeholder="Ask FlowSeeker to find the relevant code..."></textarea>
+      <div class="composer-toolbar">
+        <div class="model-select" id="modelSelect">
+          <button class="model-picker" id="modelPicker" type="button" title="Active AI model" aria-haspopup="listbox" aria-expanded="false">
+            <span class="model-picker-label" id="modelPickerLabel">No AI provider</span>
+            <span class="model-chevron">v</span>
+          </button>
+        </div>
+        <div class="spacer"></div>
+        <div class="mode-select" id="modeSelect">
+          <button class="mode-picker" id="modePicker" type="button" title="FlowSeeker mode" aria-haspopup="listbox" aria-expanded="false">
+            <span class="mode-picker-label" id="modePickerLabel">Guide</span>
+            <span class="model-chevron">v</span>
+          </button>
+        </div>
+        <button class="stop-btn" id="stopBtn" title="Stop generating" style="display:none">&#9632;</button>
+        <button class="send-btn" id="send" title="Send (Enter)">&#8593;</button>
+      </div>
+    </div>
+  </div>
+  <div class="model-menu" id="modelMenu" role="listbox"></div>
+  <div class="mode-menu" id="modeMenu" role="listbox"></div>
+  <script nonce="${nonce}">
+    const vscode = acquireVsCodeApi();
+    const providerMeta = ${providerMeta};
+    const messages = document.getElementById('messages');
+    const connection = document.getElementById('connection');
+    const statusBadge = document.getElementById('statusBadge');
+    const connectionStatusText = document.getElementById('statusText');
+    const agentPolicy = document.getElementById('agentPolicy');
+    const agentPolicyText = document.getElementById('agentPolicyText');
+    const gatewayStatus = document.getElementById('gatewayStatus');
+    const gatewayStatusText = document.getElementById('gatewayStatusText');
+    const gatewayFeedback = document.getElementById('gatewayFeedback');
+    const login = document.getElementById('login');
+    const threadPanel = document.getElementById('threadPanel');
+    const threadList = document.getElementById('threadList');
+    const modelPicker = document.getElementById('modelPicker');
+    const modelPickerLabel = document.getElementById('modelPickerLabel');
+    const modelMenu = document.getElementById('modelMenu');
+    const profileList = document.getElementById('profileList');
+    const provider = document.getElementById('provider');
+    const modelLabel = document.getElementById('modelLabel');
+    const model = document.getElementById('model');
+    const baseUrlLabel = document.getElementById('baseUrlLabel');
+    const baseUrl = document.getElementById('baseUrl');
+    const token = document.getElementById('token');
+    const task = document.getElementById('task');
+    const modePicker = document.getElementById('modePicker');
+    const modePickerLabel = document.getElementById('modePickerLabel');
+    const modeMenu = document.getElementById('modeMenu');
+    const sendButton = document.getElementById('send');
+    const stopBtn = document.getElementById('stopBtn');
+    const policyReadWorkspace = document.getElementById('policyReadWorkspace');
+    const policyEditWorkspace = document.getElementById('policyEditWorkspace');
+    const policySafeCommands = document.getElementById('policySafeCommands');
+    const policyAllCommands = document.getElementById('policyAllCommands');
+    const policyMcpTools = document.getElementById('policyMcpTools');
+    const agentRules = document.getElementById('agentRules');
+    let agentState = 'idle';
+    let busy = false;
+    const ACTION_STATES = new Set(['approving_plan', 'applying_edits', 'verifying', 'running_command', 'running_mcp_tool']);
+    let currentMode = 'guide';
+    const modeOptions = [
+      { id: 'guide', label: 'Guide', hint: 'Retrieve context, then explain likely changes.' },
+      { id: 'auto', label: 'Plan', hint: 'Create a reviewable implementation plan.' },
+      { id: 'chat', label: 'Chat', hint: 'Talk directly to connected AI provider.' }
+    ];
+    let activeThreadId = '';
+    let activeProfileId = '';
+    let providerProfiles = [];
+    let providerModelOptions = [];
+    let providerModelOptionsProvider = '';
+    let modelFetchTimer = 0;
+    let activeStreamingRow = null;
+    let activeStreamingContent = null;
+    let activeStreamingText = '';
+
+    document.getElementById('newThread').addEventListener('click', function() { if (!busy) vscode.postMessage({ type: 'newThread' }); });
+    document.getElementById('newThreadPanel').addEventListener('click', function() { if (!busy) vscode.postMessage({ type: 'newThread' }); });
+    document.getElementById('toggleThreads').addEventListener('click', function() { threadPanel.classList.toggle('open'); });
+    document.getElementById('quotaHeader').addEventListener('click', function() {
+      var detail = document.getElementById('quotaDetail');
+      var chevron = document.getElementById('quotaChevron');
+      var open = detail.classList.toggle('open');
+      chevron.classList.toggle('open', open);
+    });
+    document.getElementById('toggleLogin').addEventListener('click', function() {
+      login.classList.toggle('open');
+      if (login.classList.contains('open')) document.getElementById('agentControls').classList.remove('open');
+    });
+    document.getElementById('closeLogin').addEventListener('click', function() { login.classList.remove('open'); });
+    document.getElementById('openAgentSettings').addEventListener('click', function() { vscode.postMessage({ type: 'openAgentSettings' }); });
+    document.getElementById('toggleAgentControls').addEventListener('click', function() {
+      var ctrl = document.getElementById('agentControls');
+      ctrl.classList.toggle('open');
+      if (ctrl.classList.contains('open')) login.classList.remove('open');
+    });
+    document.getElementById('closeAgentControls').addEventListener('click', function() { document.getElementById('agentControls').classList.remove('open'); });
+    modelPicker.addEventListener('click', function(event) {
+      event.stopPropagation();
+      if (!providerProfiles.length) return;
+      setModeMenuOpen(false);
+      setModelMenuOpen(!modelMenu.classList.contains('open'));
+    });
+    modelMenu.addEventListener('click', function(event) {
+      event.stopPropagation();
+    });
+    modePicker.addEventListener('click', function(event) {
+      event.stopPropagation();
+      setModelMenuOpen(false);
+      setModeMenuOpen(!modeMenu.classList.contains('open'));
+    });
+    modeMenu.addEventListener('click', function(event) {
+      event.stopPropagation();
+    });
+    document.addEventListener('click', function() {
+      setModelMenuOpen(false);
+      setModeMenuOpen(false);
+    });
+    document.addEventListener('keydown', function(event) {
+      if (event.key === 'Escape') {
+        setModelMenuOpen(false);
+        setModeMenuOpen(false);
+      }
+    });
+    document.getElementById('connect').addEventListener('click', function() {
+      setGatewayTesting('Saving provider profile...');
+      vscode.postMessage(providerPayload('connect'));
+    });
+    document.getElementById('fetchModels').addEventListener('click', function() {
+      fetchProviderModels();
+    });
+    document.getElementById('testProvider').addEventListener('click', function() {
+      setGatewayTesting('Testing AI provider...');
+      vscode.postMessage(providerPayload('testProvider'));
+    });
+    document.getElementById('oauthAuthorize').addEventListener('click', function() {
+      vscode.postMessage({ type: 'startOAuth', provider: provider.value });
+    });
+    document.getElementById('disconnect').addEventListener('click', function() {
+      vscode.postMessage({ type: 'disconnect' });
+    });
+    document.getElementById('saveAgentPolicy').addEventListener('click', function() {
+      vscode.postMessage(agentPolicyPayload());
+    });
+    document.getElementById('openMcpConfig').addEventListener('click', function() {
+      vscode.postMessage({ type: 'openMcpConfig' });
+    });
+    document.getElementById('send').addEventListener('click', send);
+    document.getElementById('stopBtn').addEventListener('click', function() { vscode.postMessage({ type: 'cancel' }); setAgentState('cancelled'); });
+    renderModeMenu();
+    provider.addEventListener('change', function() {
+      providerModelOptions = [];
+      providerModelOptionsProvider = provider.value;
+      applyProviderDefaults(true);
+      renderModelDropdown([], model.value, provider.value);
+      scheduleModelFetch();
+    });
+    baseUrl.addEventListener('input', scheduleModelFetch);
+    token.addEventListener('input', function() { token.classList.remove('key-saved'); token.placeholder = 'API key'; scheduleModelFetch(); });
+    var modelSelectEl = document.getElementById('oauthModelSelect');
+    if (modelSelectEl) {
+      modelSelectEl.addEventListener('change', function() {
+        model.value = modelSelectEl.value;
+      });
+    }
+    task.addEventListener('keydown', function(event) {
+      if (event.key === 'Enter' && !event.shiftKey) { event.preventDefault(); send(); }
+    });
+
+    function getModelValue() {
+      var sel = document.getElementById('oauthModelSelect');
+      var selectLabel = document.getElementById('modelSelectLabel');
+      return sel && selectLabel && selectLabel.style.display !== 'none' && sel.value ? sel.value : model.value;
+    }
+
+    function providerPayload(type) {
+      return {
+        type: type,
+        provider: provider.value,
+        model: getModelValue(),
+        baseUrl: baseUrl.value,
+        endpoint: baseUrl.value,
+        token: token.value
+      };
+    }
+
+    function agentPolicyPayload() {
+      return {
+        type: 'updateAgentPolicy',
+        readWorkspace: Boolean(policyReadWorkspace && policyReadWorkspace.checked),
+        editWorkspace: Boolean(policyEditWorkspace && policyEditWorkspace.checked),
+        safeCommands: Boolean(policySafeCommands && policySafeCommands.checked),
+        allCommands: Boolean(policyAllCommands && policyAllCommands.checked),
+        mcpTools: Boolean(policyMcpTools && policyMcpTools.checked),
+        rulesText: agentRules ? agentRules.value : ''
+      };
+    }
+
+    function applyProviderDefaults(force) {
+      var meta = providerMeta[provider.value] || providerMeta.openai;
+      if (force || !model.value) model.value = meta.defaultModel || '';
+      if (force || !baseUrl.value) baseUrl.value = meta.defaultBaseUrl || '';
+      modelLabel.textContent = meta.modelLabel || 'Model';
+      baseUrlLabel.textContent = meta.baseUrlLabel || 'Base URL';
+      model.placeholder = meta.modelPlaceholder || 'Model';
+      baseUrl.placeholder = meta.baseUrlPlaceholder || 'Provider base URL';
+      token.placeholder = meta.apiKeyLabel || 'API key';
+      if (meta.apiKeyHint) token.placeholder = (meta.apiKeyLabel || 'API key') + ' (' + meta.apiKeyHint + ')';
+      token.disabled = !meta.requiresApiKey;
+      if (!meta.requiresApiKey) token.value = '';
+
+      var isOAuth = meta.authMethod === 'oauth' && meta.oauthConfig && meta.oauthConfig.clientId;
+      var hasProviderModelOptions = meta.supportsModelList;
+      var apiKeyLabel = document.getElementById('apiKeyLabel');
+      var modelSelectLabel = document.getElementById('modelSelectLabel');
+      var oauthBtn = document.getElementById('oauthAuthorize');
+      var connectBtn = document.getElementById('connect');
+      var testBtn = document.getElementById('testProvider');
+      var fetchModelsBtn = document.getElementById('fetchModels');
+      var modelInput = document.getElementById('model');
+
+      if (apiKeyLabel) apiKeyLabel.style.display = meta.requiresApiKey ? '' : 'none';
+      if (oauthBtn) {
+        oauthBtn.style.display = isOAuth ? '' : 'none';
+        oauthBtn.textContent = 'Sign in with browser';
+        oauthBtn.className = 'primary';
+        oauthBtn.title = 'Authorize this provider in your browser.';
+      }
+      if (connectBtn) connectBtn.style.display = isOAuth ? 'none' : '';
+      if (testBtn) testBtn.style.display = isOAuth ? 'none' : '';
+      if (fetchModelsBtn) fetchModelsBtn.style.display = meta.supportsModelList && !isOAuth ? '' : 'none';
+
+      if (hasProviderModelOptions && modelSelectLabel) {
+        modelSelectLabel.style.display = '';
+        if (modelInput) modelInput.style.display = 'none';
+      } else {
+        if (modelSelectLabel) modelSelectLabel.style.display = 'none';
+        if (modelInput) modelInput.style.display = '';
+      }
+    }
+
+    function scheduleModelFetch() {
+      window.clearTimeout(modelFetchTimer);
+      modelFetchTimer = window.setTimeout(fetchProviderModels, 650);
+    }
+
+    function fetchProviderModels() {
+      var meta = providerMeta[provider.value] || providerMeta.openai;
+      if (!meta.supportsModelList) return;
+      if (meta.requiresApiKey && token.value.trim().length < 6) {
+        renderModelDropdown([], model.value || meta.defaultModel || '', provider.value);
+        return;
+      }
+      vscode.postMessage(providerPayload('fetchModels'));
+    }
+
+    function setGatewayTesting(text) {
+      if (!gatewayStatus.classList.contains('testing')) {
+        gatewayStatus.dataset.previousText = gatewayStatusText.textContent || '';
+      }
+      gatewayStatus.classList.add('testing');
+      gatewayStatusText.textContent = text || 'Testing AI provider...';
+      showGatewayFeedback('info', text || 'Testing AI provider...', false);
+    }
+
+    function showGatewayFeedback(status, text, autoHide) {
+      if (status !== 'info' || (text || '').toLowerCase().indexOf('testing') < 0) {
+        gatewayStatus.classList.remove('testing');
+        if (gatewayStatus.dataset.previousText) {
+          gatewayStatusText.textContent = gatewayStatus.dataset.previousText;
+          gatewayStatus.dataset.previousText = '';
+        }
+      }
+      gatewayFeedback.className = 'gateway-feedback show ' + (status || 'info');
+      gatewayFeedback.textContent = text || '';
+      if (autoHide !== false && status !== 'error') {
+        window.clearTimeout(showGatewayFeedback.timer || 0);
+        showGatewayFeedback.timer = window.setTimeout(function() {
+          gatewayFeedback.className = 'gateway-feedback';
+          gatewayFeedback.textContent = '';
+        }, 5000);
+      }
+    }
+
+    function renderGatewayConnectionStatus(connected, label, modelName) {
+      gatewayStatus.classList.remove('testing');
+      gatewayStatus.dataset.previousText = '';
+      gatewayStatus.classList.toggle('connected', Boolean(connected));
+      gatewayStatusText.textContent = connected
+        ? 'Connected · ' + (label || 'AI provider') + (modelName ? ' / ' + modelName : '')
+        : 'Disconnected · local retrieval only';
+    }
+
+    function renderProviderProfiles(profiles, activeId) {
+      providerProfiles = Array.isArray(profiles) ? profiles : [];
+      activeProfileId = activeId || '';
+      modelMenu.innerHTML = '';
+      profileList.innerHTML = '';
+
+      if (!providerProfiles.length) {
+        modelPickerLabel.textContent = 'No AI provider';
+        modelPicker.disabled = true;
+        setModelMenuOpen(false);
+        var empty = document.createElement('div');
+        empty.className = 'profile-empty';
+        empty.textContent = 'No saved provider profiles.';
+        profileList.appendChild(empty);
+        return;
+      }
+
+      modelPicker.disabled = false;
+      if (!providerProfiles.some(function(profile) { return profile.id === activeProfileId; })) {
+        activeProfileId = providerProfiles[0].id;
+      }
+      providerProfiles.forEach(function(profile) {
+        var option = document.createElement('button');
+        option.type = 'button';
+        option.className = 'model-option' + (profile.id === activeProfileId ? ' active' : '') + (profile.connected ? ' connected' : '');
+        option.setAttribute('role', 'option');
+        option.setAttribute('aria-selected', profile.id === activeProfileId ? 'true' : 'false');
+        option.title = fullProfileLabel(profile);
+        option.addEventListener('click', function() {
+          setModelMenuOpen(false);
+          if (profile.id !== activeProfileId) vscode.postMessage({ type: 'selectProviderProfile', profileId: profile.id });
+        });
+
+        var optionDot = document.createElement('span');
+        optionDot.className = 'model-option-dot';
+        var optionMain = document.createElement('span');
+        optionMain.className = 'model-option-main';
+        var optionName = document.createElement('span');
+        optionName.className = 'model-option-name';
+        optionName.textContent = compactProfileLabel(profile);
+        var optionMeta = document.createElement('span');
+        optionMeta.className = 'model-option-meta';
+        optionMeta.textContent = hasDuplicateModelName(profile) ? (profile.providerLabel || profile.provider || '') : '';
+        optionMain.appendChild(optionName);
+        optionMain.appendChild(optionMeta);
+        var optionCheck = document.createElement('span');
+        optionCheck.className = 'model-option-check';
+        optionCheck.setAttribute('aria-hidden', 'true');
+        option.appendChild(optionDot);
+        option.appendChild(optionMain);
+        option.appendChild(optionCheck);
+        modelMenu.appendChild(option);
+
+        var row = document.createElement('div');
+        row.className = 'profile-row' + (profile.id === activeProfileId ? ' active' : '') + (profile.connected ? ' connected' : '');
+        row.title = fullProfileLabel(profile);
+        row.addEventListener('click', function() {
+          if (profile.id !== activeProfileId) vscode.postMessage({ type: 'selectProviderProfile', profileId: profile.id });
+        });
+
+        var main = document.createElement('div');
+        main.className = 'profile-main';
+        var name = document.createElement('div');
+        name.className = 'profile-name';
+        name.textContent = fullProfileLabel(profile);
+        var meta = document.createElement('div');
+        meta.className = 'profile-meta';
+        meta.textContent = profile.baseUrl || '';
+        main.appendChild(name);
+        main.appendChild(meta);
+
+        var actions = document.createElement('div');
+        actions.className = 'profile-actions';
+        var state = document.createElement('span');
+        state.className = 'profile-state';
+        state.title = profile.connected ? 'Connected' : 'Missing API key';
+        var remove = document.createElement('button');
+        remove.className = 'thread-delete';
+        remove.title = 'Remove profile';
+        remove.textContent = 'x';
+        remove.addEventListener('click', function(event) {
+          event.stopPropagation();
+          vscode.postMessage({ type: 'removeProviderProfile', profileId: profile.id });
+        });
+        actions.appendChild(state);
+        actions.appendChild(remove);
+
+        row.appendChild(main);
+        row.appendChild(actions);
+        profileList.appendChild(row);
+      });
+
+      var activeProfile = providerProfiles.find(function(profile) { return profile.id === activeProfileId; });
+      updateModelPicker(activeProfile);
+      if (activeProfile) {
+        syncProviderForm(activeProfile);
+      }
+    }
+
+    function setModelMenuOpen(open) {
+      if (open) {
+        var btnRect = modelPicker.getBoundingClientRect();
+        // Place menu right above the button, aligned with its left edge
+        modelMenu.style.bottom = (window.innerHeight - btnRect.top + 4) + 'px';
+        modelMenu.style.left = Math.max(8, Math.min(btnRect.left, window.innerWidth - 300)) + 'px';
+        modelMenu.style.top = 'auto';
+      }
+      modelMenu.classList.toggle('open', Boolean(open));
+      modelPicker.setAttribute('aria-expanded', open ? 'true' : 'false');
+    }
+
+    function updateModelPicker(profile) {
+      modelPickerLabel.textContent = profile ? compactProfileLabel(profile) : 'No AI provider';
+      modelPicker.title = profile ? fullProfileLabel(profile) : 'Active AI model';
+    }
+
+    function fullProfileLabel(profile) {
+      return (profile.providerLabel || profile.provider || 'AI') + (profile.model ? ' / ' + profile.model : '');
+    }
+
+    function compactProfileLabel(profile) {
+      var name = modelDisplayName(profile);
+      return hasDuplicateModelName(profile) ? name + ' (' + (profile.providerLabel || profile.provider || 'AI') + ')' : name;
+    }
+
+    function modelDisplayName(profile) {
+      return profile.model || profile.providerLabel || profile.provider || 'AI provider';
+    }
+
+    function modelDisplayKey(profile) {
+      return modelDisplayName(profile).trim().toLowerCase();
+    }
+
+    function hasDuplicateModelName(profile) {
+      var key = modelDisplayKey(profile);
+      if (!key) return false;
+      return providerProfiles.filter(function(item) { return modelDisplayKey(item) === key; }).length > 1;
+    }
+
+    function syncProviderForm(profile) {
+      if (!profile) return;
+      provider.value = profile.provider || provider.value;
+      model.value = profile.model || '';
+      baseUrl.value = profile.baseUrl || '';
+      if (profile.connected && profile.requiresApiKey) {
+        token.value = '';
+        token.placeholder = 'API key is saved';
+        token.classList.add('key-saved');
+      } else {
+        token.placeholder = 'API key';
+        token.classList.remove('key-saved');
+      }
+      applyProviderDefaults(false);
+    }
+
+    function renderModeMenu() {
+      modeMenu.innerHTML = '';
+      modeOptions.forEach(function(option) {
+        var button = document.createElement('button');
+        button.type = 'button';
+        button.className = 'mode-option' + (option.id === currentMode ? ' active' : '');
+        button.setAttribute('role', 'option');
+        button.setAttribute('aria-selected', option.id === currentMode ? 'true' : 'false');
+        button.addEventListener('click', function() {
+          setModeMenuOpen(false);
+          setMode(option.id);
+        });
+        var main = document.createElement('span');
+        main.className = 'mode-option-main';
+        var name = document.createElement('span');
+        name.className = 'mode-option-name';
+        name.textContent = option.label;
+        var meta = document.createElement('span');
+        meta.className = 'mode-option-meta';
+        meta.textContent = option.hint;
+        main.appendChild(name);
+        main.appendChild(meta);
+        var check = document.createElement('span');
+        check.className = 'mode-option-check';
+        check.setAttribute('aria-hidden', 'true');
+        button.appendChild(main);
+        button.appendChild(check);
+        modeMenu.appendChild(button);
+      });
+    }
+
+    function setModeMenuOpen(open) {
+      if (open) {
+        var btnRect = modePicker.getBoundingClientRect();
+        modeMenu.style.bottom = (window.innerHeight - btnRect.top + 4) + 'px';
+        modeMenu.style.left = Math.max(8, Math.min(btnRect.left, window.innerWidth - 230)) + 'px';
+        modeMenu.style.top = 'auto';
+      }
+      modeMenu.classList.toggle('open', Boolean(open));
+      modePicker.setAttribute('aria-expanded', open ? 'true' : 'false');
+    }
+
+    function setMode(mode) {
+      currentMode = mode === 'auto' ? 'auto' : mode === 'chat' ? 'chat' : 'guide';
+      var active = modeOptions.find(function(option) { return option.id === currentMode; }) || modeOptions[0];
+      modePickerLabel.textContent = active.label;
+      modePicker.title = active.label + ' - ' + active.hint;
+      renderModeMenu();
+      task.placeholder = currentMode === 'auto'
+        ? 'Ask FlowSeeker for a reviewable plan...'
+        : currentMode === 'chat'
+          ? 'Chat directly with the AI provider...'
+          : 'Ask FlowSeeker to find the relevant code...';
+    }
+
+    applyProviderDefaults(true);
+    renderModelDropdown([], model.value, provider.value);
+    scheduleModelFetch();
+
+    /* Markdown renderer */
+    function renderMarkdown(text) {
+      if (!text) return '';
+      var html = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+      html = html.replace(/\`\`\`(\\w*)\\n([\\s\\S]*?)\`\`\`/g, function(_, lang, code) {
+        return '<div class="code-block"><div class="code-header"><span class="lang">' + (lang || 'code') + '</span><button onclick="copyCode(this)">Copy</button></div><pre><code class="hljs">' + highlightCode(code) + '</code></pre></div>';
+      });
+      html = html.replace(/\`([^\`]+)\`/g, '<code>$1</code>');
+      html = html.replace(/\\*\\*(.+?)\\*\\*/g, '<strong>$1</strong>');
+      html = html.replace(/\\*(.+?)\\*/g, '<em>$1</em>');
+      html = html.replace(/^#### (.+)$/gm, '<h4>$1</h4>');
+      html = html.replace(/^### (.+)$/gm, '<h3>$1</h3>');
+      html = html.replace(/^## (.+)$/gm, '<h2>$1</h2>');
+      html = html.replace(/^# (.+)$/gm, '<h1>$1</h1>');
+      html = html.replace(/^(?:- |\\* )(.*)$/gm, '<li>$1</li>');
+      html = html.replace(/((?:<li>.*<\\/li>\\n?)+)/g, '<ul>$1</ul>');
+      html = html.replace(/^&gt;\\s?(.*)$/gm, '<blockquote>$1</blockquote>');
+      html = html.replace(/\\[([^\\]]+)\\]\\(([^)]+)\\)/g, '<a href="$2">$1</a>');
+      html = html.replace(/^---$/gm, '<hr>');
+      html = html.replace(/([^\\n]+)\\n\\n/g, '<p>$1</p>\\n');
+      return html;
+    }
+
+    function highlightCode(code) {
+      var result = code.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+      result = result.replace(new RegExp('(//.*$|#.*$)', 'gm'), '<span class="hljs-comment">$1</span>');
+      result = result.replace(/(["\`])((?:(?!\\1)[^\\\\]|\\\\.)*)\\1/g, '<span class="hljs-string">$1$2$1</span>');
+      result = result.replace(/(')((?:(?!\\1)[^\\\\]|\\\\.)*)\\1/g, '<span class="hljs-string">$1$2$1</span>');
+      result = result.replace(/\\b(\\d+\\.?\\d*)\\b/g, '<span class="hljs-number">$1</span>');
+      var kw = ['function','const','let','var','return','if','else','for','while','class','extends','import','export','default','from','async','await','try','catch','throw','new','this','typeof','instanceof','public','private','protected','static','interface','type','enum','def','self','True','False','None','and','or','not','func','go','struct','map','chan','defer','package','fn','impl','use','mod','pub','continue','switch','case','break','yield','with','finally','get','set','namespace','declare','abstract','readonly','implements'];
+      result = result.replace(new RegExp('\\\\b(' + kw.join('|') + ')\\\\b', 'g'), '<span class="hljs-keyword">$1</span>');
+      result = result.replace(/\\b([a-zA-Z_$][\\w$]*)\\s*\\(/g, '<span class="hljs-function">$1</span>(');
+      return result;
+    }
+
+    window.copyCode = function(btn) {
+      var code = btn.closest('.code-block').querySelector('code').textContent;
+      navigator.clipboard.writeText(code).then(function() {
+        btn.textContent = 'Copied!';
+        btn.classList.add('copied');
+        setTimeout(function() { btn.textContent = 'Copy'; btn.classList.remove('copied'); }, 1800);
+      }).catch(function() {});
+    };
+
+    function msgRow(kind) {
+      var row = document.createElement('div');
+      row.className = 'msg-row ' + kind;
+      var avatar = document.createElement('div');
+      avatar.className = 'msg-avatar';
+      if (kind === 'user') avatar.textContent = 'U';
+      else if (kind === 'error') avatar.textContent = '!';
+      else avatar.innerHTML = '<img src="${logoUri}" alt="">';
+      row.appendChild(avatar);
+      var body = document.createElement('div');
+      body.className = 'msg-body';
+      var label = document.createElement('div');
+      label.className = 'msg-label';
+      label.textContent = kindLabel(kind);
+      body.appendChild(label);
+      row.appendChild(body);
+      return row;
+    }
+
+    function kindLabel(kind) {
+      if (kind === 'user') return 'You';
+      if (kind === 'retrieval') return 'Context';
+      if (kind === 'status') return 'Status';
+      if (kind === 'error') return 'Error';
+      return 'FlowSeeker';
+    }
+
+    function addMessage(kind, text, files, proposal, metric, feedback, verificationFiles, trace, commands, mcpTools) {
+      removeEmpty();
+      var row = msgRow(kind);
+      var body = row.querySelector('.msg-body');
+      var bubble = document.createElement('div');
+      bubble.className = 'bubble';
+
+      var content = document.createElement('div');
+      content.className = 'content';
+      content.innerHTML = renderMarkdown(text || '');
+      bubble.appendChild(content);
+
+      if (metric) {
+        var card = document.createElement('div');
+        var statusClass = metric.proofStatus || 'complete';
+        card.className = 'metric-card ' + statusClass;
+
+        var statusLabel = statusClass === 'complete' ? 'Complete proof' : statusClass === 'partial' ? 'Partial proof' : 'Unavailable';
+        var statusChip = '<span class="metric-status ' + statusClass + '">' + statusLabel + '</span>';
+
+        var coverageHtml = metric.contextCoverage ? '<div style="margin-top:4px;font-size:10px;color:var(--muted);">Coverage: ' + metric.contextCoverage + '</div>' : '';
+
+        var warningsHtml = '';
+        if (metric.proofWarnings && metric.proofWarnings.length) {
+          warningsHtml = '<div class="metric-warnings">' + metric.proofWarnings.map(function(w) { return '<div class="metric-warning">' + w + '</div>'; }).join('') + '</div>';
+        }
+
+        card.innerHTML = '<div class="metric-header">Token Savings</div><div class="metric-main">' + metric.reduction + '</div><div class="metric-detail">Packet: ' + metric.packetTokens + '  |  Workspace: ' + metric.workspaceTokens + '  |  ' + metric.tokenizer + '</div>' + statusChip + coverageHtml + warningsHtml;
+        bubble.appendChild(card);
+      }
+
+      if (files && files.length) {
+        var fl = document.createElement('div');
+        fl.className = 'file-list';
+        files.forEach(function(f) {
+          var fr = document.createElement('div');
+          fr.className = 'file-row';
+          fr.title = f.path + ' - Click to open';
+          fr.addEventListener('click', function() { vscode.postMessage({ type: 'openFile', file: f.path }); });
+          fr.innerHTML = '<span class="path">' + f.path + '</span><span class="tag">' + f.role + '</span><span class="score">' + f.score + '</span>';
+          fl.appendChild(fr);
+        });
+        bubble.appendChild(fl);
+      }
+
+      if (feedback) {
+        var fb = document.createElement('div');
+        fb.className = 'feedback-bar';
+        fb.innerHTML = '<span class="feedback-label">Was this helpful?</span>';
+        [
+          { k: 'relevant', t: 'Relevant' },
+          { k: 'missing_file', t: 'Missing files' },
+          { k: 'not_relevant', t: 'Irrelevant' },
+          { k: 'agent_needed_more_context', t: 'AI needs more' }
+        ].forEach(function(item) {
+          var btn = document.createElement('button');
+          btn.className = 'tiny ' + (item.k === 'relevant' ? 'positive' : 'secondary');
+          btn.textContent = item.t;
+          btn.addEventListener('click', function() { vscode.postMessage({ type: 'feedback', runId: feedback.runId, kind: item.k }); });
+          fb.appendChild(btn);
+        });
+        bubble.appendChild(fb);
+      }
+
+      if (trace && trace.length) {
+        var traceList = document.createElement('div');
+        traceList.className = 'trace-list';
+        trace.forEach(function(item) {
+          var row = document.createElement('div');
+          row.className = 'trace-row';
+          var dot = document.createElement('span');
+          dot.className = 'trace-dot';
+          var label = document.createElement('span');
+          label.className = 'trace-text';
+          label.textContent = item;
+          row.appendChild(dot);
+          row.appendChild(label);
+          traceList.appendChild(row);
+        });
+        bubble.appendChild(traceList);
+      }
+
+      if (proposal) {
+        var prop = document.createElement('div');
+        prop.style.cssText = 'margin-top:10px;';
+        if (proposal.kind === 'plan') {
+          var approveBtn = document.createElement('button');
+          approveBtn.className = 'primary action-btn';
+          approveBtn.textContent = 'Approve plan and generate edits';
+          approveBtn.addEventListener('click', function() { vscode.postMessage({ type: 'approvePlan', planId: proposal.id }); });
+          prop.appendChild(approveBtn);
+          bubble.appendChild(prop);
+          body.appendChild(bubble);
+          messages.appendChild(row);
+          messages.scrollTop = messages.scrollHeight;
+          return;
+        }
+        if (proposal.edits && proposal.edits.length) {
+          var list = document.createElement('div');
+          list.style.cssText = 'display:flex;flex-direction:column;gap:3px;margin-bottom:8px;';
+          proposal.edits.forEach(function(e) {
+            var span = document.createElement('span');
+            span.style.cssText = 'font-size:11px;font-family:var(--mono);color:var(--muted);';
+            span.textContent = e.file + (e.range ? ' ' + e.range : '');
+            list.appendChild(span);
+          });
+          prop.appendChild(list);
+        }
+        var diffBtn = document.createElement('button');
+        diffBtn.className = 'secondary action-btn';
+        diffBtn.textContent = 'Open diff';
+        diffBtn.addEventListener('click', function() { vscode.postMessage({ type: 'openDiff', proposalId: proposal.id }); });
+        prop.appendChild(diffBtn);
+        var applyBtn = document.createElement('button');
+        applyBtn.className = 'primary action-btn';
+        applyBtn.textContent = 'Apply proposed edits';
+        applyBtn.addEventListener('click', function() { vscode.postMessage({ type: 'applyEdits', proposalId: proposal.id }); });
+        prop.appendChild(applyBtn);
+        bubble.appendChild(prop);
+      }
+
+      if (commands && commands.length) {
+        var commandList = document.createElement('div');
+        commandList.className = 'command-list';
+        commands.forEach(function(cmd) {
+          var row = document.createElement('div');
+          row.className = 'command-row';
+          var main = document.createElement('div');
+          main.className = 'command-main';
+          var textEl = document.createElement('span');
+          textEl.className = 'command-text';
+          textEl.textContent = cmd.command || '';
+          main.appendChild(textEl);
+          if (cmd.rationale) {
+            var reason = document.createElement('span');
+            reason.className = 'command-reason';
+            reason.textContent = cmd.rationale;
+            main.appendChild(reason);
+          }
+          var runBtn = document.createElement('button');
+          runBtn.className = 'secondary tiny action-btn';
+          runBtn.textContent = 'Run';
+          runBtn.addEventListener('click', function() {
+            vscode.postMessage({ type: 'runAgentCommand', command: cmd });
+          });
+          row.appendChild(main);
+          row.appendChild(runBtn);
+          commandList.appendChild(row);
+        });
+        bubble.appendChild(commandList);
+      }
+
+      if (mcpTools && mcpTools.length) {
+        var toolList = document.createElement('div');
+        toolList.className = 'command-list';
+        mcpTools.forEach(function(tool) {
+          var row = document.createElement('div');
+          row.className = 'command-row';
+          var main = document.createElement('div');
+          main.className = 'command-main';
+          var textEl = document.createElement('span');
+          textEl.className = 'command-text';
+          textEl.textContent = tool.tool || '';
+          main.appendChild(textEl);
+          if (tool.rationale) {
+            var reason = document.createElement('span');
+            reason.className = 'command-reason';
+            reason.textContent = tool.rationale;
+            main.appendChild(reason);
+          }
+          var runBtn = document.createElement('button');
+          runBtn.className = 'secondary tiny action-btn';
+          runBtn.textContent = 'Invoke';
+          runBtn.addEventListener('click', function() {
+            vscode.postMessage({ type: 'runMcpTool', tool: tool });
+          });
+          row.appendChild(main);
+          row.appendChild(runBtn);
+          toolList.appendChild(row);
+        });
+        bubble.appendChild(toolList);
+      }
+
+      if (verificationFiles && verificationFiles.length) {
+        var verify = document.createElement('div');
+        verify.style.cssText = 'margin-top:10px;';
+        var verifyBtn = document.createElement('button');
+        verifyBtn.className = 'secondary action-btn';
+        verifyBtn.textContent = 'Verify changes';
+        verifyBtn.addEventListener('click', function() {
+          vscode.postMessage({ type: 'verifyFiles', files: verificationFiles });
+        });
+        verify.appendChild(verifyBtn);
+        bubble.appendChild(verify);
+      }
+
+      // Copy button (visible on hover)
+      var actions = document.createElement('div');
+      actions.className = 'msg-actions';
+      var copyBtn = document.createElement('button');
+      copyBtn.className = 'secondary tiny';
+      copyBtn.textContent = 'Copy';
+      copyBtn.addEventListener('click', function() {
+        navigator.clipboard.writeText(text || '').catch(function() {});
+        copyBtn.textContent = 'Copied!';
+        setTimeout(function() { copyBtn.textContent = 'Copy'; }, 1500);
+      });
+      actions.appendChild(copyBtn);
+      if (metric) {
+        var proofBtn = document.createElement('button');
+        proofBtn.className = 'secondary tiny';
+        proofBtn.textContent = 'Copy proof';
+        proofBtn.title = 'Copy token proof summary';
+        proofBtn.addEventListener('click', function() { vscode.postMessage({ type: 'copyTokenProof' }); });
+        actions.appendChild(proofBtn);
+      }
+      bubble.appendChild(actions);
+
+      body.appendChild(bubble);
+      messages.appendChild(row);
+      messages.scrollTop = messages.scrollHeight;
+    }
+
+    function startStreamingMessage() {
+      removeStreamingMessage();
+      removeEmpty();
+      activeStreamingText = '';
+      activeStreamingRow = msgRow('assistant');
+      var body = activeStreamingRow.querySelector('.msg-body');
+      var bubble = document.createElement('div');
+      bubble.className = 'bubble';
+      activeStreamingContent = document.createElement('div');
+      activeStreamingContent.className = 'content';
+      bubble.appendChild(activeStreamingContent);
+      body.appendChild(bubble);
+      messages.appendChild(activeStreamingRow);
+      messages.scrollTop = messages.scrollHeight;
+    }
+
+    function appendStreamingMessage(text) {
+      if (!activeStreamingRow) startStreamingMessage();
+      activeStreamingText += text || '';
+      activeStreamingContent.innerHTML = renderMarkdown(activeStreamingText);
+      messages.scrollTop = messages.scrollHeight;
+    }
+
+    function removeStreamingMessage() {
+      if (activeStreamingRow && activeStreamingRow.parentElement) {
+        activeStreamingRow.parentElement.removeChild(activeStreamingRow);
+      }
+      activeStreamingRow = null;
+      activeStreamingContent = null;
+      activeStreamingText = '';
+    }
+
+    function removeEmpty() {
+      var e = document.getElementById('empty');
+      if (e) { e.style.display = 'none'; }
+    }
+
+    function clearMessages() {
+      messages.innerHTML = '';
+      var empty = document.createElement('div');
+      empty.className = 'empty-state';
+      empty.id = 'empty';
+      empty.innerHTML = '<div class="brand-lg"><img src="${logoUri}" alt=""></div><div class="empty-title"><span class="wordmark" data-text="FlowSeeker">FlowSeeker</span></div><div class="empty-hint">New session</div>';
+      messages.appendChild(empty);
+    }
+
+    function renderMessages(historyMessages) {
+      clearMessages();
+      if (!historyMessages || !historyMessages.length) return;
+      historyMessages.forEach(function(msg) {
+        addMessage(msg.kind || msg.type || 'assistant', msg.text, msg.files, msg.proposal, msg.metric, msg.feedback, msg.verificationFiles, msg.trace, msg.commands, msg.mcpTools);
+      });
+    }
+
+    function renderThreadList(threads, activeId) {
+      activeThreadId = activeId || activeThreadId;
+      threadList.innerHTML = '';
+      (threads || []).forEach(function(thread) {
+        var row = document.createElement('div');
+        row.className = 'thread-row' + (thread.id === activeThreadId ? ' active' : '');
+        row.title = thread.title || 'New chat';
+        row.addEventListener('click', function() {
+          if (thread.id !== activeThreadId && !busy) vscode.postMessage({ type: 'selectThread', threadId: thread.id });
+        });
+
+        var main = document.createElement('div');
+        main.className = 'thread-main';
+        var title = document.createElement('div');
+        title.className = 'thread-title';
+        title.textContent = thread.title || 'New chat';
+        var meta = document.createElement('div');
+        meta.className = 'thread-meta';
+        meta.textContent = formatThreadTime(thread.updatedAt) + ' - ' + (thread.messageCount || 0) + ' msg';
+        main.appendChild(title);
+        main.appendChild(meta);
+
+        var del = document.createElement('button');
+        del.className = 'thread-delete';
+        del.title = 'Delete chat';
+        del.textContent = 'x';
+        del.addEventListener('click', function(event) {
+          event.stopPropagation();
+          if (!busy) vscode.postMessage({ type: 'deleteThread', threadId: thread.id });
+        });
+
+        row.appendChild(main);
+        row.appendChild(del);
+        threadList.appendChild(row);
+      });
+    }
+
+    function renderQuotaPanel(usage, profiles, quotaDebug) {
+      var panel = document.getElementById('quotaPanel');
+      var summary = document.getElementById('quotaSummaryText');
+      var badge = document.getElementById('quotaBadge');
+      var detail = document.getElementById('quotaDetail');
+
+      if (!panel || !summary || !badge || !detail) return;
+
+      // Debug: show total record count from backend
+      var debugInfo = (typeof quotaDebug === 'number') ? ' [' + quotaDebug + ' records]' : '';
+
+      // Build model list from usage data + profiles
+      var models = [];
+      var seen = {};
+      if (usage && usage.models && usage.models.length) {
+        usage.models.forEach(function(m) {
+          var k = m.provider + '|' + m.model;
+          seen[k] = true;
+          models.push(m);
+        });
+      }
+      if (profiles && profiles.length) {
+        var now = Date.now();
+        var tmr = new Date(); tmr.setDate(tmr.getDate() + 1); tmr.setHours(0,0,0,0);
+        profiles.forEach(function(p) {
+          var k = p.provider + '|' + p.model;
+          if (!seen[k]) {
+            seen[k] = true;
+            models.push({
+              provider: p.provider, model: p.model,
+              dailyTokensUsed: -1, dailyTokenLimit: -1, dailyPct: -1,
+              quotaSource: 'unknown',
+              monthlyCostUsed: -1, monthlyCostLimit: -1, monthlyPct: -1,
+              requestsToday: 0, dailyResetMs: tmr.getTime(), monthlyResetMs: tmr.getTime()
+            });
+          }
+        });
+      }
+
+      if (!models.length) { panel.classList.remove('open'); return; }
+      panel.classList.add('open');
+
+      var hasAnyUsage = models.some(function(m) {
+        return m.dailyTokensUsed >= 0 || m.quotaSource === 'live' ||
+          typeof m.requestsLimit === 'number' || typeof m.requestsRemaining === 'number';
+      });
+      var maxPct = 0;
+      var totalTodayTokens = 0;
+      models.forEach(function(m) {
+        var requestPct = requestQuotaPct(m);
+        var pct = m.dailyPct >= 0 ? m.dailyPct : requestPct;
+        if (pct > maxPct) maxPct = pct;
+        if (m.dailyTokensUsed > 0) totalTodayTokens += m.dailyTokensUsed;
+      });
+
+      if (hasAnyUsage) {
+        var badgeClass = maxPct >= 80 ? 'danger' : maxPct >= 50 ? 'warn' : 'ok';
+        badge.textContent = maxPct + '%';
+        badge.className = 'quota-badge ' + badgeClass;
+        summary.textContent = 'Quota: ' + formatTokenCount(totalTodayTokens) + ' today / $' + (usage ? usage.todayCostUSD.toFixed(2) : '0.00') + ' today - click to expand' + debugInfo;
+      } else {
+        badge.textContent = '?';
+        badge.className = 'quota-badge ok';
+        summary.textContent = 'Quota: fetch from next request - click to expand' + debugInfo;
+      }
+
+      var detailHtml = '';
+      models.forEach(function(m) {
+        var hasTokenData = m.dailyTokensUsed >= 0;
+        var hasTokenLimit = m.dailyTokenLimit > 0;
+        var hasRequestLimit = typeof m.requestsLimit === 'number' && m.requestsLimit >= 0;
+        var hasRequestRemaining = typeof m.requestsRemaining === 'number' && m.requestsRemaining >= 0;
+        var hasData = hasTokenData || hasRequestLimit || hasRequestRemaining || m.quotaSource === 'live';
+        var requestPct = requestQuotaPct(m);
+        var dailyPct = hasTokenLimit && m.dailyPct >= 0 ? m.dailyPct : requestPct;
+        if (dailyPct < 0) dailyPct = 0;
+        var barClass = dailyPct >= 80 ? 'high' : dailyPct >= 50 ? 'mid' : 'low';
+        var resetCountdown = formatCountdown((m.dailyResetMs || Date.now() + 86400000) - Date.now());
+        var statusLabel = m.quotaSource === 'live' ? 'Live' : m.quotaSource === 'manual' ? 'Manual' : m.quotaSource === 'default' ? 'Default' : 'Unknown';
+        var statusColor = hasData ? 'var(--vscode-foreground)' : 'var(--muted)';
+        var tokenText = hasTokenData
+          ? formatTokenCount(m.dailyTokensUsed) + (hasTokenLimit ? ' / ' + formatTokenCount(m.dailyTokenLimit) : '') + ' tokens today'
+          : 'Token limit unknown';
+        var requestText = requestQuotaText(m);
+        var costText = m.monthlyCostUsed >= 0
+          ? '$' + (m.monthlyCostUsed||0).toFixed(2) + ' / $' + (m.monthlyCostLimit||10) + ' this month'
+          : 'cost unknown';
+        detailHtml +=
+          '<div class="quota-row">' +
+            '<span class="quota-model-name">' + (m.provider || '') + ' / ' + (m.model || '') + '</span>' +
+            '<span style="font-weight:700;font-size:11px;color:' + statusColor + '">' + (hasData && dailyPct > 0 ? dailyPct + '%' : statusLabel) + '</span>' +
+            '<div class="quota-bar-wrap"><div class="quota-bar-fill ' + barClass + '" style="width:' + dailyPct + '%"></div></div>' +
+            '<span class="quota-stats">' +
+              (hasData
+                ? tokenText + ' | ' + requestText + ' | ' + costText + ' | '
+                : 'Will update after next API request | ') +
+              'resets in ' + resetCountdown +
+            '</span>' +
+          '</div>';
+      });
+      detail.innerHTML = detailHtml;
+    }
+
+    function requestQuotaPct(m) {
+      if (typeof m.requestsLimit !== 'number' || m.requestsLimit <= 0 || typeof m.requestsRemaining !== 'number') return -1;
+      var used = Math.max(0, m.requestsLimit - m.requestsRemaining);
+      return Math.min(100, Math.round((used / m.requestsLimit) * 100));
+    }
+
+    function requestQuotaText(m) {
+      var hasLimit = typeof m.requestsLimit === 'number' && m.requestsLimit >= 0;
+      var hasRemaining = typeof m.requestsRemaining === 'number' && m.requestsRemaining >= 0;
+      if (hasLimit && hasRemaining) {
+        return formatTokenCount(Math.max(0, m.requestsLimit - m.requestsRemaining)) + ' / ' + formatTokenCount(m.requestsLimit) + ' provider reqs';
+      }
+      if (hasRemaining) return formatTokenCount(m.requestsRemaining) + ' provider reqs remaining';
+      if (hasLimit) return formatTokenCount(m.requestsLimit) + ' provider req limit';
+      return (m.requestsToday || 0) + ' reqs';
+    }
+
+    function formatTokenCount(n) {
+      if (n >= 1000000) return (n / 1000000).toFixed(1) + 'M';
+      if (n >= 1000) return (n / 1000).toFixed(1) + 'K';
+      return String(n);
+    }
+
+    function formatCountdown(ms) {
+      if (ms <= 0) return 'soon';
+      var h = Math.floor(ms / 3600000);
+      var m = Math.floor((ms % 3600000) / 60000);
+      if (h > 0) return h + 'h ' + m + 'm';
+      return m + 'm';
+    }
+
+    function renderModelDropdown(models, activeModelId, providerId) {
+      var sel = document.getElementById('oauthModelSelect');
+      if (!sel) return;
+      providerModelOptions = Array.isArray(models) ? models : [];
+      providerModelOptionsProvider = providerId || provider.value || '';
+      sel.innerHTML = '';
+      if (!providerModelOptions.length) {
+        var placeholder = document.createElement('option');
+        placeholder.value = '';
+        placeholder.textContent = providerMeta[providerModelOptionsProvider]?.requiresApiKey ? 'Enter API key to load models' : 'No models found';
+        placeholder.disabled = true;
+        placeholder.selected = true;
+        sel.appendChild(placeholder);
+      }
+      providerModelOptions.forEach(function(m) {
+        var opt = document.createElement('option');
+        opt.value = m.id;
+        opt.textContent = m.name || m.id;
+        if (m.id === activeModelId) opt.selected = true;
+        sel.appendChild(opt);
+      });
+      if (activeModelId && !providerModelOptions.some(function(m) { return m.id === activeModelId; })) {
+        var fallback = document.createElement('option');
+        fallback.value = activeModelId;
+        fallback.textContent = activeModelId;
+        fallback.selected = true;
+        sel.insertBefore(fallback, sel.firstChild);
+      }
+      applyProviderDefaults(false);
+    }
+
+    function renderAgentPolicy(policy) {
+      policy = policy || {};
+      var parts = [];
+      parts.push(policy.editWorkspace ? 'auto edits on' : 'review edits');
+      if (policy.allCommands) parts.push('commands auto');
+      else if (policy.safeCommands) parts.push('safe checks auto');
+      else parts.push('manual checks');
+      if (policy.mcpTools) parts.push('MCP auto');
+      if (policy.mcpServerCount) parts.push(policy.mcpServerCount + ' MCP');
+      if (policy.rulesCount) parts.push(policy.rulesCount + ' rule' + (policy.rulesCount === 1 ? '' : 's'));
+      agentPolicyText.textContent = parts.join(' · ');
+
+      var mcpServerLines = ['MCP servers:'];
+      if (policy.mcpServers && policy.mcpServers.length) {
+        policy.mcpServers.forEach(function(s) {
+          var status = !s.enabled ? 'disabled' : s.valid ? 'configured' : 'misconfigured';
+          mcpServerLines.push('  ' + s.name + ' (' + s.type + ') - ' + status);
+        });
+      } else {
+        mcpServerLines.push('  none configured');
+      }
+      agentPolicy.title = [
+        'Workspace reads: ' + (policy.readWorkspace ? 'allowed' : 'ask first'),
+        'Workspace edits: ' + (policy.editWorkspace ? 'auto-approved' : 'review before apply'),
+        'Safe commands: ' + (policy.safeCommands ? 'auto-approved' : 'manual'),
+        'All commands: ' + (policy.allCommands ? 'auto-approved' : 'manual'),
+        'MCP tools: ' + (policy.mcpTools ? 'auto-approved' : 'manual'),
+        ''
+      ].concat(mcpServerLines).concat([
+        '',
+        'Rules: ' + (policy.rulesCount || 0)
+      ]).join('\\n');
+      agentPolicy.classList.toggle('relaxed', Boolean(policy.editWorkspace || policy.safeCommands || policy.mcpTools));
+      agentPolicy.classList.toggle('risky', Boolean(policy.allCommands));
+      if (policyReadWorkspace) policyReadWorkspace.checked = Boolean(policy.readWorkspace);
+      if (policyEditWorkspace) policyEditWorkspace.checked = Boolean(policy.editWorkspace);
+      if (policySafeCommands) policySafeCommands.checked = Boolean(policy.safeCommands);
+      if (policyAllCommands) policyAllCommands.checked = Boolean(policy.allCommands);
+      if (policyMcpTools) policyMcpTools.checked = Boolean(policy.mcpTools);
+      if (agentRules && document.activeElement !== agentRules) {
+        agentRules.value = Array.isArray(policy.rules) ? policy.rules.join('\\n') : '';
+      }
+    }
+
+    function formatThreadTime(value) {
+      if (!value) return 'Now';
+      var date = new Date(value);
+      if (Number.isNaN(date.getTime())) return 'Now';
+      return date.toLocaleString(undefined, { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' });
+    }
+
+    function setAgentState(state) {
+      agentState = state;
+      var isBusy = state !== 'idle' && state !== 'cancelled' && state !== 'retrieval_complete';
+      busy = isBusy;
+      sendButton.style.display = isBusy ? 'none' : '';
+      stopBtn.style.display = isBusy ? '' : 'none';
+      task.readOnly = isBusy;
+      task.style.opacity = isBusy ? '.55' : '1';
+      if (!isBusy) task.focus();
+      // Disable action buttons on past messages when busy with another action
+      var actionBtns = messages.querySelectorAll('.action-btn');
+      actionBtns.forEach(function(btn) { btn.disabled = isBusy; });
+    }
+
+    window.addEventListener('message', function(event) {
+      var msg = event.data;
+      if (msg.type === 'connection') {
+        renderProviderProfiles(msg.profiles || [], msg.activeProfileId || msg.profileId || '');
+        var usageText = '';
+        if (msg.usage && msg.usage.totalCostUSD > 0) {
+          usageText = '  |  Today $' + msg.usage.todayCostUSD.toFixed(3) + '  |  Total $' + msg.usage.totalCostUSD.toFixed(3) + ' (' + msg.usage.totalRequests + ' reqs)';
+        }
+        statusBadge.textContent = msg.connected ? 'Connected' : 'Disconnected';
+        connectionStatusText.textContent = msg.connected
+          ? 'Ready - ' + (msg.providerLabel || msg.provider || 'AI provider') + usageText
+          : 'Local retrieval only' + usageText;
+        connection.classList.toggle('connected', Boolean(msg.connected));
+        renderGatewayConnectionStatus(msg.connected, msg.providerLabel || msg.provider || '', msg.model || '');
+        renderQuotaPanel(msg.usage, msg.profiles, msg.quotaDebug);
+        var activeProfile = providerProfiles.find(function(profile) { return profile.id === activeProfileId; });
+        var activeProviderForModels = activeProfile ? activeProfile.provider : msg.provider;
+        var activeModelForModels = activeProfile ? activeProfile.model : msg.model;
+        renderModelDropdown(msg.models || [], activeModelForModels || '', activeProviderForModels || '');
+        if (activeProfile) {
+          syncProviderForm(activeProfile);
+        } else {
+          if (msg.provider) provider.value = msg.provider;
+          if (msg.model) model.value = msg.model;
+          if (msg.baseUrl) baseUrl.value = msg.baseUrl;
+          applyProviderDefaults(false);
+        }
+        return;
+      }
+      if (msg.type === 'gatewayFeedback') {
+        showGatewayFeedback(msg.status || 'info', msg.text || '', true);
+        return;
+      }
+      if (msg.type === 'agentPolicy') {
+        renderAgentPolicy(msg);
+        return;
+      }
+      if (msg.type === 'models') {
+        if (!msg.provider || msg.provider === provider.value) {
+          renderModelDropdown(msg.models || [], msg.model || model.value || '', msg.provider || provider.value);
+        }
+        return;
+      }
+      if (msg.type === 'threadState') {
+        renderThreadList(msg.threads || [], msg.activeThreadId || '');
+        renderMessages(msg.messages || []);
+        setAgentState('idle');
+        return;
+      }
+      if (msg.type === 'threads') {
+        renderThreadList(msg.threads || [], msg.activeThreadId || '');
+        return;
+      }
+      if (msg.type === 'assistantStart') {
+        startStreamingMessage();
+        setAgentState('asking_provider');
+        return;
+      }
+      if (msg.type === 'assistantDelta') {
+        appendStreamingMessage(msg.text || '');
+        setAgentState('asking_provider');
+        return;
+      }
+      if (msg.type === 'retrieval') {
+        addMessage('retrieval', msg.text, msg.files || [], msg.proposal, msg.metric, msg.feedback, msg.verificationFiles, msg.trace, msg.commands, msg.mcpTools);
+        setAgentState('retrieval_complete');
+        return;
+      }
+      if (msg.type === 'status') {
+        addMessage('status', msg.text, void 0, void 0, void 0, void 0, msg.verificationFiles, msg.trace, msg.commands, msg.mcpTools);
+        var statusText = (msg.text || '').toLowerCase();
+        if (statusText.indexOf('cancelled') >= 0) { removeStreamingMessage(); setAgentState('cancelled'); }
+        else if (statusText.indexOf('verifying') >= 0) setAgentState('verifying');
+        else if (statusText.indexOf('applying') >= 0) setAgentState('applying_edits');
+        else if (statusText.indexOf('finding') >= 0 || statusText.indexOf('retriev') >= 0) setAgentState('retrieving');
+        else if (statusText.indexOf('asking') >= 0) setAgentState('asking_provider');
+        return;
+      }
+      if (msg.type === 'assistant' || msg.type === 'user' || msg.type === 'error') {
+        if (msg.type === 'assistant' || msg.type === 'error') removeStreamingMessage();
+        addMessage(msg.type, msg.text, void 0, msg.proposal, msg.metric, msg.feedback, msg.verificationFiles, msg.trace, msg.commands, msg.mcpTools);
+        setAgentState('idle');
+      }
+    });
+
+    function send() {
+      var cleanTask = task.value.trim();
+      if (!cleanTask || busy) return;
+      setAgentState('retrieving');
+      vscode.postMessage({ type: 'ask', task: cleanTask, mode: currentMode });
+      task.value = '';
+    }
+
+    vscode.postMessage({ type: 'ready' });
+  </script>
+</body>
+</html>`;
+    }
+}
+exports.ChatViewProvider = ChatViewProvider;
+ChatViewProvider.viewType = "flowseeker.chatView";
+function formatFileSummary(result) {
+    const groups = (0, fileGroups_1.aggregateEvidenceFiles)(result.units).slice(0, 8);
+    const stats = result.stats;
+    return [
+        `FlowSeeker retrieved ${result.units.length} evidence units from ${stats.scannedFiles} scanned files.`,
+        result.contextCoverage
+            ? `Context coverage: ${result.contextCoverage.foundRequiredSlots.length}/${result.contextCoverage.requiredSlots.length} required slots${result.contextCoverage.missingRequiredSlots.length ? `; missing ${result.contextCoverage.missingRequiredSlots.join(", ")}` : ""}.`
+            : "",
+        `Intent: ${result.profile.intent}`,
+        `Keywords: ${result.profile.keywords.join(", ") || "none"}`,
+        "",
+        "Top files:",
+        ...groups.map((group, index) => `${index + 1}. ${group.relativePath} [${group.role}/${group.slot}] score=${group.score.toFixed(1)} evidence=${group.unitCount}`)
+    ].join("\n");
+}
+function formatTokenMetric(result) {
+    const tokenSavings = result.tokenSavings;
+    if (!tokenSavings || tokenSavings.status === "unavailable") {
+        return undefined;
+    }
+    return {
+        packetTokens: (0, tokenSavings_1.formatTokenCount)(tokenSavings.solvePacketTokensEstimate),
+        workspaceTokens: (0, tokenSavings_1.formatTokenCount)(tokenSavings.workspaceTokensEstimate),
+        reduction: (0, tokenSavings_1.formatReductionPercent)(tokenSavings.reductionPercent),
+        tokenizer: tokenSavings.tokenizer,
+        proofStatus: tokenSavings.proofStatus,
+        proofWarnings: tokenSavings.proofWarnings ?? [],
+        contextCoverage: result.contextCoverage
+            ? `${result.contextCoverage.foundRequiredSlots.length}/${result.contextCoverage.requiredSlots.length} slots`
+            : ""
+    };
+}
+function createThread() {
+    const now = new Date().toISOString();
+    return {
+        id: createThreadId(),
+        title: "New chat",
+        createdAt: now,
+        updatedAt: now,
+        messages: []
+    };
+}
+function createThreadId() {
+    return `thread-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function titleFromMessage(text) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    if (!collapsed) {
+        return "New chat";
+    }
+    return collapsed.length > 46 ? `${collapsed.slice(0, 43)}...` : collapsed;
+}
+function normalizeThreads(threads) {
+    const now = new Date().toISOString();
+    return threads
+        .filter((thread) => thread && typeof thread.id === "string")
+        .map((thread) => ({
+        id: thread.id,
+        title: thread.title || titleFromMessage(thread.messages?.find((message) => message.kind === "user")?.text ?? "New chat"),
+        createdAt: thread.createdAt || now,
+        updatedAt: thread.updatedAt || thread.createdAt || now,
+        messages: Array.isArray(thread.messages) ? thread.messages.slice(-maxHistoryMessages) : []
+    }))
+        .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+}
+function isCancellationError(error) {
+    return error instanceof Error && /^cancelled$/i.test(error.message.trim());
+}
+function getNonce() {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let nonce = "";
+    for (let index = 0; index < 32; index += 1) {
+        nonce += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return nonce;
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function toProviderInput(message) {
+    const provider = message.provider ?? "customGateway";
+    return {
+        provider,
+        model: message.model,
+        baseUrl: message.baseUrl ?? message.endpoint,
+        apiKey: message.token
+    };
+}
+function formatErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function shouldProbeQuotaOnConnect(provider) {
+    return provider !== "codexCli" && provider !== "claudeCode" && provider !== "ollama";
+}
+function formatQuotaProbeWarning(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/429/.test(message) && /quota|billing/i.test(message)) {
+        return "The API key is valid enough to save and fetch models, but the provider rejected text generation with quota/billing exhausted. Add billing, raise the project budget, or use another key/project before asking FlowSeeker to call the model.";
+    }
+    if (/429/.test(message)) {
+        return "The provider rate-limited the test request. The profile was saved; try again later or use another model/key.";
+    }
+    return message;
+}
+function renderHistoryMessage(message) {
+    const state = message.kind === "status" && /cancelled/i.test(message.text) ? "cancelled"
+        : message.kind === "status" && /verifying/i.test(message.text) ? "verifying"
+            : message.kind === "status" && /applying/i.test(message.text) ? "applying_edits"
+                : message.kind === "status" && /finding/i.test(message.text) ? "retrieving"
+                    : message.kind === "status" && /asking/i.test(message.text) ? "asking_provider"
+                        : message.kind === "error" ? "error"
+                            : message.kind === "assistant" || message.kind === "user" ? "idle"
+                                : undefined;
+    return {
+        type: message.kind === "retrieval" ? "retrieval" : message.kind,
+        kind: message.kind,
+        text: message.text,
+        state,
+        trace: message.trace,
+        commands: message.commands,
+        mcpTools: message.mcpTools,
+        files: message.files,
+        metric: message.metric,
+        feedback: message.feedback,
+        proposal: message.proposal,
+        verificationFiles: message.verificationFiles
+    };
+}
+//# sourceMappingURL=chatViewProvider.js.map