sdlc-agent-4-enterprise-server 1.0.0

package/extension/src/commands/CommandRegistrar.ts

@@ -0,0 +1,177 @@
+/**
+ * CommandRegistrar — registers all non-LLM VS Code commands.
+ * Extracted from extension.ts for SRP.
+ */
+
+import * as vscode from "vscode";
+import * as path from "path";
+import * as fs from "fs";
+import {
+  injectAll, injectSelective, safeUpdate, checkStatus,
+  getVersionReport
+} from "../injector";
+import { promptIndexAfterInject, handleIndexWorkspace } from "../indexer";
+import { McpServerManager } from "../mcp-server-manager";
+import { WebviewPanelManager } from "../webview-panel-manager";
+import { removeBundledMcpConfig } from "../mcp-injector";
+import { registerSymbolSearch } from "../symbol-search";
+import { registerDiagnosticsProvider } from "../diagnostics-provider";
+import { registerAIContextCommands } from "../ai-context-commands";
+import { SecurityPanel } from "../panels/security-panel";
+import { showImpactAnalysis } from "../panels/impact-panel";
+import { SettingsPanel } from "../panels/settings-panel";
+import { LoginPanel } from "../panels/login-panel";
+import { AuthManager } from "../auth/AuthManager";
+import { KiroTreeViewProvider } from "../sidebar/tree-view-provider";
+
+interface CommandDeps {
+  mcpManager?: McpServerManager;
+  panelManager?: WebviewPanelManager;
+  authManager?: AuthManager;
+  treeProvider?: KiroTreeViewProvider;
+  workspaceRoot?: string;
+}
+
+export function registerCommands(context: vscode.ExtensionContext, deps: CommandDeps): void {
+  const { mcpManager, panelManager, authManager, treeProvider, workspaceRoot } = deps;
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand("kiroSdlc.injectAll", () => handleInjectAll(context)),
+    vscode.commands.registerCommand("kiroSdlc.injectSelective", () => handleInjectSelective(context)),
+    vscode.commands.registerCommand("kiroSdlc.update", () => handleUpdate(context)),
+    vscode.commands.registerCommand("kiroSdlc.status", () => handleStatus(context)),
+    vscode.commands.registerCommand("kiroSdlc.indexWorkspace", () => handleIndexWorkspace(authManager?.getTokenSync())),
+    vscode.commands.registerCommand("kiroSdlc.login", () => handleLogin(context, authManager, treeProvider)),
+    vscode.commands.registerCommand("kiroSdlc.logout", () => handleLogout(authManager, panelManager)),
+    vscode.commands.registerCommand("kiroSdlc.openKbGraph", () => panelManager?.openPanel("graph")),
+    vscode.commands.registerCommand("kiroSdlc.openKbDashboard", () => panelManager?.openPanel("dashboard")),
+    vscode.commands.registerCommand("kiroSdlc.openKbTags", () => panelManager?.openPanel("tags")),
+    vscode.commands.registerCommand("kiroSdlc.openKbQuality", () => panelManager?.openPanel("quality")),
+    vscode.commands.registerCommand("kiroSdlc.openKbAnalytics", () => panelManager?.openPanel("analytics")),
+    vscode.commands.registerCommand("kiroSdlc.openWorkflowGraph", () => panelManager?.openPanel("workflow")),
+    vscode.commands.registerCommand("kiroSdlc.restartMcpServer", () => handleRestartServer(mcpManager)),
+    vscode.commands.registerCommand("kiroSdlc.stopMcpServer", () => handleStopServer(mcpManager, workspaceRoot)),
+    vscode.commands.registerCommand("kiroSdlc.openKbBrowser", () => handleOpenKbBrowser(mcpManager)),
+    vscode.commands.registerCommand("kiroSdlc.editConfig", () => handleEditConfig()),
+    vscode.commands.registerCommand("kiroSdlc.changeConfig", () => handleChangeConfig(mcpManager)),
+    vscode.commands.registerCommand("kiroSdlc.openSettings", () => SettingsPanel.open(context.extensionUri, context.secrets)),
+  );
+
+  if (mcpManager) {
+    registerSymbolSearch(context, mcpManager);
+    registerDiagnosticsProvider(context, mcpManager);
+    registerAIContextCommands(context, mcpManager);
+    context.subscriptions.push(
+      vscode.commands.registerCommand("kiroSdlc.openSecurityPanel", () => { new SecurityPanel(mcpManager, context.extensionUri).loadData(); }),
+      vscode.commands.registerCommand("kiroSdlc.impactAnalysis", () => showImpactAnalysis(mcpManager, context.extensionUri)),
+    );
+  }
+}
+
+// === Handlers ===
+
+function getWorkspaceRoot(): string | undefined {
+  const folders = vscode.workspace.workspaceFolders;
+  return folders && folders.length > 0 ? folders[0].uri.fsPath : undefined;
+}
+
+async function handleLogin(context: vscode.ExtensionContext, authManager?: AuthManager, treeProvider?: KiroTreeViewProvider): Promise<void> {
+  if (!authManager) { vscode.window.showErrorMessage("Auth manager not initialized."); return; }
+  new LoginPanel(authManager, context.extensionUri).show();
+  authManager.onStateChange((state) => {
+    if (state === "AUTHENTICATED") { treeProvider?.setAuthenticated(true, "admin"); }
+    else if (state === "UNAUTHENTICATED") { treeProvider?.setAuthenticated(false); }
+  });
+}
+
+async function handleLogout(authManager?: AuthManager, panelManager?: WebviewPanelManager): Promise<void> {
+  if (!authManager) { return; }
+  await authManager.logout();
+  panelManager?.disposeAll();
+  vscode.window.showInformationMessage("Logged out successfully.");
+}
+
+async function handleInjectAll(context: vscode.ExtensionContext): Promise<void> {
+  const root = getWorkspaceRoot();
+  if (!root) { return; }
+  const confirm = await vscode.window.showInformationMessage("Inject all SDLC agents?", "Yes", "Cancel");
+  if (confirm !== "Yes") { return; }
+  try {
+    const injected = await injectAll(root, context.extensionPath);
+    vscode.window.showInformationMessage(`✅ Injected ${injected.length} components`);
+    await promptIndexAfterInject(root);
+  } catch (err) { vscode.window.showErrorMessage(`Inject failed: ${(err as Error).message}`); }
+}
+
+async function handleInjectSelective(context: vscode.ExtensionContext): Promise<void> {
+  const root = getWorkspaceRoot();
+  if (!root) { return; }
+  const injected = await injectSelective(root, context.extensionPath);
+  if (injected.length > 0) { vscode.window.showInformationMessage(`✅ Injected: ${injected.join(", ")}`); await promptIndexAfterInject(root); }
+}
+
+async function handleUpdate(context: vscode.ExtensionContext): Promise<void> {
+  const root = getWorkspaceRoot();
+  if (!root) { return; }
+  const injected = await safeUpdate(root, context.extensionPath);
+  if (injected.length > 0) { vscode.window.showInformationMessage(`✅ Updated ${injected.length} components`); }
+}
+
+async function handleStatus(context: vscode.ExtensionContext): Promise<void> {
+  const root = getWorkspaceRoot();
+  if (!root) { return; }
+  const status = checkStatus(root);
+  const lines = Object.entries(status).map(([id, exists]) => `${exists ? "✅" : "❌"} ${id}`);
+  const action = await vscode.window.showInformationMessage(`SDLC Status:\n${lines.join("\n")}`, "Show File Versions", "Inject Missing", "Close");
+  if (action === "Show File Versions") {
+    const ch = vscode.window.createOutputChannel("SDLC File Versions"); ch.show();
+    ch.appendLine(getVersionReport(root, context.extensionPath));
+  } else if (action === "Inject Missing") { vscode.commands.executeCommand("kiroSdlc.injectSelective"); }
+}
+
+async function handleOpenKbBrowser(mcpManager?: McpServerManager): Promise<void> {
+  if (!mcpManager || mcpManager.status !== "running") { vscode.window.showErrorMessage("MCP server not running."); return; }
+  await vscode.env.openExternal(vscode.Uri.parse(`http://localhost:${mcpManager.port}/`));
+}
+
+async function handleRestartServer(mcpManager?: McpServerManager): Promise<void> {
+  if (!mcpManager) { vscode.window.showErrorMessage("No workspace open."); return; }
+  try { await mcpManager.reconnect(); vscode.window.showInformationMessage("MCP server reconnected."); }
+  catch (err) { vscode.window.showErrorMessage(`Reconnect failed: ${(err as Error).message}`); }
+}
+
+async function handleStopServer(mcpManager?: McpServerManager, workspaceRoot?: string): Promise<void> {
+  if (!mcpManager) { vscode.window.showErrorMessage("No workspace open."); return; }
+  try { await mcpManager.disconnect(); if (workspaceRoot) { removeBundledMcpConfig(workspaceRoot); } vscode.window.showInformationMessage("MCP server disconnected."); }
+  catch (err) { vscode.window.showErrorMessage(`Disconnect failed: ${(err as Error).message}`); }
+}
+
+async function handleEditConfig(): Promise<void> {
+  const root = getWorkspaceRoot();
+  if (!root) { return; }
+  const config = vscode.workspace.getConfiguration("kiroSdlc");
+  const relPath = config.get<string>("configPath", ".code-intel/orchestration.json");
+  const fullPath = path.join(root, relPath);
+  if (!fs.existsSync(fullPath)) {
+    const create = await vscode.window.showWarningMessage(`Config not found: ${relPath}. Create?`, "Create", "Cancel");
+    if (create !== "Create") { return; }
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) { fs.mkdirSync(dir, { recursive: true }); }
+    fs.writeFileSync(fullPath, JSON.stringify({ servers: [], routing: {} }, null, 2));
+  }
+  await vscode.window.showTextDocument(await vscode.workspace.openTextDocument(fullPath));
+}
+
+async function handleChangeConfig(mcpManager?: McpServerManager): Promise<void> {
+  const root = getWorkspaceRoot();
+  if (!root) { return; }
+  const config = vscode.workspace.getConfiguration("kiroSdlc");
+  const currentRelPath = config.get<string>("configPath", ".code-intel/orchestration.json");
+  const defaultUri = vscode.Uri.file(root);
+  const result = await vscode.window.showOpenDialog({ canSelectFiles: true, canSelectFolders: false, canSelectMany: false, defaultUri, filters: { "JSON": ["json"] } });
+  if (!result || result.length === 0) { return; }
+  const relPath = path.relative(root, result[0].fsPath).replace(/\\/g, "/");
+  await config.update("configPath", relPath, vscode.ConfigurationTarget.Workspace);
+  vscode.window.showInformationMessage(`Config changed to: ${relPath}. Restarting...`);
+  await handleRestartServer(mcpManager);
+}

