sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/chat-panel/ChatContextPicker.ts

@@ -0,0 +1,191 @@
+/**
+ * ChatContextPicker — handles context picker UI for different context types.
+ * Extracted from ChatPanelProvider for SRP.
+ */
+
+import * as vscode from "vscode";
+import * as path from "path";
+import { ChatExtToWebviewMessage } from "./message-protocol";
+
+type ContextItem = { type: string; label: string; path?: string; content?: string };
+
+export class ChatContextPicker {
+  constructor(
+    private readonly workspaceRoot: string,
+    private readonly sendToWebview: (msg: ChatExtToWebviewMessage) => void
+  ) {}
+
+  async pick(contextType: string): Promise<void> {
+    let item: ContextItem | undefined;
+    switch (contextType) {
+      case "file": item = await this.pickFile(); break;
+      case "folder": item = await this.pickFolder(); break;
+      case "problems": item = this.pickProblems(); break;
+      case "gitDiff": item = await this.pickGitDiff(); break;
+      case "terminal": item = await this.pickTerminal(); break;
+      case "spec": item = await this.pickSpec(); break;
+      case "currentFile": item = this.pickCurrentFile(); break;
+      case "steering": item = await this.pickSteering(); break;
+      case "mcp": item = await this.pickMcp(); break;
+    }
+    if (item) {
+      this.sendToWebview({ type: "chat:contextPicked", item: item as any });
+    }
+  }
+
+  private async pickFile(): Promise<ContextItem | undefined> {
+    const files = await vscode.workspace.findFiles("**/*", "{**/node_modules/**,**/.git/**,**/out/**,**/dist/**}", 500);
+    if (files.length === 0) { return undefined; }
+    const items = files.map(f => ({ label: path.basename(f.fsPath), description: vscode.workspace.asRelativePath(f), uri: f })).sort((a, b) => a.label.localeCompare(b.label));
+    const picked = await vscode.window.showQuickPick(items, { title: "Select File", placeHolder: "Type to search...", matchOnDescription: true });
+    if (!picked) { return undefined; }
+    const doc = await vscode.workspace.openTextDocument(picked.uri);
+    return { type: "file", label: vscode.workspace.asRelativePath(picked.uri), path: picked.uri.fsPath, content: doc.getText().slice(0, 50000) };
+  }
+
+  private async pickFolder(): Promise<ContextItem | undefined> {
+    const allFiles = await vscode.workspace.findFiles("**/*", "{**/node_modules/**,**/.git/**,**/out/**,**/dist/**}", 1000);
+    const folderSet = new Set<string>();
+    for (const f of allFiles) {
+      const rel = vscode.workspace.asRelativePath(f);
+      const dir = path.dirname(rel);
+      if (dir && dir !== ".") {
+        folderSet.add(dir);
+        const parts = dir.split(/[/\\]/);
+        for (let i = 1; i < parts.length; i++) { folderSet.add(parts.slice(0, i).join("/")); }
+      }
+    }
+    const items = Array.from(folderSet).sort().map(f => ({ label: path.basename(f), description: f, folderPath: f }));
+    const picked = await vscode.window.showQuickPick(items, { title: "Select Folder", placeHolder: "Type to search folders...", matchOnDescription: true });
+    if (!picked) { return undefined; }
+    const folderUri = vscode.Uri.joinPath(vscode.workspace.workspaceFolders![0].uri, picked.folderPath);
+    const filesInFolder = await vscode.workspace.findFiles(new vscode.RelativePattern(folderUri, "**/*"), "**/node_modules/**", 100);
+    const listing = filesInFolder.map(f => vscode.workspace.asRelativePath(f)).sort().join("\n");
+    return { type: "folder", label: picked.folderPath, path: folderUri.fsPath, content: listing };
+  }
+
+  private pickProblems(): ContextItem {
+    const diagnostics = vscode.languages.getDiagnostics();
+    const lines: string[] = [];
+    let totalCount = 0;
+    for (const [uri, diags] of diagnostics) {
+      if (diags.length === 0) { continue; }
+      const relPath = vscode.workspace.asRelativePath(uri);
+      for (const d of diags) {
+        const sev = d.severity === vscode.DiagnosticSeverity.Error ? "ERROR" : d.severity === vscode.DiagnosticSeverity.Warning ? "WARN" : "INFO";
+        lines.push(`[${sev}] ${relPath}:${d.range.start.line + 1}: ${d.message}`);
+        totalCount++;
+      }
+    }
+    return { type: "problems", label: `Problems (${totalCount})`, content: lines.length > 0 ? lines.join("\n") : "No problems found." };
+  }
+
+  private async pickGitDiff(): Promise<ContextItem> {
+    try {
+      const gitExt = vscode.extensions.getExtension("vscode.git");
+      let diffContent = "";
+      if (gitExt) {
+        const git = gitExt.exports.getAPI(1);
+        if (git?.repositories?.length > 0) {
+          diffContent = await git.repositories[0].diff(true) || await git.repositories[0].diff() || "";
+        }
+      }
+      if (!diffContent) {
+        const cp = require("child_process");
+        diffContent = cp.execSync("git diff --stat && echo --- && git diff", { cwd: this.workspaceRoot, encoding: "utf-8", timeout: 10000 }).toString().slice(0, 50000);
+      }
+      return { type: "gitDiff", label: "Git Diff", content: diffContent || "No changes detected." };
+    } catch (e) {
+      return { type: "gitDiff", label: "Git Diff", content: `Error: ${(e as Error).message}` };
+    }
+  }
+
+  private async pickTerminal(): Promise<ContextItem> {
+    let content = "";
+    const activeTerminal = vscode.window.activeTerminal;
+    if (activeTerminal) {
+      try {
+        await vscode.commands.executeCommand("workbench.action.terminal.selectAll");
+        await vscode.commands.executeCommand("workbench.action.terminal.copySelection");
+        content = (await vscode.env.clipboard.readText()).slice(-20000);
+        await vscode.commands.executeCommand("workbench.action.terminal.clearSelection");
+      } catch { content = `Terminal "${activeTerminal.name}" content could not be read.`; }
+    } else { content = "No active terminal."; }
+    return { type: "terminal", label: "Terminal", content };
+  }
+
+  private async pickSpec(): Promise<ContextItem | undefined> {
+    const specFiles = await vscode.workspace.findFiles(".kiro/specs/**/*.md");
+    if (specFiles.length === 0) { return undefined; }
+    const items = specFiles.map(f => ({ label: vscode.workspace.asRelativePath(f), uri: f }));
+    const picked = await vscode.window.showQuickPick(items, { title: "Select Spec" });
+    if (!picked) { return undefined; }
+    const doc = await vscode.workspace.openTextDocument(picked.uri);
+    return { type: "spec", label: path.basename(picked.label), path: picked.uri.fsPath, content: doc.getText().slice(0, 50000) };
+  }
+
+  private pickCurrentFile(): ContextItem | undefined {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) { return undefined; }
+    const relativePath = vscode.workspace.asRelativePath(editor.document.uri);
+    return { type: "currentFile", label: relativePath, path: editor.document.uri.fsPath, content: editor.document.getText().slice(0, 50000) };
+  }
+
+  private async pickSteering(): Promise<ContextItem | undefined> {
+    const files = await vscode.workspace.findFiles(".kiro/steering/**/*.md");
+    if (files.length === 0) { return undefined; }
+    const items = files.map(f => ({ label: path.basename(f.fsPath, ".md"), description: vscode.workspace.asRelativePath(f), uri: f }));
+    const picked = await vscode.window.showQuickPick(items, { title: "Select Steering Rule" });
+    if (!picked) { return undefined; }
+    const doc = await vscode.workspace.openTextDocument(picked.uri);
+    return { type: "steering", label: picked.label, path: picked.uri.fsPath, content: doc.getText().slice(0, 50000) };
+  }
+
+  private async pickMcp(): Promise<ContextItem | undefined> {
+    try {
+      const fs = require("fs");
+      const mcpConfigPath = path.join(this.workspaceRoot, ".kiro", "settings", "mcp.json");
+      if (!fs.existsSync(mcpConfigPath)) { vscode.window.showWarningMessage("No MCP configuration found."); return undefined; }
+      const config = JSON.parse(fs.readFileSync(mcpConfigPath, "utf-8"));
+      const servers = config.mcpServers || {};
+      const serverNames = Object.keys(servers).filter(k => !servers[k].disabled);
+      if (serverNames.length === 0) { vscode.window.showWarningMessage("No active MCP servers."); return undefined; }
+
+      const quickPickItems: any[] = [];
+      for (const serverName of serverNames) {
+        const url = servers[serverName].url;
+        if (!url) { continue; }
+        quickPickItems.push({ label: serverName, kind: vscode.QuickPickItemKind.Separator });
+        const tools = await this.fetchMcpTools(url);
+        for (const tool of tools) {
+          quickPickItems.push({ label: `  $(symbol-method) ${tool.name}`, description: tool.description?.slice(0, 80) || "", toolName: tool.name, serverName });
+        }
+      }
+      const picked = await vscode.window.showQuickPick(quickPickItems, { title: "Select MCP Tool", placeHolder: "Choose a tool...", matchOnDescription: true });
+      if (picked?.toolName) {
+        return { type: "mcp", label: `${picked.serverName}/${picked.toolName}`, content: `MCP Tool: ${picked.toolName} (server: ${picked.serverName})` };
+      }
+    } catch (e) { vscode.window.showErrorMessage(`MCP error: ${(e as Error).message}`); }
+    return undefined;
+  }
+
+  private fetchMcpTools(url: string): Promise<Array<{ name: string; description?: string }>> {
+    const http = require("http");
+    return new Promise((resolve) => {
+      const body = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list", params: {} });
+      const parsedUrl = new URL(url);
+      const req = http.request({
+        hostname: parsedUrl.hostname, port: parsedUrl.port, path: parsedUrl.pathname,
+        method: "POST", headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) }, timeout: 5000,
+      }, (res: any) => {
+        let data = "";
+        res.on("data", (chunk: string) => data += chunk);
+        res.on("end", () => { try { resolve(JSON.parse(data).result?.tools || []); } catch { resolve([]); } });
+      });
+      req.on("error", () => resolve([]));
+      req.on("timeout", () => { req.destroy(); resolve([]); });
+      req.write(body);
+      req.end();
+    });
+  }
+}