package/extension/src/commands/LlmCommands.ts

@@ -0,0 +1,111 @@
+/**
+ * LlmCommands — LLM-related command handlers.
+ * Extracted from extension.ts for SRP.
+ */
+
+import * as vscode from "vscode";
+import { ChatPanelProvider } from "../chat-panel/chat-panel-provider";
+
+const LLM_SECRET_KEYS: Record<string, string> = {
+  anthropic: "kiroSdlc.anthropicApiKey",
+  openai: "kiroSdlc.openaiApiKey",
+};
+
+export function registerLlmCommands(
+  context: vscode.ExtensionContext,
+  chatPanelProvider: ChatPanelProvider
+): void {
+  context.subscriptions.push(
+    vscode.commands.registerCommand("kiroSdlc.notifyLlmConnected", () => {
+      console.log("[LlmCommands] notifyLlmConnected fired");
+      chatPanelProvider.notifyLlmStatusChanged("connected");
+    }),
+    vscode.commands.registerCommand("kiroSdlc.notifyLlmDisconnected", () => {
+      console.log("[LlmCommands] notifyLlmDisconnected fired");
+      chatPanelProvider.notifyLlmStatusChanged("disconnected");
+    }),
+    vscode.commands.registerCommand("kiroSdlc.testLanguageModels", () => testLanguageModels()),
+    vscode.commands.registerCommand("kiroSdlc.setLlmApiKey", () => handleSetLlmApiKey(context)),
+    vscode.commands.registerCommand("kiroSdlc.clearLlmApiKey", () => handleClearLlmApiKey(context)),
+  );
+}
+
+async function testLanguageModels(): Promise<void> {
+  const outputCh = vscode.window.createOutputChannel("LM Test");
+  outputCh.show();
+  outputCh.appendLine("[LM Test] Starting vscode.lm API test...");
+
+  try {
+    if (!vscode.lm || !vscode.lm.selectChatModels) {
+      outputCh.appendLine("[LM Test] ERROR: vscode.lm API not available.");
+      vscode.window.showErrorMessage("vscode.lm API not available in Kiro IDE.");
+      return;
+    }
+    outputCh.appendLine("[LM Test] vscode.lm namespace exists. Calling selectChatModels({})...");
+    const allModels = await vscode.lm.selectChatModels({});
+    outputCh.appendLine(`[LM Test] selectChatModels returned ${allModels.length} model(s)`);
+
+    if (allModels.length === 0) {
+      outputCh.appendLine("[LM Test] No models found.");
+      vscode.window.showWarningMessage("vscode.lm API exists but returned 0 models.");
+      return;
+    }
+
+    for (const m of allModels) {
+      outputCh.appendLine(`  - ${m.vendor}/${m.family} id=${m.id} maxTokens=${m.maxInputTokens}`);
+    }
+
+    const pick = await vscode.window.showInformationMessage(
+      `Found ${allModels.length} model(s). First: ${allModels[0].vendor}/${allModels[0].family}`,
+      "Test Chat", "Cancel"
+    );
+    if (pick === "Test Chat") {
+      await sendTestChat(allModels[0], outputCh);
+    }
+  } catch (err: any) {
+    outputCh.appendLine(`[LM Test] EXCEPTION: ${err?.message || err}`);
+    vscode.window.showErrorMessage(`LM API Error: ${err?.message || String(err)}`);
+  }
+}
+
+async function sendTestChat(model: vscode.LanguageModelChat, outputCh: vscode.OutputChannel): Promise<void> {
+  outputCh.appendLine(`[LM Test] Sending test request to ${model.id}...`);
+  const messages = [vscode.LanguageModelChatMessage.User("Say hello in 10 words or less.")];
+  const response = await model.sendRequest(messages, {}, new vscode.CancellationTokenSource().token);
+  let result = "";
+  for await (const chunk of response.text) { result += chunk; }
+  outputCh.appendLine(`[LM Test] Response: ${result}`);
+  vscode.window.showInformationMessage(`LLM Response: ${result}`);
+}
+
+async function handleSetLlmApiKey(context: vscode.ExtensionContext): Promise<void> {
+  const config = vscode.workspace.getConfiguration("kiroSdlc");
+  const provider = config.get<string>("llmProvider", "anthropic");
+  if (provider === "ollama") {
+    vscode.window.showInformationMessage("Ollama does not require an API key.");
+    return;
+  }
+  const secretKey = LLM_SECRET_KEYS[provider];
+  if (!secretKey) { vscode.window.showErrorMessage(`Unknown provider: ${provider}`); return; }
+  const apiKey = await vscode.window.showInputBox({
+    prompt: `Enter API key for ${provider}`, password: true,
+    placeHolder: provider === "anthropic" ? "sk-ant-..." : "sk-...",
+    ignoreFocusOut: true,
+  });
+  if (!apiKey) { return; }
+  await context.secrets.store(secretKey, apiKey);
+  vscode.window.showInformationMessage(`${provider} API key stored securely.`);
+}
+
+async function handleClearLlmApiKey(context: vscode.ExtensionContext): Promise<void> {
+  const config = vscode.workspace.getConfiguration("kiroSdlc");
+  const provider = config.get<string>("llmProvider", "anthropic");
+  if (provider === "ollama") {
+    vscode.window.showInformationMessage("Ollama does not use stored API keys.");
+    return;
+  }
+  const secretKey = LLM_SECRET_KEYS[provider];
+  if (!secretKey) { return; }
+  await context.secrets.delete(secretKey);
+  vscode.window.showInformationMessage(`${provider} API key removed.`);
+}