package/extension/src/chat-panel/ChatHtmlBuilder.ts

@@ -0,0 +1,67 @@
+/**
+ * ChatHtmlBuilder — generates the HTML for the chat panel webview.
+ * Extracted from ChatPanelProvider to keep the provider under 200 lines.
+ */
+
+import * as vscode from "vscode";
+import { getNonce } from "../mcp-server-manager";
+
+export class ChatHtmlBuilder {
+  static build(webview: vscode.Webview, extensionUri: vscode.Uri): string {
+    const nonce = getNonce();
+    const cspSource = webview.cspSource;
+    const cssUri = webview.asWebviewUri(vscode.Uri.joinPath(extensionUri, "webview-assets", "chat", "chat.css"));
+    const chatJsUri = webview.asWebviewUri(vscode.Uri.joinPath(extensionUri, "webview-assets", "chat", "chat.js"));
+    const mdRendererUri = webview.asWebviewUri(vscode.Uri.joinPath(extensionUri, "webview-assets", "chat", "markdown-renderer.js"));
+    const graphVizUri = webview.asWebviewUri(vscode.Uri.joinPath(extensionUri, "webview-assets", "chat", "graph-viz.js"));
+
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'nonce-${nonce}'; style-src ${cspSource} 'unsafe-inline'; img-src ${cspSource} data:; font-src ${cspSource}; connect-src 'none';">
+    <link rel="stylesheet" href="${cssUri}">
+    <title>Chat Panel</title>
+</head>
+<body>
+    <div id="chat-root">
+        ${ChatHtmlBuilder.headerHtml()}
+        ${ChatHtmlBuilder.tabBarHtml()}
+        ${ChatHtmlBuilder.steeringHtml()}
+        ${ChatHtmlBuilder.warningsHtml()}
+        ${ChatHtmlBuilder.welcomeHtml()}
+        <div id="chat-messages" class="hidden"></div>
+        ${ChatHtmlBuilder.inputAreaHtml()}
+    </div>
+    <script nonce="${nonce}" src="${mdRendererUri}"></script>
+    <script nonce="${nonce}" src="${graphVizUri}"></script>
+    <script nonce="${nonce}" src="${chatJsUri}"></script>
+</body>
+</html>`;
+  }
+
+  private static headerHtml(): string {
+    return `<div id="chat-header"><div class="header-left"><div class="context-usage-icon" id="context-usage-icon" aria-label="Context window usage"><svg viewBox="0 0 20 20"><circle class="arc-bg" cx="10" cy="10" r="8" /><circle class="arc-progress safe" cx="10" cy="10" r="8" stroke-dasharray="50.27" stroke-dashoffset="50.27" transform="rotate(-90 10 10)" /></svg><span class="context-usage-tooltip" id="context-tooltip">0 / 128,000 tokens (0%)</span></div><span class="header-title">SDLC Pipeline</span></div><span id="status-indicator" class="status disconnected">disconnected</span></div>`;
+  }
+
+  private static tabBarHtml(): string {
+    return `<div id="tab-bar" role="tablist" aria-label="Conversation tabs"><button class="tab-add-btn" id="tab-add-btn" title="New conversation (Ctrl+Shift+T)" aria-label="New tab">+</button></div>`;
+  }
+
+  private static steeringHtml(): string {
+    return `<div class="steering-section" id="steering-section"><div class="steering-header" id="steering-header"><span class="steering-chevron">&#x25B6;</span><span>Included Rules</span><span id="steering-count">(0)</span></div><div class="steering-list" id="steering-list"></div></div>`;
+  }
+
+  private static warningsHtml(): string {
+    return `<div class="context-full-warning" id="context-full-warning"><span>Context window is full.</span><span class="new-tab-link" id="full-new-tab">Start new tab</span></div><div class="context-toast" id="context-toast"><span id="toast-text">Context usage at 95%</span><button class="toast-dismiss" id="toast-dismiss">&times;</button></div><div id="working-bar"><span class="working-label"><span id="working-text">Working...</span></span><div class="working-actions"><button id="cancel-btn" title="Cancel">Cancel</button><button id="follow-btn" title="Follow output">Follow &#x1F441;</button></div></div>`;
+  }
+
+  private static welcomeHtml(): string {
+    return `<div id="welcome-state"><h3>SDLC Pipeline Agent</h3><p>Ask a question or describe a task. Use ticket keys to trigger the full pipeline.</p><div class="welcome-suggestions"><button data-cmd="KSA-XXX tao BRD">&#x1F4CB; Create BRD from ticket</button><button data-cmd="KSA-XXX tao FSD">&#x1F4D0; Create FSD from ticket</button><button data-cmd="KSA-XXX tao tai lieu day du">&#x1F4DA; Full pipeline</button><button data-cmd="status">&#x1F4CA; Show pipeline status</button><button data-cmd="resume">&#x25B6; Resume paused pipeline</button><button data-action="openWorkflowGraph">&#x1F5FA; Open Workflow Graph</button></div></div>`;
+  }
+
+  private static inputAreaHtml(): string {
+    return `<div id="chat-input-area"><div id="input-context-chips"></div><div class="input-wrapper"><div id="chat-input" contenteditable="true" role="textbox" aria-multiline="true" aria-placeholder="Ask a question or describe a task..."></div><div id="input-attachments"></div><div class="input-toolbar"><div class="input-toolbar-left"><button class="toolbar-btn" id="ctx-btn" title="Add context (#)">#</button><button class="toolbar-btn" id="attach-btn" title="Attach file">&#x1F4CE;</button><button class="toolbar-btn" id="stop-btn" title="Stop" style="display:none;">&#x23F9;</button></div><div class="input-toolbar-right"><button class="model-selector" id="model-btn"><span id="model-label">Auto</span><span class="model-chevron">&#x25BC;</span></button><div class="autopilot-toggle on" id="autopilot-toggle"><span class="toggle-label">Autopilot</span><div class="toggle-track"><div class="toggle-thumb"></div></div></div><button id="send-btn" title="Send">&#x2191;</button></div><div class="model-dropdown hidden" id="model-dropdown"><button data-model="auto" class="active">Auto</button></div><div class="context-menu hidden" id="context-menu"><button data-ctx="file"><span class="ctx-icon">&#x1F4C4;</span> Files</button><button data-ctx="spec"><span class="ctx-icon">&#x1F4CB;</span> Spec</button><button data-ctx="gitDiff"><span class="ctx-icon">&#x1F500;</span> Git Diff</button><button data-ctx="terminal"><span class="ctx-icon">&#x1F4BB;</span> Terminal</button><button data-ctx="problems"><span class="ctx-icon">&#x26A0;</span> Problems</button><button data-ctx="folder"><span class="ctx-icon">&#x1F4C1;</span> Folder</button><button data-ctx="currentFile"><span class="ctx-icon">&#x1F4DD;</span> Current File</button><button data-ctx="steering"><span class="ctx-icon">&#x1F9ED;</span> Steering</button><button data-ctx="mcp"><span class="ctx-icon">&#x1F50C;</span> MCP</button></div><div class="slash-popup hidden" id="slash-popup" role="listbox" aria-label="Slash commands"><div class="slash-section"><div class="slash-section-title">Agents</div><button type="button" class="slash-item" data-slash="/qa-agent" role="option"><span class="slash-icon">&#x1F9EA;</span><span class="slash-label">qa-agent</span><span class="slash-desc">QA Engineer</span></button><button type="button" class="slash-item" data-slash="/sa-agent" role="option"><span class="slash-icon">&#x1F3D7;</span><span class="slash-label">sa-agent</span><span class="slash-desc">Solution Architect</span></button><button type="button" class="slash-item" data-slash="/sm-agent" role="option"><span class="slash-icon">&#x1F4CB;</span><span class="slash-label">sm-agent</span><span class="slash-desc">Scrum Master</span></button><button type="button" class="slash-item" data-slash="/ta-agent" role="option"><span class="slash-icon">&#x1F527;</span><span class="slash-label">ta-agent</span><span class="slash-desc">Technical Architect</span></button><button type="button" class="slash-item" data-slash="/ui-agent" role="option"><span class="slash-icon">&#x1F3A8;</span><span class="slash-label">ui-agent</span><span class="slash-desc">UI/UX Designer</span></button><button type="button" class="slash-item" data-slash="/security-agent" role="option"><span class="slash-icon">&#x1F6E1;</span><span class="slash-label">security-agent</span><span class="slash-desc">Security Expert</span></button></div><div class="slash-section"><div class="slash-section-title">Steering Rules</div><div id="slash-steering-list"></div></div></div></div></div></div>`;
+  }
+}

package/extension/src/chat-panel/ChatModelManager.ts

@@ -0,0 +1,49 @@
+/**
+ * ChatModelManager — handles model list fetching and sending to webview.
+ */
+
+import * as vscode from "vscode";
+import { getStaticModels, getDefaultModel, fetchGatewayModels } from "./chat-models";
+import { ChatExtToWebviewMessage } from "./message-protocol";
+
+export class ChatModelManager {
+  constructor(
+    private readonly sendToWebview: (msg: ChatExtToWebviewMessage) => void
+  ) {}
+
+  /**
+   * Build and send the provider-aware model list to the webview.
+   * For gateway providers, attempts /v1/models first, falling back to static catalog.
+   */
+  async sendModels(): Promise<void> {
+    const config = vscode.workspace.getConfiguration("kiroSdlc");
+    const provider = config.get<string>("llmProvider", "anthropic");
+    const anthropicBaseUrl = config.get<string>("anthropicBaseUrl", "");
+
+    let models = getStaticModels(provider);
+
+    const isGatewayBaseUrl =
+      (provider === "anthropic" && anthropicBaseUrl.includes("127.0.0.1"));
+
+    if (isGatewayBaseUrl) {
+      const gatewayModels = await fetchGatewayModels(anthropicBaseUrl);
+      if (gatewayModels && gatewayModels.length > 0) {
+        models = gatewayModels;
+      }
+    }
+
+    const llmModel = config.get<string>("llmModel", "");
+    let selected = llmModel;
+    if (!selected || !models.some((m) => m.id === selected)) {
+      selected = models.length > 0 ? models[0].id : getDefaultModel(provider);
+    }
+
+    this.sendToWebview({
+      type: "chat:models",
+      provider,
+      models,
+      selected,
+      supportsAuto: true,
+    });
+  }
+}