package/extension/src/config-watcher.ts

@@ -0,0 +1,171 @@
+/**
+ * ConfigWatcher — Monitors .kiro/settings/mcp.json for changes to code-intelligence server config.
+ * Debounces rapid edits (500ms) and only triggers restart when config actually changes.
+ */
+
+import * as vscode from "vscode";
+import * as fs from "fs";
+import * as path from "path";
+import { McpServerManager } from "./mcp-server-manager";
+
+export interface CodeIntelConfig {
+  url?: string;
+  port?: number;
+  transportType?: string;
+  command?: string;
+  args?: string[];
+  disabled?: boolean;
+  [key: string]: unknown;
+}
+
+export class ConfigWatcher implements vscode.Disposable {
+  private watcher: vscode.FileSystemWatcher | undefined;
+  private debounceTimer: NodeJS.Timeout | undefined;
+  private lastConfigHash: string = "";
+  private suppressUntil: number = 0;
+  private readonly outputChannel: vscode.OutputChannel;
+
+  private static readonly DEBOUNCE_MS = 500;
+  private static readonly SUPPRESS_MS = 2000;
+
+  constructor(
+    private readonly workspaceFolder: string,
+    private readonly mcpManager: McpServerManager,
+    outputChannel: vscode.OutputChannel
+  ) {
+    this.outputChannel = outputChannel;
+    this.lastConfigHash = this.computeConfigHash();
+    this.startWatching();
+  }
+
+  /**
+   * Call this BEFORE writing to mcp.json to suppress self-triggered events.
+   */
+  suppressNextChange(): void {
+    this.suppressUntil = Date.now() + ConfigWatcher.SUPPRESS_MS;
+  }
+
+  private get mcpConfigPath(): string {
+    return path.join(this.workspaceFolder, ".kiro", "settings", "mcp.json");
+  }
+
+  private startWatching(): void {
+    const pattern = new vscode.RelativePattern(
+      this.workspaceFolder,
+      ".kiro/settings/mcp.json"
+    );
+
+    this.watcher = vscode.workspace.createFileSystemWatcher(pattern);
+
+    this.watcher.onDidChange(() => this.onConfigFileChanged());
+    this.watcher.onDidCreate(() => this.onConfigFileChanged());
+    this.watcher.onDidDelete(() => this.onConfigFileDeleted());
+
+    this.outputChannel.appendLine("[ConfigWatcher] Watching .kiro/settings/mcp.json");
+  }
+
+  private onConfigFileChanged(): void {
+    if (Date.now() < this.suppressUntil) {
+      return; // Ignore self-triggered change
+    }
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.handleConfigChange();
+    }, ConfigWatcher.DEBOUNCE_MS);
+  }
+
+  private onConfigFileDeleted(): void {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.debounceTimer = setTimeout(() => {
+      this.handleConfigDeleted();
+    }, ConfigWatcher.DEBOUNCE_MS);
+  }
+
+  private handleConfigChange(): void {
+    const newHash = this.computeConfigHash();
+
+    if (newHash === this.lastConfigHash) {
+      this.outputChannel.appendLine("[ConfigWatcher] Config unchanged (hash match), skipping.");
+      return;
+    }
+
+    this.lastConfigHash = newHash;
+    const config = this.readCodeIntelConfig();
+
+    if (!config) {
+      // code-intelligence entry removed or invalid
+      this.outputChannel.appendLine("[ConfigWatcher] code-intelligence config removed or invalid. Stopping server.");
+      this.mcpManager.disconnect().catch((err) => {
+        this.outputChannel.appendLine(`[ConfigWatcher] Disconnect failed: ${(err as Error).message}`);
+      });
+      return;
+    }
+
+    // If server is disabled, do NOT restart — just ensure it's stopped
+    if (config.disabled === true) {
+      this.outputChannel.appendLine("[ConfigWatcher] code-intelligence is disabled. Ensuring server is stopped.");
+      this.mcpManager.disconnect().catch((err) => {
+        this.outputChannel.appendLine(`[ConfigWatcher] Disconnect failed: ${(err as Error).message}`);
+      });
+      return;
+    }
+
+    // Config changed — restart server with new config
+    this.outputChannel.appendLine("[ConfigWatcher] code-intelligence config changed. Restarting server...");
+    this.mcpManager.reconnect().catch((err) => {
+      this.outputChannel.appendLine(`[ConfigWatcher] Reconnect failed: ${(err as Error).message}`);
+    });
+  }
+
+  private handleConfigDeleted(): void {
+    this.outputChannel.appendLine("[ConfigWatcher] mcp.json deleted. Stopping server.");
+    this.lastConfigHash = "";
+    this.mcpManager.disconnect().catch((err) => {
+      this.outputChannel.appendLine(`[ConfigWatcher] Disconnect failed: ${(err as Error).message}`);
+    });
+  }
+
+  /**
+   * Read the code-intelligence server config from mcp.json.
+   * Returns null if file missing, invalid JSON, or code-intelligence entry absent.
+   */
+  readCodeIntelConfig(): CodeIntelConfig | null {
+    try {
+      if (!fs.existsSync(this.mcpConfigPath)) {
+        return null;
+      }
+      const raw = fs.readFileSync(this.mcpConfigPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      const serverConfig = parsed?.mcpServers?.["code-intelligence"];
+      if (!serverConfig || typeof serverConfig !== "object") {
+        return null;
+      }
+      return serverConfig as CodeIntelConfig;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Compute a simple hash of the code-intelligence config section only.
+   * Used to detect actual changes vs. unrelated edits to other servers.
+   */
+  private computeConfigHash(): string {
+    const config = this.readCodeIntelConfig();
+    if (!config) {
+      return "";
+    }
+    return JSON.stringify(config);
+  }
+
+  dispose(): void {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+    this.watcher?.dispose();
+  }
+}

package/extension/src/config.ts

@@ -0,0 +1,106 @@
+/**
+ * Extension configuration — component definitions, paths, and MCP variants.
+ */
+
+export interface Component {
+    id: string;
+    label: string;
+    description: string;
+    sourcePath: string;
+    targetPath: string;
+    filter?: string[];
+}
+
+export type McpDelivery = "registry" | "download";
+
+export interface McpVariant {
+    id: string;
+    label: string;
+    description: string;
+    delivery: McpDelivery;
+    config: McpServerConfig;
+    downloadUrl?: string;
+    downloadAsset?: string;
+}
+
+export interface McpServerConfig {
+    command: string;
+    args: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    transportType?: string;
+}
+
+/** Where downloaded MCP servers are stored (per-workspace). */
+export const MCP_SERVERS_DIR = ".code-intel/servers";
+
+/** GitHub repo for release downloads. */
+export const GITHUB_RELEASE_REPO = "dnguyenminh/Kiro-SDLC-Agents";
+
+export const CORE_COMPONENTS: Component[] = [
+    {
+        id: "agents",
+        label: "Agents (BA, SA, QA, DEV, DevOps, UI, Security, SM, TA)",
+        description: "Multi-agent SDLC pipeline with prompts",
+        sourcePath: ".kiro/agents",
+        targetPath: ".kiro/agents"
+    },
+    {
+        id: "steering",
+        label: "Steering Rules",
+        description: "Code standards, self-learning, file-writing, drawio, jira-workflow",
+        sourcePath: ".kiro/steering",
+        targetPath: ".kiro/steering"
+    },
+    {
+        id: "hooks",
+        label: "Hooks (Code Index + Drawio Validation)",
+        description: "Auto-trigger hooks for file events",
+        sourcePath: ".kiro/hooks",
+        targetPath: ".kiro/hooks"
+    },
+    {
+        id: "templates",
+        label: "Document Templates (BRD, FSD, TDD, STP, STC, DPG, RLN, UG)",
+        description: "Templates for all SDLC documents",
+        sourcePath: "documents/templates",
+        targetPath: "documents/templates"
+    }
+];
+
+export const MCP_VARIANTS: McpVariant[] = [
+    {
+        id: "python",
+        label: "Python (recommended — zero install)",
+        description: "uvx auto-downloads from PyPI. Python 3.11+",
+        delivery: "registry",
+        config: {
+            command: "uvx",
+            args: ["mcp-code-intelligence@latest", "--config", "${workspaceFolder}/.code-intel/orchestration.json"],
+            cwd: "${workspaceFolder}"
+        }
+    },
+    {
+        id: "nodejs",
+        label: "Node.js (full-featured — zero install)",
+        description: "npx auto-downloads from npm. Node.js 20+",
+        delivery: "registry",
+        config: {
+            command: "npx",
+            args: ["mcp-code-intelligence@latest", "--config", "${workspaceFolder}/.code-intel/orchestration.json"],
+            cwd: "${workspaceFolder}"
+        }
+    },
+    {
+        id: "kotlin",
+        label: "Kotlin/JVM (enterprise)",
+        description: "Downloads JAR from GitHub Release. JDK 21+",
+        delivery: "download",
+        downloadAsset: "mcp-code-intelligence-latest.jar",
+        config: {
+            command: "java",
+            args: ["-jar", "${mcpServersDir}/mcp-code-intelligence-latest.jar", "--config", "${workspaceFolder}/.code-intel/orchestration.json"],
+            cwd: "${workspaceFolder}"
+        }
+    }
+];

package/extension/src/connection/ConnectionManager.ts

@@ -0,0 +1,128 @@
+/**
+ * ConnectionManager — Backend connectivity state machine.
+ * States: DISCONNECTED → CONNECTING → CONNECTED
+ * Auto-reconnects with exponential backoff.
+ */
+
+import * as vscode from "vscode";
+import { AuthManager } from "../auth/AuthManager";
+import { HttpClient } from "../proxy/HttpClient";
+import { HealthChecker } from "./HealthChecker";
+
+export type ConnectionState = "DISCONNECTED" | "CONNECTING" | "CONNECTED";
+
+export interface RemoteBackendConfig {
+  url: string;
+  healthCheckInterval: number;
+  toolCallTimeout: number;
+  chatTimeout: number;
+}
+
+export class ConnectionManager implements vscode.Disposable {
+  private state: ConnectionState = "DISCONNECTED";
+  private reconnectAttempts = 0;
+  private readonly maxReconnectAttempts = 5;
+  private readonly reconnectDelays = [1000, 2000, 4000, 8000, 16000];
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private healthChecker: HealthChecker;
+
+  private _onStateChange = new vscode.EventEmitter<ConnectionState>();
+  readonly onStateChange: vscode.Event<ConnectionState> = this._onStateChange.event;
+
+  constructor(
+    private config: RemoteBackendConfig,
+    private readonly authManager: AuthManager,
+    private readonly httpClient: HttpClient
+  ) {
+    this.healthChecker = new HealthChecker(httpClient, config.healthCheckInterval);
+    this.healthChecker.onHealthFail(() => {
+      if (this.state === "CONNECTED") {
+        this.transitionTo("DISCONNECTED");
+        this.scheduleReconnect();
+      }
+    });
+  }
+
+  get currentState(): ConnectionState {
+    return this.state;
+  }
+
+  get isConnected(): boolean {
+    return this.state === "CONNECTED";
+  }
+
+  get backendUrl(): string {
+    return this.config.url;
+  }
+
+  /**
+   * Attempt to connect to backend.
+   */
+  async connect(): Promise<void> {
+    this.transitionTo("CONNECTING");
+    const healthy = await this.httpClient.healthCheck();
+    if (healthy) {
+      this.transitionTo("CONNECTED");
+      this.reconnectAttempts = 0;
+      this.healthChecker.start();
+    } else {
+      this.transitionTo("DISCONNECTED");
+      this.scheduleReconnect();
+    }
+  }
+
+  /**
+   * Disconnect and stop health checking.
+   */
+  disconnect(): void {
+    this.healthChecker.stop();
+    this.cancelReconnect();
+    this.transitionTo("DISCONNECTED");
+  }
+
+  /**
+   * Update backend URL (e.g., settings changed).
+   */
+  updateConfig(newConfig: Partial<RemoteBackendConfig>): void {
+    if (newConfig.url) {
+      this.config.url = newConfig.url;
+      this.httpClient.baseUrl = newConfig.url;
+    }
+    if (newConfig.healthCheckInterval) {
+      this.config.healthCheckInterval = newConfig.healthCheckInterval;
+      this.healthChecker.interval = newConfig.healthCheckInterval;
+    }
+  }
+
+  private scheduleReconnect(): void {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      vscode.window.showErrorMessage(
+        "Cannot connect to Kiro backend. Check backend URL in settings."
+      );
+      return;
+    }
+    const delay = this.reconnectDelays[this.reconnectAttempts] || 16000;
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(() => this.connect(), delay);
+  }
+
+  private cancelReconnect(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.reconnectAttempts = 0;
+  }
+
+  private transitionTo(newState: ConnectionState): void {
+    if (this.state === newState) { return; }
+    this.state = newState;
+    this._onStateChange.fire(newState);
+  }
+
+  dispose(): void {
+    this.healthChecker.stop();
+    this.cancelReconnect();
+    this._onStateChange.dispose();
+  }
+}