package/extension/src/chat-panel/ChatStateManager.ts

@@ -0,0 +1,129 @@
+/**
+ * ChatStateManager — handles chat state persistence, restoration,
+ * and steering info loading.
+ */
+
+import * as vscode from "vscode";
+import { debugLog, debugError } from "../debug-logger";
+import { LangGraphEngine } from "../langgraph/langgraph-engine";
+import { ChatExtToWebviewMessage } from "./message-protocol";
+
+const STATE_KEY = "chatPanel.state";
+
+export class ChatStateManager {
+  constructor(
+    private readonly workspaceRoot: string,
+    private readonly workspaceState: vscode.Memento | undefined,
+    private readonly sendToWebview: (msg: ChatExtToWebviewMessage) => void,
+    private readonly getEngine: () => LangGraphEngine
+  ) {}
+
+  /** Save current chat state (called from webview via message) */
+  saveChatState(state: { tabs: unknown[]; activeTabId: string; messageHistory?: string[] }): void {
+    if (!this.workspaceState) { return; }
+    debugLog(` saveChatState: ${(state.tabs as any[])?.length || 0} tabs, activeTab=${state.activeTabId}`);
+    void this.workspaceState.update(STATE_KEY, state);
+  }
+
+  /** Restore chat state on webview ready */
+  restoreChatState(): void {
+    if (!this.workspaceState) { return; }
+    const state = this.workspaceState.get<{
+      tabs: unknown[]; activeTabId: string; messageHistory?: string[];
+    }>(STATE_KEY);
+    debugLog(` restoreChatState: state=${state ? "found" : "null"}`);
+
+    if (!state || !state.tabs || state.tabs.length === 0) { return; }
+
+    this.sendToWebview({
+      type: "tab:updated",
+      payload: {
+        tabs: state.tabs as any,
+        activeTabId: state.activeTabId,
+        messageHistory: state.messageHistory,
+      } as any,
+    });
+
+    this.restoreEngineHistory(state);
+  }
+
+  /** Send steering files and hooks info to webview. */
+  sendSteeringInfo(): void {
+    try {
+      const fs = require("fs");
+      const path = require("path");
+      const steeringDir = path.join(this.workspaceRoot, ".kiro", "steering");
+      const rules: Array<{ name: string; file: string }> = [];
+      const autoInjectInclusions = new Set(["always", "auto"]);
+
+      if (!fs.existsSync(steeringDir)) { return; }
+
+      const files = this.getSteeringFilesRecursive(steeringDir, steeringDir);
+      for (const file of files) {
+        if (this.shouldIncludeSteeringFile(path.join(steeringDir, file), autoInjectInclusions)) {
+          const name = path.basename(file, ".md").replace(/-/g, " ");
+          rules.push({ name, file });
+        }
+      }
+
+      if (rules.length > 0) {
+        this.sendToWebview({ type: "chat:steeringLoaded", rules });
+      }
+    } catch (err) {
+      debugError("[ChatPanel] sendSteeringInfo failed", err as Error);
+    }
+  }
+
+  private shouldIncludeSteeringFile(fullPath: string, validInclusions: Set<string>): boolean {
+    try {
+      const fs = require("fs");
+      const content: string = fs.readFileSync(fullPath, "utf-8");
+      const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+      if (!fmMatch) { return false; }
+      const inclusionMatch = fmMatch[1].match(/^inclusion\s*:\s*["']?(\w+)["']?\s*$/m);
+      if (!inclusionMatch) { return false; }
+      return validInclusions.has(inclusionMatch[1].toLowerCase());
+    } catch {
+      return false;
+    }
+  }
+
+  private restoreEngineHistory(state: { tabs: unknown[]; activeTabId: string }): void {
+    const activeTab = (state.tabs as any[]).find((t: any) => t.id === state.activeTabId);
+    if (!activeTab?.messages?.length) { return; }
+    try {
+      const engine = this.getEngine();
+      const chatMsgs = (activeTab.messages as any[])
+        .filter((m: any) => m.role === "user" || m.role === "assistant")
+        .slice(-20)
+        .map((m: any) => ({
+          id: m.id || require("crypto").randomUUID(),
+          role: m.role,
+          content: m.content,
+          timestamp: m.timestamp || new Date().toISOString(),
+        }));
+      debugLog(` restoreChatState: restoring ${chatMsgs.length} messages to engine`);
+      engine.setChatHistory(chatMsgs, state.activeTabId);
+    } catch (e) {
+      debugError(` restoreChatState: engine restore failed:`, (e as Error));
+    }
+  }
+
+  private getSteeringFilesRecursive(dir: string, baseDir: string): string[] {
+    const fs = require("fs");
+    const path = require("path");
+    const results: string[] = [];
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          results.push(...this.getSteeringFilesRecursive(fullPath, baseDir));
+        } else if (entry.name.endsWith(".md")) {
+          results.push(path.relative(baseDir, fullPath).replace(/\\/g, "/"));
+        }
+      }
+    } catch { /* ignore */ }
+    return results;
+  }
+}

package/extension/src/chat-panel/ChatStatusManager.ts

@@ -0,0 +1,49 @@
+/**
+ * ChatStatusManager — handles combined MCP + LLM status checking
+ * and notifies the webview of connection state changes.
+ */
+
+import * as vscode from "vscode";
+import { createLlmProvider } from "../langgraph/providers";
+import { McpServerManager } from "../mcp-server-manager";
+import { mapServerStatusToWebview } from "../types";
+import { ChatExtToWebviewMessage } from "./message-protocol";
+
+export class ChatStatusManager {
+  constructor(
+    private readonly mcpManager: McpServerManager,
+    private readonly secrets?: vscode.SecretStorage,
+    private readonly sendToWebview?: (msg: ChatExtToWebviewMessage) => void
+  ) {}
+
+  /**
+   * Called by Settings panel when LLM test succeeds/fails.
+   */
+  notifyLlmStatusChanged(status: "connected" | "disconnected"): void {
+    this.sendToWebview?.({ type: "serverStatus", status });
+  }
+
+  /**
+   * Check both MCP server AND LLM provider availability.
+   * Status = "connected" only when BOTH are working.
+   */
+  async sendCombinedStatus(): Promise<void> {
+    const mcpStatus = this.mcpManager.status;
+    const webviewStatus = mapServerStatusToWebview(mcpStatus);
+
+    if (webviewStatus !== "connected") {
+      this.sendToWebview?.({ type: "serverStatus", status: webviewStatus });
+      return;
+    }
+
+    try {
+      const provider = createLlmProvider(this.secrets);
+      const llmAvailable = await provider.isAvailable();
+      provider.dispose();
+      const status = llmAvailable ? "connected" : "disconnected";
+      this.sendToWebview?.({ type: "serverStatus", status });
+    } catch {
+      this.sendToWebview?.({ type: "serverStatus", status: "disconnected" });
+    }
+  }
+}

package/extension/src/chat-panel/__tests__/chat-models.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Chat Panel model catalog tests — KSA-237 (Chat Panel BUG 2)
+ *
+ * Verifies the provider-aware model catalog and gateway fetch fallback that
+ * back the dynamic Chat Panel model dropdown (replacing the old hardcoded
+ * mixed list of providers + models).
+ */
+import { describe, it, expect, vi, afterEach } from "vitest";
+import {
+  AVAILABLE_MODELS,
+  getStaticModels,
+  getDefaultModel,
+  fetchGatewayModels,
+} from "../chat-models";
+
+describe("chat-models catalog (BUG 2)", () => {
+  it("returns provider-specific models, not a mixed list", () => {
+    const kiro = getStaticModels("kiro").map((m) => m.id);
+    const openai = getStaticModels("openai").map((m) => m.id);
+
+    // Kiro mirrors the real Kiro IDE list: claude families + auto + a few
+    // non-Claude families (deepseek/minimax/glm/qwen). It must NOT contain
+    // OpenAI or Ollama-only ids.
+    expect(kiro).toContain("auto");
+    expect(kiro.some((id) => id.includes("claude"))).toBe(true);
+    expect(kiro.some((id) => id.startsWith("gpt") || id.startsWith("o1") || id.startsWith("o3"))).toBe(false);
+    // OpenAI lists only GPT/o-series models, never Claude or Ollama
+    expect(openai.some((id) => id.startsWith("gpt") || id.startsWith("o"))).toBe(true);
+    expect(openai.some((id) => id.includes("claude"))).toBe(false);
+    expect(openai.some((id) => id.includes("llama"))).toBe(false);
+  });
+
+  it("falls back to anthropic catalog for unknown providers", () => {
+    expect(getStaticModels("does-not-exist")).toEqual(AVAILABLE_MODELS.anthropic);
+  });
+
+  it("exposes a default model per provider", () => {
+    expect(getDefaultModel("kiro")).toBe("auto");
+    expect(getDefaultModel("openai")).toBe("gpt-4o");
+    expect(getDefaultModel("ollama")).toBe("llama3.1");
+  });
+});
+
+describe("fetchGatewayModels (BUG 2)", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+  });
+
+  it("returns null when no base URL is provided", async () => {
+    expect(await fetchGatewayModels("")).toBeNull();
+  });
+
+  it("parses the Anthropic /v1/models envelope from the gateway", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            data: [
+              { type: "model", id: "claude-sonnet-4-5", display_name: "Claude Sonnet 4.5" },
+              { type: "model", id: "claude-opus-4-6", display_name: "Claude Opus 4.6" },
+            ],
+          }),
+      })
+    );
+
+    const models = await fetchGatewayModels("http://127.0.0.1:8990/anthropic");
+    expect(models).toEqual([
+      { id: "claude-sonnet-4-5", name: "Claude Sonnet 4.5" },
+      { id: "claude-opus-4-6", name: "Claude Opus 4.6" },
+    ]);
+  });
+
+  it("parses description and rate_multiplier from the gateway (KSA-237)", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        json: () =>
+          Promise.resolve({
+            data: [
+              {
+                type: "model",
+                id: "claude-opus-4.8",
+                display_name: "Claude Opus 4.8",
+                description: "Experimental preview of Claude Opus 4.8 model",
+                rate_multiplier: 1.9,
+              },
+              {
+                type: "model",
+                id: "claude-sonnet-4.6",
+                display_name: "Claude Sonnet 4.6",
+                description: "General purpose model",
+                rate_multiplier: 1,
+              },
+            ],
+          }),
+      })
+    );
+
+    const models = await fetchGatewayModels("http://127.0.0.1:8990/anthropic");
+    expect(models).toEqual([
+      {
+        id: "claude-opus-4.8",
+        name: "Claude Opus 4.8",
+        description: "Experimental preview of Claude Opus 4.8 model",
+        rateMultiplier: 1.9,
+      },
+      {
+        id: "claude-sonnet-4.6",
+        name: "Claude Sonnet 4.6",
+        description: "General purpose model",
+        rateMultiplier: 1,
+      },
+    ]);
+  });
+
+  it("returns null when the gateway responds non-OK", async () => {
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ ok: false, json: () => Promise.resolve({}) }));
+    expect(await fetchGatewayModels("http://127.0.0.1:8990/anthropic")).toBeNull();
+  });
+
+  it("returns null when fetch throws (gateway unreachable)", async () => {
+    vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("ECONNREFUSED")));
+    expect(await fetchGatewayModels("http://127.0.0.1:8990/anthropic")).toBeNull();
+  });
+
+  it("returns null when the envelope has an empty data array", async () => {
+    vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ ok: true, json: () => Promise.resolve({ data: [] }) }));
+    expect(await fetchGatewayModels("http://127.0.0.1:8990/anthropic")).toBeNull();
+  });
+});