@agenthippo-ai/agenthippo 0.1.0

package/out/extension.js

@@ -0,0 +1,4472 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+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.activate = activate;
+exports.deactivate = deactivate;
+/* eslint-disable local/code-no-unexternalized-strings */
+const vscode = __importStar(require("vscode"));
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const types_1 = require("./engines/types");
+const factory_1 = require("./engines/factory");
+const sync_1 = require("./sync");
+const session_1 = require("./session");
+const utils_1 = require("./utils");
+const agentEnvFile_1 = require("./utils/agentEnvFile");
+const index_1 = require("./utils/index");
+const runtime_1 = require("./cli/runtime");
+const mcp_1 = require("./mcp");
+const terminalLogger_1 = require("./terminalLogger");
+const workspaceFolders_1 = require("./workspaceFolders");
+const branding_1 = require("./branding");
+const binary_1 = require("./utils/binary");
+const paths_1 = require("./agentpack/paths");
+const permissions_1 = require("./permissions");
+const vscode_edit_tracker_1 = require("./runtime/vscode/vscode-edit-tracker");
+const vscode_logger_1 = require("./runtime/vscode/vscode-logger");
+const vscode_config_provider_1 = require("./runtime/vscode/vscode-config-provider");
+const permission_handler_1 = require("./runtime/interfaces/permission-handler");
+const customRegistry_1 = require("./engines/customRegistry");
+const handleRemoteChat_js_1 = require("./remote/handleRemoteChat.js");
+const serveClient_js_1 = require("./remote/serveClient.js");
+const remotePackStatusBar_js_1 = require("./remote/remotePackStatusBar.js");
+const provider_js_1 = require("./auth/provider.js");
+const signInFlow_js_1 = require("./auth/signInFlow.js");
+const githubStoreGate_js_1 = require("./auth/githubStoreGate.js");
+const sessionEvents_1 = require("./analytics/sessionEvents");
+const base_1 = require("./engines/base");
+/** globalState key for user-installed bundled tools dir (from "Install Bundled Tools" command). */
+const BUNDLED_TOOLS_DIR_KEY = 'agentide.bundledToolsDir';
+const AGENTIDE_SESSIONS_DIR_NAME = `${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}/${paths_1.AGENT_CONSTANTS.SESSIONS_DIR}`;
+const TERMINAL_LOG_FILE_NAME = "terminal.md";
+const MAX_TERMINAL_LOG_BYTES = 2 * 1024 * 1024; // 2MB per session, then rotate
+const ATTACHMENTS_DIR_NAME = "attachments";
+let _state;
+let _extensionContext;
+const _activeRunsByStreamId = new Map();
+const _pendingQuestionsById = new Map();
+const STREAM_QUESTION_TIMEOUT_MS = 1000 * 60 * 10;
+function resolvePendingQuestion(questionId, answer) {
+    const pending = _pendingQuestionsById.get(questionId);
+    if (!pending) {
+        return false;
+    }
+    clearTimeout(pending.timeout);
+    _pendingQuestionsById.delete(questionId);
+    pending.resolver(answer);
+    return true;
+}
+function rejectPendingQuestionsForStream(streamId, reason) {
+    for (const [questionId, pending] of _pendingQuestionsById) {
+        if (pending.streamId !== streamId) {
+            continue;
+        }
+        clearTimeout(pending.timeout);
+        _pendingQuestionsById.delete(questionId);
+        pending.rejecter(new Error(reason));
+    }
+}
+async function askQuestionFromChatUI(streamId, question) {
+    return await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            _pendingQuestionsById.delete(question.questionId);
+            reject(new Error('Question timed out waiting for user response'));
+        }, STREAM_QUESTION_TIMEOUT_MS);
+        _pendingQuestionsById.set(question.questionId, {
+            streamId,
+            question,
+            resolver: resolve,
+            rejecter: reject,
+            timeout,
+        });
+        void Promise.resolve(vscode.commands.executeCommand('agentide.streamCallback', {
+            streamId,
+            type: 'question',
+            metadata: question,
+        })).catch((err) => {
+            clearTimeout(timeout);
+            _pendingQuestionsById.delete(question.questionId);
+            reject(err instanceof Error ? err : new Error(String(err)));
+        });
+    });
+}
+function normalizeQuestionAnswer(answer) {
+    const candidate = (answer && typeof answer === 'object') ? answer : {};
+    const selected = Array.isArray(candidate.selected)
+        ? candidate.selected.filter((item) => typeof item === 'string' && item.trim().length > 0)
+        : [];
+    const freeText = typeof candidate.freeText === 'string'
+        ? candidate.freeText
+        : (candidate.freeText === null ? null : null);
+    return {
+        selected,
+        freeText,
+        declined: candidate.declined === true,
+        timedOut: candidate.timedOut === true,
+        cancelled: candidate.cancelled === true,
+    };
+}
+function questionPromptToHeader(prompt) {
+    const firstLine = prompt.split(/\r?\n/, 1)[0]?.trim() || 'Question';
+    if (firstLine.length <= 50) {
+        return firstLine;
+    }
+    return `${firstLine.slice(0, 47)}...`;
+}
+/** Map our stream question payload to the workbench askQuestions tool input. */
+function streamPayloadToAskQuestionsInput(payload) {
+    const header = questionPromptToHeader(payload.prompt);
+    const question = {
+        header,
+        question: payload.prompt,
+        multiSelect: payload.multiSelect,
+        allowFreeformInput: payload.allowFreeText,
+    };
+    if (payload.options?.length) {
+        question.options = payload.options.map(o => ({
+            label: o.label,
+            description: o.description,
+            recommended: o.recommended,
+        }));
+    }
+    return { questions: [question] };
+}
+/**
+ * Ask a question via the workbench's built-in askQuestions tool (same path as Copilot).
+ * Uses vscode.lm.invokeTool so the chat UI shows the question carousel and returns the user's answer.
+ */
+async function askQuestionViaWorkbenchTool(sessionResource, _requestId, payload, abortSignal) {
+    const tokenSource = new vscode.CancellationTokenSource();
+    abortSignal.addEventListener('abort', () => tokenSource.cancel(), { once: true });
+    try {
+        const input = streamPayloadToAskQuestionsInput(payload);
+        // Workbench expects IToolInvocationContext { sessionResource } for chat-attached tool UX
+        const result = await vscode.lm.invokeTool('vscode_askQuestions', {
+            input,
+            toolInvocationToken: { sessionResource: vscode.Uri.parse(sessionResource) },
+        }, tokenSource.token);
+        // Result content: [{ kind: 'text', value: jsonString }]. JSON is IAnswerResult { answers: Record<header, IQuestionAnswer> }.
+        const firstText = result?.content?.find((p) => typeof p.value === 'string');
+        const jsonStr = firstText?.value;
+        if (!jsonStr) {
+            return { selected: [], freeText: null, declined: true };
+        }
+        const parsed = JSON.parse(jsonStr);
+        const answers = parsed?.answers ?? {};
+        const firstKey = Object.keys(answers)[0];
+        const answer = firstKey ? answers[firstKey] : undefined;
+        if (!answer) {
+            return { selected: [], freeText: null, declined: true };
+        }
+        return {
+            selected: answer.selected ?? [],
+            freeText: answer.freeText ?? null,
+            declined: answer.skipped === true,
+        };
+    }
+    catch (err) {
+        // User cancelled or tool failed
+        const cancelled = err instanceof Error && (err.name === 'Canceled' || err.message?.includes('cancel'));
+        return { selected: [], freeText: null, declined: true, cancelled };
+    }
+    finally {
+        tokenSource.dispose();
+    }
+}
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+const SESSION_CLEANUP_INTERVAL_MS = 1000 * 60 * 5; // 5 minutes
+function log(outputChannel, message) {
+    outputChannel.appendLine((0, branding_1.brandify)(message));
+}
+function logConsole(message) {
+    console.log((0, branding_1.brandify)(message));
+}
+function showInfo(message) {
+    return vscode.window.showInformationMessage((0, branding_1.brandify)(message));
+}
+function showWarning(message) {
+    return vscode.window.showWarningMessage((0, branding_1.brandify)(message));
+}
+function showError(message) {
+    return vscode.window.showErrorMessage((0, branding_1.brandify)(message));
+}
+// -----------------------------------------------------------------------------
+// Activation
+// -----------------------------------------------------------------------------
+async function activate(context) {
+    const outputChannel = vscode.window.createOutputChannel(branding_1.AGENTIDE_EXTENSION_NAME);
+    log(outputChannel, `${branding_1.AGENTIDE_BRAND_NAME} extension activating...`);
+    logConsole(`${branding_1.AGENTIDE_BRAND_NAME} extension activating...`);
+    try {
+        const envMerge = await (0, agentEnvFile_1.mergeAgentHomeEnvIntoProcessEnv)();
+        if (envMerge.applied.length > 0) {
+            log(outputChannel, `[AgentIDE] Loaded ${envMerge.applied.length} env var(s) from ${envMerge.envFilePath} (shell env wins on conflict)`);
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log(outputChannel, `[AgentIDE] Warning: failed to load ~/.agent-hippo/.env: ${message}`);
+    }
+    _extensionContext = context;
+    // Expose extension scripts directory to agent shells
+    // This allows skills to reference setup scripts via $AGENTIDE_ANALYTICS_SCRIPTS_DIR
+    const analyticsScriptsDir = (0, utils_1.getAnalyticsScriptsDir)(context.extensionPath);
+    process.env.AGENTIDE_ANALYTICS_SCRIPTS_DIR = analyticsScriptsDir;
+    log(outputChannel, `[AgentIDE] Analytics scripts dir: ${analyticsScriptsDir}`);
+    // Initialize session persistence
+    (0, session_1.initSessionStore)(context);
+    // Setup cleanup interval - runs maintenance on all providers generically
+    const maintenanceLogger = new vscode_logger_1.VSCodeLogger(outputChannel, "[Maintenance]");
+    const cleanupInterval = setInterval(() => {
+        (0, session_1.runSessionMaintenance)();
+        if (_state) {
+            for (const engine of Object.values(_state.engines)) {
+                engine.onMaintenance(maintenanceLogger);
+            }
+        }
+    }, SESSION_CLEANUP_INTERVAL_MS);
+    context.subscriptions.push(new vscode.Disposable(() => clearInterval(cleanupInterval)));
+    // Prepare workspace-scoped engine directories from registry
+    const storageBase = context.storageUri ?? context.globalStorageUri;
+    const storageType = context.storageUri ? "per-workspace" : "global";
+    // Build config from AGENT_ENGINES
+    const config = {
+        storagePath: storageBase.fsPath,
+    };
+    for (const engine of Object.values(types_1.AGENT_ENGINES)) {
+        const dirPath = path.join(storageBase.fsPath, engine.id);
+        try {
+            await fs_1.promises.mkdir(dirPath, { recursive: true });
+            log(outputChannel, `[AgentIDE] ${engine.displayName} dir: ${dirPath} (${storageType})`);
+            // Dynamically set config directory based on engine's configEnvVar
+            if (engine.configEnvVar === "CODEX_HOME") {
+                config.codexHome = dirPath;
+            }
+            else if (engine.configEnvVar === "CLAUDE_CONFIG_DIR") {
+                config.claudeConfigDir = dirPath;
+            }
+        }
+        catch (e) {
+            log(outputChannel, `[AgentIDE] Warning: failed to create ${engine.id} dir: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    // Create sync service
+    const syncService = new sync_1.SyncService(() => getBundledBasePromptsDir());
+    // Create engines from factory
+    const engines = (0, factory_1.createEngines)({
+        config,
+        syncService,
+        getBundledBasePromptsDir: () => getBundledBasePromptsDir(),
+    });
+    // Store state
+    _state = {
+        outputChannel,
+        engines,
+        syncService,
+        config,
+    };
+    // Enable Agent Skills by default (VS Code promptSyntax setting renamed in main7)
+    try {
+        const chatConfig = vscode.workspace.getConfiguration("chat");
+        const inspect = chatConfig.inspect("useAgentSkills");
+        if (inspect &&
+            !inspect.globalValue &&
+            !inspect.workspaceValue &&
+            !inspect.workspaceFolderValue) {
+            await chatConfig.update("useAgentSkills", true, vscode.ConfigurationTarget.Global);
+            log(outputChannel, "[AgentIDE] Enabled Agent Skills by default");
+        }
+    }
+    catch (e) {
+        log(outputChannel, `[AgentIDE] Warning: failed to enable Agent Skills setting: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    // Register bundled MCP servers with VS Code
+    await registerBundledMcpServers(context, outputChannel);
+    (0, provider_js_1.registerAgentHippoAuth)(context);
+    void (0, provider_js_1.refreshBootstrapIfSignedIn)(context);
+    context.subscriptions.push((0, provider_js_1.startAgentHippoTokenRefreshTimer)(context));
+    // Register commands
+    registerCommands(context, _state);
+    const remotePackStatusBar = new remotePackStatusBar_js_1.RemotePackStatusBar(syncService, () => getWorkspaceRoot(outputChannel).workspaceRoot, outputChannel);
+    _state.remotePackStatusBar = remotePackStatusBar;
+    context.subscriptions.push(remotePackStatusBar);
+    void remotePackStatusBar.refresh();
+    // Initialize Agent Anywhere lifecycle manager (detect/install/start/stop gateway)
+    // This is the user-facing "Agent Anywhere" feature -- all opt-in, nothing auto-starts.
+    // The lifecycle manager owns the single status bar icon and handles connect/disconnect.
+    const { GatewayLifecycleManager } = await import('./gateway/lifecycle.js');
+    _state.gatewayLifecycle = new GatewayLifecycleManager(outputChannel, context);
+    context.subscriptions.push({ dispose: () => _state?.gatewayLifecycle?.dispose() });
+    // Initialize Gateway bridge service (WebSocket connection to gateway)
+    // Routes messages via VS Code Chat UI commands -- no direct engine access needed.
+    const { GatewayService: GatewayServiceClass } = await import('./gateway/service.js');
+    _state.gatewayService = new GatewayServiceClass(context, outputChannel);
+    context.subscriptions.push({ dispose: () => _state?.gatewayService?.dispose() });
+    // Wire lifecycle ↔ bridge: lifecycle manages connect/disconnect via the single icon
+    _state.gatewayLifecycle.setBridgeRef(_state.gatewayService);
+    // Meet Agent Anywhere is only opened from the command palette / Agent Anywhere menu — not after connect.
+    // Auto-connect bridge when gateway starts running (if autoConnect is enabled)
+    _state.gatewayLifecycle.onStatusChange(async (status) => {
+        if (status === 'running') {
+            const autoConnect = vscode.workspace.getConfiguration('agentide.anywhere').get('autoConnect', false);
+            if (autoConnect && _state?.gatewayLifecycle) {
+                void _state.gatewayLifecycle.connectBridge();
+            }
+        }
+    });
+    // Initialize Analytics service (for LiteLLM Spotlight)
+    const { AnalyticsService: AnalyticsServiceClass } = await import('./analytics/service.js');
+    _state.analyticsService = new AnalyticsServiceClass(context, outputChannel);
+    context.subscriptions.push({ dispose: () => _state?.analyticsService?.dispose() });
+    // Initialize Spotlight Dashboard (WebView sidebar with charts + chat)
+    const { AnalyticsDashboardProvider, ArtifactManagerImpl, QueryRunnerImpl, ensureBundledFleetAdapters, } = await import('./analytics/dashboard/index.js');
+    const spotlightArtifactManager = new ArtifactManagerImpl(outputChannel);
+    const teamArtifactManager = new ArtifactManagerImpl(outputChannel);
+    const queryRunner = new QueryRunnerImpl(outputChannel);
+    ensureBundledFleetAdapters(queryRunner);
+    const analyticsService = _state.analyticsService;
+    _state.analyticsDashboard = new AnalyticsDashboardProvider(context, queryRunner, spotlightArtifactManager, outputChannel, () => analyticsService?.getIndexingService());
+    const teamDashboard = new AnalyticsDashboardProvider(context, queryRunner, teamArtifactManager, outputChannel, () => analyticsService?.getIndexingService(), 'team');
+    _state.analyticsTeamDashboard = teamDashboard;
+    context.subscriptions.push(vscode.window.registerWebviewViewProvider(AnalyticsDashboardProvider.viewType, _state.analyticsDashboard, { webviewOptions: { retainContextWhenHidden: true } }), vscode.window.registerWebviewViewProvider('agentide.teamView', teamDashboard, { webviewOptions: { retainContextWhenHidden: true } }), _state.analyticsDashboard, teamDashboard, { dispose: () => spotlightArtifactManager.dispose() }, { dispose: () => teamArtifactManager.dispose() }, { dispose: () => queryRunner.dispose() });
+    // Spotlight dashboard commands
+    context.subscriptions.push(vscode.commands.registerCommand('agentide.analytics.openDashboard', () => {
+        vscode.commands.executeCommand('agentide.analyticsView.focus');
+    }), vscode.commands.registerCommand('agentide.fleet.open', async () => {
+        const team = _state?.analyticsTeamDashboard;
+        if (team) {
+            await team.openWithView('fleet');
+        }
+        await vscode.commands.executeCommand('agentide.teamView.focus');
+    }), vscode.commands.registerCommand('agentide.analytics.clearArtifacts', async () => {
+        const result = await spotlightArtifactManager.cleanup(0);
+        await context.workspaceState.update('analytics.generatedDefaultDashboard', false);
+        vscode.window.showInformationMessage(`Cleared ${result.deletedCount} Spotlight artifacts (${(result.freedBytes / 1024).toFixed(1)} KB)`);
+    }), vscode.commands.registerCommand('agentide.analytics.regenerateDefaults', async () => {
+        if (_state?.analyticsDashboard) {
+            queryRunner.invalidateCache();
+            await _state.analyticsDashboard.runDefaultChartScript();
+        }
+    }), vscode.commands.registerCommand('agentide.persistChatVote', async (payload) => {
+        if (!payload?.sessionId || !payload?.requestId)
+            return;
+        await _sessionEventWriter.append(payload.sessionId, payload.requestId, 'vote', {
+            direction: payload.direction,
+            reason: payload.reason,
+            agentId: payload.agentId,
+            command: payload.command,
+        });
+    }));
+    // Activate terminal activity logger (logs all terminal commands to the agent terminals directory)
+    // Terminal logs are automatically truncated to max N lines (configurable)
+    // Session cleanup happens opportunistically when sessions are deleted
+    (0, terminalLogger_1.activateTerminalLogger)(context);
+    // Simplest retention behavior: best-effort cleanup on startup (non-blocking).
+    // Manual cleanup is also available via 'AgentIDE: Cleanup Old Session Logs'.
+    const sessionsCleanupTimeout = setTimeout(() => {
+        void (0, terminalLogger_1.cleanupOldSessionLogs)(outputChannel);
+    }, 5_000);
+    context.subscriptions.push(new vscode.Disposable(() => clearTimeout(sessionsCleanupTimeout)));
+    // Initialize store index in background (non-blocking)
+    // This preloads the Orama search index for faster store browsing
+    const storeIndexTimeout = setTimeout(async () => {
+        try {
+            const { initializeStoreIndex } = await import("./store/oramaIndex.js");
+            await initializeStoreIndex(outputChannel);
+        }
+        catch (e) {
+            log(outputChannel, `[AgentIDE] Store index init: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }, 3_000); // Delay slightly to prioritize other startup tasks
+    context.subscriptions.push(new vscode.Disposable(() => clearTimeout(storeIndexTimeout)));
+    // Setup workspace watchers and repair unregistered packs
+    if (vscode.workspace.workspaceFolders?.length) {
+        void refreshAgentideProject(_state).then(async () => {
+            syncService.ensureAgentideWatchers(outputChannel);
+            // Auto-repair: register any untracked packs found on disk
+            try {
+                const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+                const { AgentPackManager } = await import("./agentpack/index.js");
+                const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+                const { registered } = await packManager.repairUnregisteredAgents();
+                if (registered.length > 0) {
+                    log(outputChannel, `[AgentIDE] Auto-repaired ${registered.length} unregistered pack(s): ${registered.join(", ")}`);
+                }
+            }
+            catch (e) {
+                log(outputChannel, `[AgentIDE] Pack repair check failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            // Note: Pack restoration is now handled by the workbench (AgentPackService).
+            // The workbench persists the active pack ID in IStorageService and calls
+            // agentide.pack.setActive on startup to restore pack files.
+            // Mode/model preferences are stored in the chat widget's storage and
+            // restored by the chat widget itself.
+            void _state?.remotePackStatusBar?.refresh();
+        });
+    }
+    context.subscriptions.push(vscode.workspace.onDidChangeWorkspaceFolders(() => {
+        syncService.ensureAgentideWatchers(outputChannel);
+        if (_state) {
+            void refreshAgentideProject(_state);
+            void _state.remotePackStatusBar?.refresh();
+        }
+    }));
+    context.subscriptions.push(new vscode.Disposable(() => {
+        syncService.disposeAllWatchers();
+    }));
+    log(outputChannel, "[AgentIDE] Extension activation complete");
+}
+function deactivate() {
+    if (_state) {
+        for (const engine of Object.values(_state.engines)) {
+            try {
+                engine.dispose();
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    _state = undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function quoteEnvValue(value) {
+    if (/^[A-Za-z0-9_./:@-]+$/.test(value)) {
+        return value;
+    }
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function upsertEnvVar(content, variable, value) {
+    const lines = content.split(/\r?\n/);
+    const matcher = new RegExp(`^\\s*(?:export\\s+)?${escapeRegExp(variable)}\\s*=`);
+    let replaced = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        if (matcher.test(line)) {
+            lines[i] = `${variable}=${quoteEnvValue(value)}`;
+            replaced = true;
+        }
+    }
+    if (!replaced) {
+        if (lines.length > 0 && lines[lines.length - 1].trim() !== "") {
+            lines.push("");
+        }
+        lines.push(`${variable}=${quoteEnvValue(value)}`);
+    }
+    return lines.join("\n").replace(/\s*$/, "\n");
+}
+function hasEnvVar(content, variable) {
+    const matcher = new RegExp(`^\\s*(?:export\\s+)?${escapeRegExp(variable)}\\s*=`);
+    return content.split(/\r?\n/).some(line => {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            return false;
+        }
+        return matcher.test(line);
+    });
+}
+// -----------------------------------------------------------------------------
+// Command Registration
+// -----------------------------------------------------------------------------
+function registerCommands(context, state) {
+    const { outputChannel, syncService, config } = state;
+    // Set API keys (called from Workbench)
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.setParticipantApiKey", (args) => {
+        log(outputChannel, `[AgentIDE] Setting API key for ${args.provider}${args.baseUrl ? ` with baseUrl: ${args.baseUrl}` : ""}`);
+        if (args.provider === "litellm") {
+            config.litellmApiKey = args.apiKey;
+            config.litellmBaseUrl = args.baseUrl;
+        }
+    }));
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.binary.findOnPath", async (args) => {
+        const name = args?.name?.trim();
+        if (!name) {
+            throw new Error("Binary name is required");
+        }
+        return (0, binary_1.findBinaryCached)(name, (0, binary_1.getCommonBinaryPaths)(name));
+    }));
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.openaiCodex.loginOAuth", async () => {
+        log(outputChannel, "[AgentIDE] Starting native OpenAI Codex OAuth login");
+        const { loginOpenAICodex } = await import("@mariozechner/pi-ai");
+        const creds = await loginOpenAICodex({
+            onAuth: async ({ url }) => {
+                log(outputChannel, `[AgentIDE] OpenAI Codex OAuth URL: ${url}`);
+                try {
+                    await vscode.env.openExternal(vscode.Uri.parse(url));
+                    void showInfo("Complete ChatGPT sign-in in your browser. Return here if prompted for a redirect URL.");
+                }
+                catch (error) {
+                    log(outputChannel, `[AgentIDE] Failed to auto-open OAuth URL: ${String(error)}`);
+                    void showWarning(`Open this URL in your browser: ${url}`);
+                }
+            },
+            onPrompt: async (prompt) => {
+                const input = await vscode.window.showInputBox({
+                    title: "OpenAI Codex OAuth",
+                    prompt: prompt.message,
+                    placeHolder: prompt.placeholder,
+                    ignoreFocusOut: true,
+                    validateInput: value => value.trim().length > 0 ? undefined : "Required"
+                });
+                if (!input || input.trim().length === 0) {
+                    throw new Error("OpenAI Codex OAuth cancelled");
+                }
+                return input.trim();
+            },
+            onProgress: (message) => {
+                log(outputChannel, `[AgentIDE] OpenAI Codex OAuth: ${message}`);
+            }
+        });
+        const apiKey = creds?.access?.trim();
+        if (!apiKey) {
+            throw new Error("OpenAI Codex OAuth completed without an access token");
+        }
+        const oauthCredential = { type: "oauth", ...creds };
+        const result = {
+            apiKey,
+            oauthCredential,
+            expiresAt: typeof creds.expires === "number" ? creds.expires : undefined
+        };
+        log(outputChannel, "[AgentIDE] OpenAI Codex OAuth login complete");
+        return result;
+    }));
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.openaiCodex.getValidApiKey", async (args) => {
+        const oauthCredential = args?.oauthCredential;
+        if (!oauthCredential || typeof oauthCredential !== "object") {
+            throw new Error("Missing openai-codex OAuth credential payload.");
+        }
+        const { getOAuthApiKey } = await import("@mariozechner/pi-ai");
+        const normalized = ((oauthCredential.type === "oauth")
+            ? oauthCredential
+            : { type: "oauth", ...oauthCredential });
+        const authMap = {
+            "openai-codex": normalized,
+        };
+        const resolved = await getOAuthApiKey("openai-codex", authMap);
+        if (!resolved?.apiKey) {
+            throw new Error("OpenAI Codex OAuth credential is invalid or expired. Please sign in again.");
+        }
+        return {
+            apiKey: String(resolved.apiKey),
+            oauthCredential: { type: "oauth", ...resolved.newCredentials },
+            expiresAt: typeof resolved.newCredentials?.expires === "number"
+                ? resolved.newCredentials.expires
+                : undefined
+        };
+    }));
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.litellm.setUpstreamApiKey", async (args) => {
+        const envVar = args?.envVar?.trim() ?? "";
+        const apiKey = args?.apiKey?.trim() ?? "";
+        if (!envVar || !/^[A-Z][A-Z0-9_]*$/.test(envVar)) {
+            throw new Error(`Invalid env var name: ${envVar}`);
+        }
+        if (!apiKey) {
+            throw new Error(`API key value cannot be empty for ${envVar}`);
+        }
+        const agentHomeDir = (0, index_1.getAgentideHome)();
+        const envFilePath = path.join(agentHomeDir, ".env");
+        await fs_1.promises.mkdir(agentHomeDir, { recursive: true, mode: 0o700 });
+        let existingContent = "";
+        try {
+            existingContent = await fs_1.promises.readFile(envFilePath, "utf8");
+        }
+        catch {
+            // File does not exist yet, we'll create it below.
+        }
+        const updatedContent = upsertEnvVar(existingContent, envVar, apiKey);
+        await fs_1.promises.writeFile(envFilePath, updatedContent, "utf8");
+        try {
+            await fs_1.promises.chmod(envFilePath, 0o600);
+        }
+        catch {
+            // Best-effort on platforms that may not support chmod.
+        }
+        log(outputChannel, `[AgentIDE] Updated LiteLLM upstream key in ${envFilePath} (${envVar})`);
+        return { envFilePath, envVar };
+    }));
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.litellm.getUpstreamApiKeyStatus", async (args) => {
+        const envVar = args?.envVar?.trim() ?? "";
+        if (!envVar || !/^[A-Z][A-Z0-9_]*$/.test(envVar)) {
+            throw new Error(`Invalid env var name: ${envVar}`);
+        }
+        const agentHomeDir = (0, index_1.getAgentideHome)();
+        const envFilePath = path.join(agentHomeDir, ".env");
+        let existingContent = "";
+        try {
+            existingContent = await fs_1.promises.readFile(envFilePath, "utf8");
+        }
+        catch {
+            // Missing file means key is not configured yet.
+        }
+        return {
+            envFilePath,
+            envVar,
+            exists: hasEnvVar(existingContent, envVar),
+        };
+    }));
+    // Clear managed resources
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.clearManagedResources", async () => {
+        const confirm = await vscode.window.showWarningMessage((0, branding_1.brandify)("Clear all AgentIDE managed resources?"), {
+            modal: true,
+            detail: `This will remove derived folders and generated files. User-managed files in \`${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}/\` will NOT be deleted.`,
+        }, "Clear Resources", "Cancel");
+        if (confirm !== "Clear Resources") {
+            return;
+        }
+        const { workspaceRoot, additionalDirectories, isHomeFallback } = getWorkspaceRoot(outputChannel);
+        if (isHomeFallback) {
+            // Ensure fallback exists before doing any filesystem work.
+            await ensureFallbackDirectoryExists(outputChannel);
+        }
+        const { cleared, skipped, errors } = await syncService.clearManagedResources(config.codexHome, config.claudeConfigDir, workspaceRoot, additionalDirectories, outputChannel);
+        const message = [
+            `Cleared: ${cleared.length} resources`,
+            skipped.length > 0 ? `Skipped: ${skipped.length} (user files)` : "",
+            errors.length > 0 ? `Errors: ${errors.length}` : "",
+        ]
+            .filter(Boolean)
+            .join(" | ");
+        if (errors.length > 0) {
+            showError(`AgentIDE: ${message}`);
+            log(outputChannel, `[AgentIDE] Errors: ${errors.join(", ")}`);
+        }
+        else {
+            showInfo(`AgentIDE: ${message}`);
+        }
+        log(outputChannel, `[AgentIDE] Clear complete: ${message}`);
+    }));
+    // Sync remote skills into the default agent skills directory (best-effort)
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.skills.syncRemote", async () => {
+        const { workspaceRoot, additionalDirectories, isHomeFallback } = getWorkspaceRoot(outputChannel);
+        if (isHomeFallback) {
+            await ensureFallbackDirectoryExists(outputChannel);
+        }
+        // Ensure project exists (creates agent root if missing)
+        await syncService.ensureAgentideProjectPrepared(workspaceRoot, additionalDirectories, outputChannel);
+        // Force a remote skills sync regardless of syncOnStartup
+        await syncService.syncRemoteSkillsIfEnabled(workspaceRoot, outputChannel, { force: true });
+        // Apply changes immediately (refresh manifest + derived dirs if needed)
+        await syncService.flushAgentideRootUpdate(workspaceRoot, outputChannel, {
+            allowDuringActiveTurn: true,
+            force: false,
+        });
+        void showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: Remote skills sync complete (see ${branding_1.AGENTIDE_BRAND_NAME} output for details).`);
+    }));
+    // Show managed resources
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.showManagedResources", async () => {
+        const { workspaceRoot, additionalDirectories, isHomeFallback } = getWorkspaceRoot(outputChannel);
+        if (isHomeFallback) {
+            // Ensure fallback exists before writing derived files.
+            await ensureFallbackDirectoryExists(outputChannel);
+        }
+        await syncService.writeManagedPathsManifest(config.codexHome, config.claudeConfigDir, workspaceRoot, additionalDirectories, outputChannel);
+        const manifestPath = path.join((0, paths_1.getAgentideDir)(workspaceRoot), "paths.md");
+        if (await (0, utils_1.pathExists)(manifestPath)) {
+            const doc = await vscode.workspace.openTextDocument(manifestPath);
+            await vscode.window.showTextDocument(doc);
+        }
+    }));
+    // Cleanup old session logs
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.cleanupSessionLogs", async () => {
+        const result = await (0, terminalLogger_1.cleanupOldSessionLogs)(outputChannel);
+        if (result.cleaned > 0) {
+            showInfo(`AgentIDE: Cleaned up ${result.cleaned} old session(s)`);
+        }
+        else if (result.errors.length > 0) {
+            showWarning(`AgentIDE: Cleanup completed with ${result.errors.length} error(s)`);
+        }
+        else {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No old sessions to clean up`);
+        }
+    }));
+    // Delete specific session logs and opportunistically clean up old sessions
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.deleteSessionLogs", async (args) => {
+        const sessionId = args?.sessionId;
+        if (!sessionId) {
+            return { deleted: false, error: "sessionId is required" };
+        }
+        const result = await (0, terminalLogger_1.deleteSessionLogs)(sessionId);
+        if (result.deleted) {
+            log(outputChannel, `[AgentIDE] Deleted session logs: ${sessionId}`);
+            // Optional: run best-effort retention cleanup after deletion.
+            void (0, terminalLogger_1.cleanupOldSessionLogs)(outputChannel);
+        }
+        else if (result.error) {
+            log(outputChannel, `[AgentIDE] Failed to delete session logs: ${result.error}`);
+        }
+        return result;
+    }));
+    // -------------------------------------------------------------------------
+    // CLI Setup
+    // -------------------------------------------------------------------------
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.cli.status", async () => {
+        const configuredCliPath = vscode.workspace
+            .getConfiguration("agentide")
+            .get("cli.path", "");
+        const health = await (0, runtime_1.getCliHealth)({
+            configuredPath: configuredCliPath,
+            extensionPath: context.extensionPath,
+        });
+        const toolsHealth = (0, runtime_1.getBundledToolsHealth)({
+            extensionPath: context.extensionPath,
+            binaryDirHint: health.path ? path.dirname(health.path) : undefined,
+        });
+        const availableTools = toolsHealth.tools.filter(tool => tool.available).map(tool => tool.name);
+        if (health.installed) {
+            const sourceLabel = health.source === 'setting'
+                ? 'configured path'
+                : health.source === 'bundled'
+                    ? 'bundled binary'
+                    : 'system PATH';
+            const toolsSuffix = availableTools.length > 0
+                ? `; tools: ${availableTools.join(', ')}`
+                : '; tools: none';
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: CLI available (${sourceLabel})${health.version ? `  ${health.version}` : ''}${toolsSuffix}`);
+        }
+        else {
+            showWarning(`${branding_1.AGENTIDE_BRAND_NAME}: CLI not found. Run '${branding_1.AGENTIDE_BRAND_NAME}: Setup AgentHippo CLI'.`);
+        }
+        return health;
+    }));
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.cli.isInstalled", async () => {
+        const configuredCliPath = vscode.workspace
+            .getConfiguration("agentide")
+            .get("cli.path", "");
+        const health = await (0, runtime_1.getCliHealth)({
+            configuredPath: configuredCliPath,
+            extensionPath: context.extensionPath,
+        });
+        return health.installed;
+    }));
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.installBundledTools", async () => {
+        const toolsHealth = (0, runtime_1.getBundledToolsHealth)({ extensionPath: context.extensionPath });
+        if (!toolsHealth.platformKey) {
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: Unsupported platform ${process.platform}-${process.arch}. Cannot install bundled tools.`);
+            return;
+        }
+        const storageUri = context.globalStorageUri;
+        if (!storageUri) {
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: No global storage path. Cannot install bundled tools.`);
+            return;
+        }
+        const outBaseDir = path.join(storageUri.fsPath, 'tools');
+        const scriptCandidates = [
+            path.join(context.extensionPath, 'out', 'scripts', 'vendor-tools.mjs'),
+            path.join(context.extensionPath, 'scripts', 'vendor-tools.mjs'),
+        ];
+        const scriptPath = scriptCandidates.find((p) => {
+            try {
+                return require('fs').statSync(p).isFile();
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!scriptPath) {
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: vendor-tools script not found. Run from extension source or rebuild.`);
+            return;
+        }
+        log(outputChannel, `[AgentIDE] Installing bundled tools (rg, sg, tree-sitter) into ${outBaseDir} ...`);
+        try {
+            const { spawn } = await import('child_process');
+            await new Promise((resolve, reject) => {
+                const child = spawn(process.execPath, [scriptPath, '--out-dir', outBaseDir, '--clean'], {
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    env: { ...process.env },
+                });
+                let stderr = '';
+                child.stdout?.on('data', (chunk) => log(outputChannel, chunk.toString()));
+                child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); log(outputChannel, chunk.toString()); });
+                child.on('error', reject);
+                child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`Exit ${code}: ${stderr}`))));
+            });
+            const toolsDir = path.join(outBaseDir, toolsHealth.platformKey);
+            await context.globalState.update(BUNDLED_TOOLS_DIR_KEY, toolsDir);
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: Bundled tools installed to ${toolsDir}. They will be used by the agent.`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Install bundled tools failed: ${msg}`);
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: Failed to install bundled tools. Check Output > Agent Hippo. ${msg}`);
+        }
+    }));
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.setupCli", async () => {
+        log(outputChannel, "[AgentIDE] Starting CLI setup...");
+        const cliConfig = vscode.workspace.getConfiguration("agentide.cli");
+        const configuredCliPath = cliConfig.get("path", "");
+        const installSource = cliConfig.get("installSource", "").trim();
+        if (installSource && /[;`|$&\n\r"']/.test(installSource)) {
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: Invalid CLI install source. Remove shell control characters from 'agentide.cli.installSource'.`);
+            return { success: false, error: "Invalid install source" };
+        }
+        const health = await (0, runtime_1.getCliHealth)({
+            configuredPath: configuredCliPath,
+            extensionPath: context.extensionPath,
+            forceRefresh: true,
+        });
+        if (health.installed && health.path) {
+            await vscode.workspace
+                .getConfiguration("agentide")
+                .update("cli.path", health.path, vscode.ConfigurationTarget.Global);
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: CLI is ready at ${health.path}`);
+            return { success: true, path: health.path };
+        }
+        const isWindows = process.platform === "win32";
+        const scriptName = isWindows ? "setup-cli.ps1" : "setup-cli.sh";
+        const candidates = [
+            path.join(context.extensionPath, "out", "scripts", scriptName),
+            path.join(context.extensionPath, "scripts", scriptName),
+        ];
+        const scriptPath = candidates.find((p) => {
+            try {
+                require("fs").accessSync(p);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!scriptPath) {
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: CLI setup script not found. Build CLI via extensions/agentide/scripts/build-cli.sh and set agentide.cli.path.`);
+            return { success: false, error: "Script not found" };
+        }
+        const setupResult = await runCliSetup(scriptPath, outputChannel, installSource);
+        if (!setupResult.success) {
+            return setupResult;
+        }
+        const refreshed = await (0, runtime_1.getCliHealth)({
+            configuredPath: configuredCliPath,
+            extensionPath: context.extensionPath,
+            forceRefresh: true,
+        });
+        if (refreshed.installed && refreshed.path) {
+            await vscode.workspace
+                .getConfiguration("agentide")
+                .update("cli.path", refreshed.path, vscode.ConfigurationTarget.Global);
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: CLI configured at ${refreshed.path}`);
+            return { success: true, path: refreshed.path };
+        }
+        showWarning(`${branding_1.AGENTIDE_BRAND_NAME}: Setup launched. Re-run '${branding_1.AGENTIDE_BRAND_NAME}: CLI Status' after terminal setup completes.`);
+        return { success: true, pending: true };
+    }));
+    async function runCliSetup(scriptPath, outputChannel, installSource) {
+        const isWindows = process.platform === "win32";
+        const isUrlSource = /^https?:\/\//i.test(installSource);
+        const sourceArg = installSource
+            ? isWindows
+                ? `-Source \"${installSource}\"`
+                : `--source \"${installSource}\"`
+            : "";
+        const terminal = isWindows
+            ? vscode.window.createTerminal({
+                name: "AgentHippo CLI Setup",
+                cwd: path.dirname(scriptPath),
+                shellPath: "powershell.exe",
+                shellArgs: [
+                    "-NoProfile",
+                    "-NoExit",
+                    "-ExecutionPolicy",
+                    "Bypass",
+                    "-Command",
+                    `& "${scriptPath}" ${sourceArg} -Yes; Write-Host ""; Write-Host "You can close this window."`,
+                ],
+            })
+            : vscode.window.createTerminal({
+                name: "AgentHippo CLI Setup",
+                cwd: path.dirname(scriptPath),
+                shellPath: "/bin/bash",
+                shellArgs: [
+                    "-c",
+                    `"${scriptPath}" ${sourceArg} --yes; echo ''; echo 'Press any key to close...'; read -n 1`,
+                ],
+            });
+        if (installSource) {
+            log(outputChannel, `[AgentIDE] CLI install source configured (${isUrlSource ? 'url' : 'package/path'}): ${installSource}`);
+        }
+        terminal.show();
+        showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: CLI setup started. Check the terminal for progress.`);
+        log(outputChannel, "[AgentIDE] CLI setup terminal opened");
+        return { success: true };
+    }
+    // -------------------------------------------------------------------------
+    // Spotlight Setup
+    // -------------------------------------------------------------------------
+    // Install or repair Spotlight (OTEL Collector + DuckDB)
+    // Scripts are bundled with the extension for reliable access
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.setupAnalytics", async () => {
+        log(outputChannel, "[AgentIDE] Starting Spotlight install/repair...");
+        const isWindows = process.platform === "win32";
+        const scriptName = isWindows ? "setup-analytics.ps1" : "setup-analytics.sh";
+        const extensionPath = context.extensionPath;
+        // Try bundled location first, then dev location
+        const candidates = [
+            path.join(extensionPath, "out", "scripts", "analytics", scriptName),
+            path.join(extensionPath, "scripts", "analytics", scriptName),
+        ];
+        const scriptPath = candidates.find((p) => {
+            try {
+                require("fs").accessSync(p);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!scriptPath) {
+            showError(`Spotlight install script not found. Please run 'scripts/analytics/${scriptName}' manually from the AgentIDE repository.`);
+            return { success: false, error: "Script not found" };
+        }
+        if (isWindows && _state?.analyticsService) {
+            return _state.analyticsService.setupWindowsSpotlight({ reinstall: false });
+        }
+        return runAnalyticsSetup(scriptPath, outputChannel);
+    }));
+    async function runAnalyticsSetup(scriptPath, outputChannel) {
+        const isWindows = process.platform === "win32";
+        const agentHomeDir = path.join(os.homedir(), branding_1.AGENTIDE_DIR_NAME);
+        const terminal = isWindows
+            ? vscode.window.createTerminal({
+                name: "Spotlight Install",
+                cwd: path.dirname(scriptPath),
+                env: { AGENT_HOME_DIR: agentHomeDir },
+                shellPath: "powershell.exe",
+                shellArgs: ["-NoProfile", "-NoExit", "-ExecutionPolicy", "Bypass", "-Command",
+                    `& "${scriptPath}" -Yes; Write-Host ""; Write-Host "You can close this window."`],
+            })
+            : vscode.window.createTerminal({
+                name: "Spotlight Install",
+                cwd: path.dirname(scriptPath),
+                env: { AGENT_HOME_DIR: agentHomeDir },
+                shellPath: "/bin/bash",
+                shellArgs: ["-c", `"${scriptPath}" --yes; echo ''; echo 'Press any key to close...'; read -n 1`],
+            });
+        terminal.show();
+        showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: Spotlight install started. Check the terminal for progress.`);
+        log(outputChannel, "[AgentIDE] Spotlight install terminal opened");
+        return { success: true };
+    }
+    // -------------------------------------------------------------------------
+    // AgentPack Commands
+    // -------------------------------------------------------------------------
+    // Install agent pack from local folder
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.install", async () => {
+        const { workspaceRoot, isHomeFallback } = getWorkspaceRoot(outputChannel);
+        if (isHomeFallback) {
+            await ensureFallbackDirectoryExists(outputChannel);
+        }
+        const folders = await vscode.window.showOpenDialog({
+            canSelectFolders: true,
+            canSelectFiles: false,
+            canSelectMany: false,
+            openLabel: "Select Agent Pack Folder",
+            title: "Install Agent Pack",
+        });
+        if (!folders || folders.length === 0) {
+            return;
+        }
+        const sourcePath = folders[0].fsPath;
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        try {
+            const installed = await packManager.installFromLocal(sourcePath);
+            showInfo(`AgentIDE: Installed pack "${installed.id}" v${installed.version}`);
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Pack install error: ${errorMsg}`);
+            showError(`AgentIDE: Failed to install pack - ${errorMsg}`);
+        }
+    }));
+    // List installed packs
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.list", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        const packs = await packManager.listInstalled();
+        if (packs.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No agent packs installed`);
+            return;
+        }
+        const items = packs.map((p) => ({
+            label: p.id,
+            description: `v${p.version} (${p.preferredEngine})`,
+            detail: `Status: ${p.status} | Installed: ${new Date(p.installedAt).toLocaleDateString()}`,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select a pack to view details",
+            title: "Installed Agent Packs",
+        });
+        if (selected) {
+            log(outputChannel, `[AgentIDE] Pack selected: ${selected.label}`);
+            outputChannel.show();
+        }
+    }));
+    // Get installed packs (data-only, no UI)
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.getInstalled", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        try {
+            return await packManager.listInstalled();
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Pack list error: ${errorMsg}`);
+            return [];
+        }
+    }));
+    // List discovered custom engines (data-only, no UI)
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.customEngine.list", (args) => {
+        const additionalEngineDir = getConfiguredAdditionalEngineDir();
+        const explicitWorkspaceRoot = args?.workspaceRoot?.trim();
+        const workspaceFolderRoots = (vscode.workspace.workspaceFolders ?? [])
+            .map((folder) => folder.uri.fsPath)
+            .filter((value) => !!value?.trim());
+        const processCwd = process.cwd?.();
+        const candidateRoots = Array.from(new Set([
+            explicitWorkspaceRoot,
+            ...workspaceFolderRoots,
+            processCwd,
+        ]
+            .map((value) => value?.trim())
+            .filter((value) => !!value)));
+        const manifestsById = new Map();
+        for (const root of candidateRoots) {
+            try {
+                const manifests = (0, customRegistry_1.discoverCustomEngineManifests)(root, additionalEngineDir);
+                for (const manifest of manifests) {
+                    if (!manifestsById.has(manifest.id)) {
+                        manifestsById.set(manifest.id, {
+                            id: manifest.id,
+                            displayName: manifest.displayName || manifest.id,
+                            description: manifest.description,
+                            defaultModel: manifest.model?.defaultModel,
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                const errorMsg = e instanceof Error ? e.message : String(e);
+                log(outputChannel, `[AgentIDE] Custom engine list warning for root ${root}: ${errorMsg}`);
+            }
+        }
+        if (manifestsById.size === 0) {
+            try {
+                const manifests = (0, customRegistry_1.discoverCustomEngineManifests)(undefined, additionalEngineDir);
+                for (const manifest of manifests) {
+                    manifestsById.set(manifest.id, {
+                        id: manifest.id,
+                        displayName: manifest.displayName || manifest.id,
+                        description: manifest.description,
+                        defaultModel: manifest.model?.defaultModel,
+                    });
+                }
+            }
+            catch (e) {
+                const errorMsg = e instanceof Error ? e.message : String(e);
+                log(outputChannel, `[AgentIDE] Custom engine list error: ${errorMsg}`);
+            }
+        }
+        log(outputChannel, `[AgentIDE] Custom engine list: ${manifestsById.size} discovered (${Array.from(manifestsById.keys()).join(", ") || "none"}) from roots: ${candidateRoots.join("; ") || "(home only)"}`);
+        return Array.from(manifestsById.values());
+    }));
+    // Uninstall a custom engine from the default home install root
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.engine.uninstall", async (args) => {
+        const { listInstalledCustomEngines, uninstallCustomEngine, } = await import("./engines/install.js");
+        let engineId = args?.id?.trim();
+        let displayName = engineId;
+        if (!engineId) {
+            const installed = await listInstalledCustomEngines();
+            if (installed.length === 0) {
+                showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No custom engines are installed`);
+                return;
+            }
+            const selected = await vscode.window.showQuickPick(installed.map(engine => ({
+                label: engine.displayName,
+                description: engine.id,
+                detail: engine.installDir,
+                engine,
+            })), {
+                placeHolder: "Select a custom engine to uninstall",
+                title: "Uninstall Custom Engine",
+            });
+            if (!selected) {
+                return;
+            }
+            engineId = selected.engine.id;
+            displayName = selected.engine.displayName;
+        }
+        if (!engineId) {
+            return;
+        }
+        if (args?.skipConfirmation !== true) {
+            const confirmed = await vscode.window.showWarningMessage(`Uninstall custom engine "${displayName || engineId}"?`, { modal: true }, "Uninstall", "Cancel");
+            if (confirmed !== "Uninstall") {
+                return;
+            }
+        }
+        const result = await uninstallCustomEngine(engineId, { logger: outputChannel });
+        if (!result.removed) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: Custom engine "${result.id}" is not installed`);
+            return;
+        }
+        clearCustomEngineRuntimeCache(state, result.id);
+        const { invalidateLocalIndex } = await import("./store/oramaIndex.js");
+        invalidateLocalIndex();
+        await refreshCustomEnginePicker(outputChannel);
+        showInfo(`Uninstalled engine "${result.displayName || result.id}"`);
+    }));
+    // Publish custom engine to store (fork + PR)
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.engine.publish", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { collectEngineFiles, discoverPublishableEngines, isValidPublishVersion, validateEngineForPublish, } = await import("./engines/publish.js");
+        const { publishToStore, STORE_CONFIG, canPublishDirectlyToStore } = await import("./store/index.js");
+        const engines = await discoverPublishableEngines(workspaceRoot);
+        if (engines.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No custom engines found. Add engine.manifest.json under .agent-hippo/engines/<id>/`);
+            return;
+        }
+        const selected = await vscode.window.showQuickPick(engines.map(engine => ({
+            label: engine.displayName,
+            description: engine.id,
+            detail: `${engine.sourceLabel}: ${engine.sourceDir}`,
+            engine,
+        })), {
+            placeHolder: "Select a custom engine to publish",
+            title: `Publish to ${STORE_CONFIG.owner}/${STORE_CONFIG.repo}`,
+        });
+        if (!selected) {
+            return;
+        }
+        try {
+            const validation = await validateEngineForPublish(selected.engine.sourceDir, selected.engine.id);
+            if (!validation.valid) {
+                showError(`${branding_1.AGENTIDE_BRAND_NAME}: Cannot publish - ${validation.errors.join(", ")}`);
+                return;
+            }
+            if (validation.warnings.length > 0) {
+                const proceed = await vscode.window.showWarningMessage(`Warnings: ${validation.warnings.join(", ")}`, "Publish Anyway", "Cancel");
+                if (proceed !== "Publish Anyway") {
+                    return;
+                }
+            }
+            const versionInput = await vscode.window.showInputBox({
+                prompt: "Publish version (semver)",
+                value: validation.metadata?.suggestedVersion || "1.0.0",
+                placeHolder: "e.g., 1.0.0",
+                validateInput: value => value && isValidPublishVersion(value.replace(/^v/, ""))
+                    ? null
+                    : "Use semver format (e.g., 1.0.0)",
+            });
+            if (!versionInput) {
+                return;
+            }
+            const version = versionInput.replace(/^v/, "");
+            const changelog = await vscode.window.showInputBox({
+                prompt: "What changed in this version? (optional)",
+                placeHolder: "Initial release, bug fixes...",
+            });
+            const files = await collectEngineFiles(selected.engine.sourceDir);
+            const publishDirect = await canPublishDirectlyToStore();
+            const confirm = await vscode.window.showWarningMessage(publishDirect
+                ? `Publish "${selected.engine.id}" v${version} to ${STORE_CONFIG.owner}/${STORE_CONFIG.repo}?\n\nThis will open a pull request on the store repository.`
+                : `Submit "${selected.engine.id}" v${version} to ${STORE_CONFIG.owner}/${STORE_CONFIG.repo}?\n\nThis will create a pull request from your fork.`, { modal: true }, "Submit PR");
+            if (confirm !== "Submit PR") {
+                return;
+            }
+            const result = await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Window,
+                title: `Publishing engine ${selected.engine.id} v${version}`,
+                cancellable: false,
+            }, async (progress) => {
+                progress.report({
+                    message: publishDirect
+                        ? `Publishing to ${STORE_CONFIG.owner}/${STORE_CONFIG.repo}...`
+                        : "Preparing fork...",
+                });
+                const res = await publishToStore({
+                    type: "engine",
+                    slug: selected.engine.id,
+                    version,
+                    files,
+                    changelog,
+                }, outputChannel);
+                progress.report({ message: "Creating PR..." });
+                return res;
+            });
+            const viewAction = await vscode.window.showInformationMessage(`Published engine "${selected.engine.id}" v${version}! PR created.`, "View PR");
+            if (viewAction === "View PR") {
+                vscode.env.openExternal(vscode.Uri.parse(result.prUrl));
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Engine publish error: ${errorMsg}`);
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: ${errorMsg}`);
+        }
+    }));
+    // Uninstall agent pack
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.uninstall", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager, isDefaultAgent } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        const packs = await packManager.listInstalled();
+        // Filter out the default agent - it cannot be uninstalled
+        const uninstallablePacks = packs.filter((p) => !isDefaultAgent(p.id));
+        if (uninstallablePacks.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No agent packs available to uninstall`);
+            return;
+        }
+        const items = uninstallablePacks.map((p) => ({
+            label: p.id,
+            description: `v${p.version}${state.activePackId === p.id ? " (active)" : ""}`,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select a pack to uninstall",
+            title: "Uninstall Agent Pack",
+        });
+        if (!selected) {
+            return;
+        }
+        const packIdToUninstall = selected.label;
+        const wasActive = state.activePackId === packIdToUninstall;
+        const confirm = await vscode.window.showWarningMessage(`Uninstall agent pack "${packIdToUninstall}"?${wasActive ? " This will switch to the default agent." : ""}`, { modal: true }, "Uninstall", "Cancel");
+        if (confirm !== "Uninstall") {
+            return;
+        }
+        try {
+            await packManager.uninstall(packIdToUninstall);
+            // If uninstalling the active pack, switch to default agent
+            if (wasActive) {
+                const appliedPackId = await syncService.switchToPack(workspaceRoot, undefined, // Switch to default
+                outputChannel, { importDerivedSkills: true });
+                state.activePackId = appliedPackId;
+                syncService.setActivePackId(workspaceRoot, appliedPackId);
+                log(outputChannel, `[AgentIDE] Switched to default agent after uninstalling active pack`);
+                // Notify workbench to update its pack state
+                try {
+                    await vscode.commands.executeCommand("agentide.applyPackPreferences", {
+                        packId: "default",
+                        silent: true,
+                    });
+                }
+                catch {
+                    // Workbench command may not be available
+                }
+            }
+            showInfo(`AgentIDE: Uninstalled pack "${packIdToUninstall}"${wasActive ? " - switched to default agent" : ""}`);
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Pack uninstall error: ${errorMsg}`);
+            showError(`AgentIDE: Failed to uninstall pack - ${errorMsg}`);
+        }
+    }));
+    // Set active pack (for next request) - syncs pack content to workspace .claude/.codex
+    // NOTE: This is an INTERNAL command (not in package.json contributions).
+    // It only handles file syncing. Mode/model switching is done via agentide.applyPackPreferences
+    // on the workbench side. For interactive UI, use workbench.action.chat.openAgentPackPicker.
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.setActive", async (args) => {
+        if (!args?.packId) {
+            throw new Error("packId is required. Use workbench.action.chat.openAgentPackPicker for interactive selection.");
+        }
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        // Switch pack and sync derived dirs
+        const packId = args.packId === "default" ? undefined : args.packId;
+        const appliedPackId = await syncService.switchToPack(workspaceRoot, packId, outputChannel, { importDerivedSkills: true });
+        state.activePackId = appliedPackId;
+        // Track active pack in SyncService for file-watcher awareness
+        syncService.setActivePackId(workspaceRoot, appliedPackId);
+        log(outputChannel, `[AgentIDE] Active pack switched to: ${appliedPackId ?? "default"}`);
+        await state.remotePackStatusBar?.refresh({ notifyOnActivate: true });
+        // Note: Pack ID is now persisted by the workbench (IAgentPackService)
+        // The extension just handles file sync operations
+        return { activePackId: state.activePackId ?? "default" };
+    }));
+    // Get active pack ID
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.getActive", () => {
+        return { activePackId: state.activePackId ?? "default" };
+    }));
+    // Remote pack URL for the active (or specified) pack — used by the workbench to bypass
+    // local engine credential resolution when spec.remote.url is set.
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.getRemoteServeUrl", async (args) => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const packId = args?.packId?.trim()
+            || syncService.getActivePackId(workspaceRoot)
+            || state.activePackId;
+        if (!packId || packId === 'default') {
+            return undefined;
+        }
+        const manifest = await syncService.getActiveAgentManifest(workspaceRoot, outputChannel, packId);
+        const remoteUrl = (0, serveClient_js_1.getRemoteServeUrl)(manifest);
+        if (!remoteUrl) {
+            return undefined;
+        }
+        return {
+            packId,
+            remoteUrl,
+            preferredEngine: manifest?.spec?.engine,
+        };
+    }));
+    // Create a new agent pack scaffold
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.create", async () => {
+        const { workspaceRoot, isHomeFallback } = getWorkspaceRoot(outputChannel);
+        if (isHomeFallback) {
+            await ensureFallbackDirectoryExists(outputChannel);
+        }
+        // Get current chat state to capture current model (best effort)
+        // We use modelId (e.g., 'claude-sonnet-4-20250514', 'litellm::gpt-nano') for reliable matching
+        let currentModelId;
+        try {
+            const chatState = await vscode.commands.executeCommand("agentide.getChatState");
+            currentModelId = chatState?.modelId;
+            log(outputChannel, `[AgentIDE] Current chat state: mode=${chatState?.mode}, modelId=${currentModelId}, modelName=${chatState?.modelName}`);
+        }
+        catch {
+            // Command may not be available yet
+        }
+        // Prompt for pack name with inline validation (including "already exists" check)
+        const rawPackName = await vscode.window.showInputBox({
+            prompt: "Enter the agent pack name",
+            placeHolder: "e.g., code-reviewer, security-auditor, My Code Reviewer",
+            validateInput: async (input) => {
+                const normalized = (0, paths_1.normalizePackName)(input);
+                // Check for invalid name first
+                const nameError = (0, paths_1.getPackNameError)(normalized);
+                if (nameError) {
+                    return nameError;
+                }
+                // Check if pack already exists
+                const existingPackRoot = path.join((0, paths_1.getAgentideDir)(workspaceRoot), paths_1.AGENT_CONSTANTS.AGENTS_DIR, normalized);
+                if (await (0, utils_1.pathExists)(existingPackRoot)) {
+                    return `A pack named "${normalized}" already exists. Choose a different name.`;
+                }
+                return undefined;
+            },
+        });
+        if (!rawPackName) {
+            return;
+        }
+        // Normalize the pack name (lowercase, hyphens, no special chars)
+        const packName = (0, paths_1.normalizePackName)(rawPackName);
+        log(outputChannel, `[AgentIDE] Pack name normalized: "${rawPackName}" -> "${packName}"`);
+        const packRoot = path.join((0, paths_1.getAgentideDir)(workspaceRoot), paths_1.AGENT_CONSTANTS.AGENTS_DIR, packName);
+        // Prompt for description
+        const description = await vscode.window.showInputBox({
+            prompt: "Enter a short description for the pack",
+            placeHolder: "e.g., Advanced code review agent with security analysis",
+        });
+        // Prompt for preferred engine
+        const engineChoice = await vscode.window.showQuickPick([
+            {
+                label: "Claude",
+                description: "Anthropic Claude Agent SDK",
+                engine: "claude",
+            },
+            { label: "Codex", description: "OpenAI Codex SDK", engine: "codex" },
+        ], {
+            placeHolder: "Select the preferred engine for this pack",
+            title: "Preferred Engine",
+        });
+        if (!engineChoice) {
+            return;
+        }
+        try {
+            await fs_1.promises.mkdir(path.join(packRoot, "rules"), { recursive: true });
+            await fs_1.promises.mkdir(path.join(packRoot, "skills"), { recursive: true });
+            await fs_1.promises.mkdir(path.join(packRoot, "mcp"), { recursive: true });
+            // Create agent.yaml manifest using centralized template
+            // Use current model if available, otherwise let the template use the default
+            const manifest = (0, paths_1.generateAgentYaml)(packName, {
+                description: description || undefined,
+                engine: engineChoice.engine,
+                model: currentModelId,
+            });
+            await fs_1.promises.writeFile(path.join(packRoot, "agent.yaml"), manifest);
+            // Create AGENTS.md using centralized template
+            const agentsMd = (0, paths_1.generateAgentsMd)(packName, {
+                description: description || undefined,
+            });
+            await fs_1.promises.writeFile(path.join(packRoot, "AGENTS.md"), agentsMd);
+            // Note: We don't sync pack-internal derived dirs (.codex/.claude) here.
+            // Those folders should only exist at workspace root level, not inside packs.
+            // The pack's content will be synced to workspace root when it's activated.
+            // Register the pack in the manifest
+            const { AgentPackManager } = await import("./agentpack/index.js");
+            const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+            await packManager.installFromLocal(packRoot);
+            log(outputChannel, `[AgentIDE] Created agent pack scaffold: ${packName}`);
+            showInfo(`AgentIDE: Created agent pack "${packName}" at ${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}/${paths_1.AGENT_CONSTANTS.AGENTS_DIR}/${packName}/`);
+            // Open the AGENTS.md file
+            const agentsMdUri = vscode.Uri.file(path.join(packRoot, "AGENTS.md"));
+            await vscode.window.showTextDocument(agentsMdUri);
+            // Offer agent-assisted configuration
+            const choice = await vscode.window.showInformationMessage(`Agent pack "${packName}" created. Would you like help generating a specialized configuration?`, "Yes, help me configure it", "No, I'll edit manually");
+            if (choice === "Yes, help me configure it") {
+                // Build a prompt that leverages the agentpack-creator skill
+                const configureQuery = [
+                    `I just created a new agent pack called "${packName}"`,
+                    description ? ` that should: ${description}.` : ".",
+                    "\n\nPlease help me write a proper AGENTS.md file for this agent. ",
+                    "Ask me clarifying questions about:\n",
+                    "1. What specific tasks this agent should excel at\n",
+                    "2. What domain expertise it should have\n",
+                    "3. What constraints or limitations it should follow\n",
+                    "4. How it should format its outputs\n\n",
+                    `The AGENTS.md file is at: ${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}/agents/${packName}/AGENTS.md`,
+                ].join("");
+                // Open chat with the query - attach the AGENTS.md file for context
+                await vscode.commands.executeCommand("workbench.action.chat.open", {
+                    query: configureQuery,
+                    isPartialQuery: false,
+                    mode: "agent",
+                    attachFiles: [agentsMdUri],
+                });
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Pack create error: ${errorMsg}`);
+            showError(`AgentIDE: Failed to create pack - ${errorMsg}`);
+        }
+    }));
+    // -------------------------------------------------------------------------
+    // Agent Stores Commands (UAL + Hydration)
+    // -------------------------------------------------------------------------
+    // Share agent to User Library
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.share", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        const packs = await packManager.listInstalledWithCleanup();
+        // Filter out default agent - can't share it
+        const shareable = packs.filter((p) => p.id !== "default");
+        if (shareable.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No agents to share (create an agent first)`);
+            return;
+        }
+        const items = shareable.map((p) => ({
+            label: p.id,
+            description: `v${p.version}`,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select an agent to share to User Library",
+            title: "Share Agent to User Library",
+        });
+        if (!selected) {
+            return;
+        }
+        try {
+            const version = await packManager.shareToUserLibrary(selected.label);
+            showInfo(`AgentIDE: Shared "${selected.label}" v${version} to User Library`);
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Share error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Share skill to User Library
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.skill.share", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const { getAgentSkillsDir, getUserSkillDir, } = await import("./agentpack/paths.js");
+        const { copyDirRecursive, pathExists } = await import("./utils.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        // Get installed packs
+        const packs = await packManager.listInstalledWithCleanup();
+        if (packs.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No agents found`);
+            return;
+        }
+        // Let user pick a pack
+        const packPick = await vscode.window.showQuickPick(packs.map((p) => ({ label: p.id, description: `v${p.version}` })), {
+            placeHolder: "Select agent containing the skill",
+            title: "Save Skill to User Library",
+        });
+        if (!packPick) {
+            return;
+        }
+        // List skills in that pack
+        const skillsDir = getAgentSkillsDir(workspaceRoot, packPick.label);
+        const skillsDirExists = await pathExists(skillsDir);
+        if (!skillsDirExists) {
+            showInfo(`AgentIDE: No skills found in ${packPick.label}`);
+            return;
+        }
+        const skillEntries = await fs_1.promises.readdir(skillsDir, { withFileTypes: true });
+        const skillDirs = skillEntries
+            .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+            .map((e) => e.name);
+        if (skillDirs.length === 0) {
+            showInfo(`AgentIDE: No skills found in ${packPick.label}`);
+            return;
+        }
+        const skillPick = await vscode.window.showQuickPick(skillDirs.map((s) => ({ label: s })), {
+            placeHolder: "Select skill to save to User Library",
+            title: "Save Skill to User Library",
+        });
+        if (!skillPick) {
+            return;
+        }
+        const sourceDir = path.join(skillsDir, skillPick.label);
+        const targetDir = getUserSkillDir(skillPick.label);
+        // Check if skill already exists in library
+        if (await pathExists(targetDir)) {
+            const overwrite = await vscode.window.showWarningMessage(`Skill "${skillPick.label}" already exists in User Library. Overwrite?`, { modal: true }, "Overwrite", "Cancel");
+            if (overwrite !== "Overwrite") {
+                return;
+            }
+            await fs_1.promises.rm(targetDir, { recursive: true, force: true });
+        }
+        try {
+            await copyDirRecursive(sourceDir, targetDir);
+            // Register in local registry
+            const { getRegistry } = await import("./registry/index.js");
+            const registry = getRegistry(outputChannel);
+            await registry.registerSkill({
+                slug: skillPick.label,
+                displayName: skillPick.label,
+                latestVersion: "local",
+                tags: [],
+                stats: { installs: 1 },
+            });
+            // Invalidate local index cache
+            const { invalidateLocalIndex } = await import("./store/oramaIndex.js");
+            invalidateLocalIndex();
+            showInfo(`AgentIDE: Saved skill "${skillPick.label}" to User Library`);
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Share skill error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Share MCP to User Library
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.mcp.share", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const { getAgentMcpDir, getUserMcpServerDir, } = await import("./agentpack/paths.js");
+        const { copyDirRecursive, pathExists } = await import("./utils.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        // Get installed packs
+        const packs = await packManager.listInstalledWithCleanup();
+        if (packs.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No agents found`);
+            return;
+        }
+        // Let user pick a pack
+        const packPick = await vscode.window.showQuickPick(packs.map((p) => ({ label: p.id, description: `v${p.version}` })), {
+            placeHolder: "Select agent containing the MCP server",
+            title: "Save MCP Server to User Library",
+        });
+        if (!packPick) {
+            return;
+        }
+        // Read .mcp.json to get configured MCP servers
+        const mcpDir = getAgentMcpDir(workspaceRoot, packPick.label);
+        const mcpJsonPath = path.join(mcpDir, ".mcp.json");
+        let mcpConfig = {
+            mcpServers: {},
+        };
+        try {
+            const content = await fs_1.promises.readFile(mcpJsonPath, "utf-8");
+            mcpConfig = JSON.parse(content);
+        }
+        catch {
+            showInfo(`AgentIDE: No MCP servers configured in ${packPick.label}`);
+            return;
+        }
+        if (!mcpConfig.mcpServers ||
+            Object.keys(mcpConfig.mcpServers).length === 0) {
+            showInfo(`AgentIDE: No MCP servers configured in ${packPick.label}`);
+            return;
+        }
+        const mcpNames = Object.keys(mcpConfig.mcpServers);
+        const mcpPick = await vscode.window.showQuickPick(mcpNames.map((m) => ({ label: m })), {
+            placeHolder: "Select MCP server to save to User Library",
+            title: "Save MCP Server to User Library",
+        });
+        if (!mcpPick) {
+            return;
+        }
+        const targetDir = getUserMcpServerDir(mcpPick.label);
+        // Check if MCP already exists in library
+        if (await pathExists(targetDir)) {
+            const overwrite = await vscode.window.showWarningMessage(`MCP "${mcpPick.label}" already exists in User Library. Overwrite?`, { modal: true }, "Overwrite", "Cancel");
+            if (overwrite !== "Overwrite") {
+                return;
+            }
+            await fs_1.promises.rm(targetDir, { recursive: true, force: true });
+        }
+        try {
+            await fs_1.promises.mkdir(targetDir, { recursive: true });
+            // Save the MCP config as mcp.json
+            const mcpServerConfig = mcpConfig.mcpServers[mcpPick.label];
+            await fs_1.promises.writeFile(path.join(targetDir, "mcp.json"), JSON.stringify({
+                name: mcpPick.label,
+                ...mcpServerConfig,
+            }, null, 2));
+            // Copy any additional files from the MCP subdirectory if it exists
+            const mcpSubDir = path.join(mcpDir, mcpPick.label);
+            if (await pathExists(mcpSubDir)) {
+                await copyDirRecursive(mcpSubDir, targetDir);
+            }
+            // Register in local registry
+            const { getRegistry } = await import("./registry/index.js");
+            const registry = getRegistry(outputChannel);
+            await registry.registerMcp({
+                slug: mcpPick.label,
+                displayName: mcpPick.label,
+                transport: mcpServerConfig.transport || "stdio",
+                latestVersion: "local",
+                tags: [],
+                stats: { installs: 1 },
+            });
+            // Invalidate local index cache
+            const { invalidateLocalIndex } = await import("./store/oramaIndex.js");
+            invalidateLocalIndex();
+            showInfo(`AgentIDE: Saved MCP "${mcpPick.label}" to User Library`);
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Share MCP error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Publish agent to store (fork → PR workflow)
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.publish", async () => {
+        await (0, githubStoreGate_js_1.ensureGitHubStoreAccess)(context);
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager, validateForPublish } = await import("./agentpack/index.js");
+        const { publishToStore, STORE_CONFIG } = await import("./store/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        const packs = await packManager.listInstalledWithCleanup();
+        const publishable = packs.filter((p) => p.id !== "default");
+        if (publishable.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No agents to publish (create an agent first)`);
+            return;
+        }
+        // Select pack
+        const selectedPack = await vscode.window.showQuickPick(publishable.map((p) => ({
+            label: p.id,
+            description: `v${p.version}`,
+        })), {
+            placeHolder: "Select an agent pack to publish",
+            title: `Publish to ${STORE_CONFIG.owner}/${STORE_CONFIG.repo}`,
+        });
+        if (!selectedPack) {
+            return;
+        }
+        // Validate before publishing
+        const validation = await validateForPublish(workspaceRoot, selectedPack.label);
+        if (!validation.valid) {
+            showError(`AgentIDE: Cannot publish - ${validation.errors.join(", ")}`);
+            return;
+        }
+        if (validation.warnings.length > 0) {
+            const proceed = await vscode.window.showWarningMessage(`Warnings: ${validation.warnings.join(", ")}`, "Publish Anyway", "Cancel");
+            if (proceed !== "Publish Anyway") {
+                return;
+            }
+        }
+        // Changelog
+        const changelog = await vscode.window.showInputBox({
+            prompt: "What changed in this version? (optional)",
+            placeHolder: "Added new features, fixed bugs...",
+        });
+        // Collect files
+        const { getAgentRoot } = await import("./agentpack/paths.js");
+        const agentRoot = getAgentRoot(workspaceRoot, selectedPack.label);
+        const files = [];
+        async function collectFiles(dir, prefix) {
+            const entries = await fs_1.promises.readdir(dir);
+            for (const entry of entries) {
+                if (entry.startsWith(".")) {
+                    continue;
+                }
+                const fullPath = path.join(dir, entry);
+                const relativePath = prefix ? `${prefix}/${entry}` : entry;
+                const stat = await fs_1.promises.stat(fullPath);
+                if (stat.isDirectory()) {
+                    await collectFiles(fullPath, relativePath);
+                }
+                else {
+                    const content = await fs_1.promises.readFile(fullPath, "utf-8");
+                    files.push({ path: relativePath, content });
+                }
+            }
+        }
+        await collectFiles(agentRoot, "");
+        const pack = publishable.find((p) => p.id === selectedPack.label);
+        // Confirm
+        const confirm = await vscode.window.showWarningMessage(`Submit "${pack.id}" v${pack.version} to ${STORE_CONFIG.owner}/${STORE_CONFIG.repo}?\n\nThis will create a pull request.`, { modal: true }, "Submit PR");
+        if (confirm !== "Submit PR") {
+            return;
+        }
+        try {
+            const result = await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Window,
+                title: `Publishing ${pack.id} v${pack.version}`,
+                cancellable: false,
+            }, async (progress) => {
+                progress.report({ message: "Preparing fork..." });
+                const res = await publishToStore({
+                    type: "pack",
+                    slug: pack.id,
+                    version: pack.version,
+                    files,
+                    changelog,
+                }, outputChannel);
+                progress.report({ message: "Creating PR..." });
+                return res;
+            });
+            const viewAction = await vscode.window.showInformationMessage(`Created PR #${result.prNumber} for ${pack.id} v${pack.version}`, "View PR");
+            if (viewAction === "View PR") {
+                vscode.env.openExternal(vscode.Uri.parse(result.prUrl));
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Publish error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Install agent from GitHub
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.installFromGitHub", async (sourceArg) => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { installFromGitHub } = await import("./agentpack/index.js");
+        // Get source from arg or prompt
+        let source = sourceArg;
+        if (!source) {
+            source = await vscode.window.showInputBox({
+                prompt: "Enter GitHub repository URL or owner/repo",
+                placeHolder: "e.g., user/my-agent-pack or github://user/pack@v1.0.0",
+                validateInput: (value) => {
+                    if (!value.trim()) {
+                        return "Please enter a repository";
+                    }
+                    if (!value.includes("/")) {
+                        return "Expected format: owner/repo or github://owner/repo@version";
+                    }
+                    return null;
+                },
+            });
+        }
+        if (!source) {
+            return;
+        }
+        try {
+            const result = await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Window,
+                title: "Installing from GitHub",
+                cancellable: false,
+            }, async (progress) => {
+                progress.report({ message: "Downloading..." });
+                return await installFromGitHub(workspaceRoot, {
+                    source,
+                    force: false,
+                }, outputChannel);
+            });
+            // Refresh pack list
+            await vscode.commands.executeCommand("agentide.packsChanged");
+            await syncService.seedAgentDataIfNeeded(workspaceRoot, result.agentId, outputChannel);
+            const activateAction = await vscode.window.showInformationMessage(`Installed ${result.agentId} ${result.version}!`, "Activate");
+            if (activateAction === "Activate") {
+                await vscode.commands.executeCommand("agentide.pack.switch", result.agentId);
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            // Check if it's "already exists" error
+            if (errorMsg.includes("already exists")) {
+                const overwrite = await vscode.window.showWarningMessage(errorMsg, "Overwrite", "Cancel");
+                if (overwrite === "Overwrite") {
+                    try {
+                        const result = await vscode.window.withProgress({
+                            location: vscode.ProgressLocation.Window,
+                            title: "Installing from GitHub",
+                            cancellable: false,
+                        }, async (progress) => {
+                            progress.report({ message: "Downloading..." });
+                            return await installFromGitHub(workspaceRoot, {
+                                source,
+                                force: true,
+                            }, outputChannel);
+                        });
+                        await vscode.commands.executeCommand("agentide.packsChanged");
+                        await syncService.seedAgentDataIfNeeded(workspaceRoot, result.agentId, outputChannel);
+                        showInfo(`AgentIDE: Installed ${result.agentId} ${result.version}`);
+                    }
+                    catch (e2) {
+                        const errorMsg2 = e2 instanceof Error ? e2.message : String(e2);
+                        showError(`AgentIDE: ${errorMsg2}`);
+                    }
+                }
+            }
+            else {
+                log(outputChannel, `[AgentIDE] Install error: ${errorMsg}`);
+                showError(`AgentIDE: ${errorMsg}`);
+            }
+        }
+    }));
+    // Browse User Library
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.browseLibrary", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        const agents = await packManager.listUserLibrary();
+        if (agents.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: User Library is empty. Share agents with "${branding_1.AGENTIDE_BRAND_NAME}: Share Agent to User Library"`);
+            return;
+        }
+        const items = agents.map((a) => ({
+            label: a.id,
+            description: a.currentVersion
+                ? `v${a.currentVersion}`
+                : `${a.versions.length} version(s)`,
+            detail: a.description ||
+                `Preferred engine: ${a.preferredEngine || "unknown"}`,
+            agentId: a.id,
+            currentVersion: a.currentVersion,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select an agent to install",
+            title: "User Agent Library",
+        });
+        if (!selected) {
+            return;
+        }
+        // Offer to install
+        const action = await vscode.window.showQuickPick([
+            { label: "Install to Workspace", action: "install" },
+            { label: "Cancel", action: "cancel" },
+        ], {
+            placeHolder: `What would you like to do with "${selected.agentId}"?`,
+        });
+        if (action?.action !== "install") {
+            return;
+        }
+        try {
+            const result = await packManager.installAgentToWorkspace(selected.agentId);
+            if (result.installed) {
+                const msg = result.hydrated
+                    ? `Installed "${selected.agentId}" v${result.version} to workspace from User Library`
+                    : `"${selected.agentId}" is already installed in this workspace`;
+                showInfo(`AgentIDE: ${msg}`);
+            }
+            else {
+                showError(`AgentIDE: Failed to install "${selected.agentId}"`);
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Install error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Publish skill to GitHub
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.skill.publish", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        // Find skills in current workspace
+        const skillsDir = path.join(workspaceRoot, ".agent-hippo", "agents");
+        const skills = [];
+        if (await (0, utils_1.pathExists)(skillsDir)) {
+            // Look for SKILL.md in agent packs
+            const agents = await fs_1.promises.readdir(skillsDir);
+            for (const agent of agents) {
+                const agentSkillsDir = path.join(skillsDir, agent, "skills");
+                if (await (0, utils_1.pathExists)(agentSkillsDir)) {
+                    const skillFolders = await fs_1.promises.readdir(agentSkillsDir);
+                    for (const skill of skillFolders) {
+                        const skillPath = path.join(agentSkillsDir, skill);
+                        const skillMd = path.join(skillPath, "SKILL.md");
+                        if (await (0, utils_1.pathExists)(skillMd)) {
+                            skills.push({ name: skill, path: skillPath });
+                        }
+                    }
+                }
+            }
+        }
+        if (skills.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No skills found. Create a skill with SKILL.md in your agent's skills/ folder.`);
+            return;
+        }
+        // Select skill
+        const selected = await vscode.window.showQuickPick(skills.map((s) => ({ label: s.name, path: s.path })), { placeHolder: "Select a skill to publish" });
+        if (!selected) {
+            return;
+        }
+        try {
+            const { validateSkillForPublish, collectSkillFiles } = await import("./skills/publish.js");
+            const { publishToStore } = await import("./store/index.js");
+            const validation = await validateSkillForPublish(selected.path);
+            if (!validation.valid) {
+                showError(`AgentIDE: ${validation.errors.join(", ")}`);
+                return;
+            }
+            // Get version (optional for skills)
+            const version = validation.metadata?.version ||
+                (await vscode.window.showInputBox({
+                    prompt: "Version (semver)",
+                    placeHolder: "e.g., 1.0.0",
+                    validateInput: (v) => /^\d+\.\d+\.\d+/.test(v)
+                        ? null
+                        : "Use semver format (e.g., 1.0.0)",
+                }));
+            if (!version) {
+                return;
+            }
+            // Collect files
+            const files = await collectSkillFiles(selected.path);
+            // Publish to store via fork + PR with progress
+            const result = await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Window,
+                title: `Publishing skill "${selected.label}"`,
+                cancellable: false,
+            }, async (progress) => {
+                progress.report({ message: "Preparing fork..." });
+                const res = await publishToStore({
+                    type: "skill",
+                    slug: selected.label,
+                    version,
+                    files,
+                }, outputChannel);
+                progress.report({ message: "Creating PR..." });
+                return res;
+            });
+            // Register in local registry
+            const { getRegistry } = await import("./registry/index.js");
+            const { STORE_CONFIG } = await import("./store/index.js");
+            const registry = getRegistry(outputChannel);
+            await registry.registerSkill({
+                slug: selected.label,
+                displayName: validation.metadata?.name || selected.label,
+                description: validation.metadata?.description,
+                github: { owner: STORE_CONFIG.owner, repo: STORE_CONFIG.repo },
+                latestVersion: version,
+                tags: validation.metadata?.tags || [],
+                stats: { installs: 0 },
+            });
+            const viewAction = await vscode.window.showInformationMessage(`Published skill "${selected.label}" v${version}! PR created.`, "View PR");
+            if (viewAction === "View PR") {
+                vscode.env.openExternal(vscode.Uri.parse(result.prUrl));
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Skill publish error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Publish MCP server to store
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.mcp.publish", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        // Find MCP configs in current workspace
+        const agentsDir = path.join(workspaceRoot, ".agentide", "agents");
+        const mcpConfigs = [];
+        if (await (0, utils_1.pathExists)(agentsDir)) {
+            const agents = await fs_1.promises.readdir(agentsDir);
+            for (const agent of agents) {
+                const mcpDir = path.join(agentsDir, agent, "mcp");
+                const mcpConfigPath = path.join(mcpDir, ".mcp.json");
+                if (await (0, utils_1.pathExists)(mcpConfigPath)) {
+                    try {
+                        const content = await fs_1.promises.readFile(mcpConfigPath, "utf-8");
+                        const config = JSON.parse(content);
+                        // Each MCP config can have multiple servers
+                        if (config.mcpServers) {
+                            for (const serverName of Object.keys(config.mcpServers)) {
+                                mcpConfigs.push({
+                                    name: serverName,
+                                    agentId: agent,
+                                    configPath: mcpConfigPath,
+                                    mcpDir,
+                                });
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip invalid configs
+                    }
+                }
+            }
+        }
+        if (mcpConfigs.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No MCP servers found. Add MCP servers to your agent's mcp/.mcp.json file.`);
+            return;
+        }
+        // Select MCP server
+        const selected = await vscode.window.showQuickPick(mcpConfigs.map((m) => ({
+            label: m.name,
+            description: `from ${m.agentId}`,
+            detail: m.configPath,
+            config: m,
+        })), { placeHolder: "Select an MCP server to publish" });
+        if (!selected) {
+            return;
+        }
+        try {
+            const { publishToStore, STORE_CONFIG } = await import("./store/index.js");
+            const { collectMcpFiles, validateMcpConfig } = await import("./mcp/publish.js");
+            const { getRegistry } = await import("./registry/index.js");
+            // Read the full config
+            const configContent = await fs_1.promises.readFile(selected.config.configPath, "utf-8");
+            const fullConfig = JSON.parse(configContent);
+            const serverConfig = fullConfig.mcpServers[selected.config.name];
+            // Validate
+            const validation = validateMcpConfig({
+                name: selected.config.name,
+                version: serverConfig.version || "1.0.0",
+                description: serverConfig.description,
+                transport: serverConfig.transport || "stdio",
+                command: serverConfig.command,
+                args: serverConfig.args,
+                env: serverConfig.env,
+                url: serverConfig.url,
+                npmPackage: serverConfig.npmPackage,
+            });
+            if (!validation.valid) {
+                showError(`AgentIDE: ${validation.errors.join(", ")}`);
+                return;
+            }
+            // Get version (if not in config)
+            const version = serverConfig.version ||
+                (await vscode.window.showInputBox({
+                    prompt: "Version (semver)",
+                    placeHolder: "e.g., 1.0.0",
+                    value: "1.0.0",
+                    validateInput: (v) => /^\d+\.\d+\.\d+/.test(v)
+                        ? null
+                        : "Use semver format (e.g., 1.0.0)",
+                }));
+            if (!version) {
+                return;
+            }
+            // Get description if missing
+            let description = serverConfig.description;
+            if (!description) {
+                description = await vscode.window.showInputBox({
+                    prompt: "Description (required)",
+                    placeHolder: "What does this MCP server do?",
+                });
+                if (!description) {
+                    showError(`${branding_1.AGENTIDE_BRAND_NAME}: Description is required`);
+                    return;
+                }
+            }
+            // Collect files from MCP directory
+            const files = await collectMcpFiles(selected.config.mcpDir);
+            // Add/update mcp.json manifest
+            const manifest = {
+                name: selected.config.name,
+                version,
+                description,
+                transport: serverConfig.transport || "stdio",
+                command: serverConfig.command,
+                args: serverConfig.args,
+                env: serverConfig.env,
+                url: serverConfig.url,
+                npmPackage: serverConfig.npmPackage,
+            };
+            // Remove undefined fields
+            const cleanManifest = JSON.parse(JSON.stringify(manifest));
+            files.push({
+                path: "mcp.json",
+                content: JSON.stringify(cleanManifest, null, 2),
+            });
+            // Publish to store via fork + PR with progress
+            const result = await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Window,
+                title: `Publishing MCP "${selected.config.name}"`,
+                cancellable: false,
+            }, async (progress) => {
+                progress.report({ message: "Preparing fork..." });
+                const res = await publishToStore({
+                    type: "mcp",
+                    slug: selected.config.name,
+                    version,
+                    files,
+                }, outputChannel);
+                progress.report({ message: "Creating PR..." });
+                return res;
+            });
+            // Register in local registry
+            const registry = getRegistry(outputChannel);
+            await registry.registerMcp({
+                slug: selected.config.name,
+                displayName: selected.config.name,
+                description,
+                transport: (serverConfig.transport || "stdio"),
+                github: { owner: STORE_CONFIG.owner, repo: STORE_CONFIG.repo },
+                latestVersion: version,
+                tags: [],
+                stats: { installs: 0 },
+            });
+            const viewAction = await vscode.window.showInformationMessage(`Published MCP "${selected.config.name}" v${version}! PR created.`, "View PR");
+            if (viewAction === "View PR") {
+                vscode.env.openExternal(vscode.Uri.parse(result.prUrl));
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] MCP publish error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Publish Spotlight view to store
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.spotlight.publish", async (viewIdArg, publishOptions) => {
+        const bundleMode = publishOptions?.bundle === "scripts-only" ? "scripts-only" : "full";
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { collectViewFiles, discoverPublishableViews, validateViewForPublish, } = await import("./spotlight/publish.js");
+        const { publishToStore, STORE_CONFIG, canPublishDirectlyToStore } = await import("./store/index.js");
+        const { isValidPublishVersion } = await import("./engines/publish.js");
+        const views = await discoverPublishableViews(workspaceRoot);
+        if (views.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No publishable Spotlight views found. Create a view under .agent-hippo/analytics and register it in panel/views.yaml.`);
+            return;
+        }
+        const requestedViewId = typeof viewIdArg === "string" ? viewIdArg.trim() : "";
+        let selectedView = requestedViewId
+            ? views.find((view) => view.id === requestedViewId)
+            : undefined;
+        if (requestedViewId && !selectedView) {
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: View "${requestedViewId}" is not publishable. Add widget scripts under .agent-hippo/analytics/views/${requestedViewId}/scripts and register the view in panel/views.yaml.`);
+            return;
+        }
+        if (!selectedView) {
+            const selected = await vscode.window.showQuickPick(views.map((view) => ({
+                label: view.name,
+                description: view.id,
+                detail: `${view.sourceLabel} • ${view.scope} • ${view.scripts.length} script(s)`,
+                view,
+            })), {
+                placeHolder: "Select a Spotlight view to publish",
+                title: `Publish to ${STORE_CONFIG.owner}/${STORE_CONFIG.repo}`,
+            });
+            if (!selected) {
+                return;
+            }
+            selectedView = selected.view;
+        }
+        try {
+            const validation = await validateViewForPublish(selectedView, {
+                expectedId: selectedView.id,
+                mode: bundleMode,
+            });
+            if (!validation.valid) {
+                showError(`${branding_1.AGENTIDE_BRAND_NAME}: Cannot publish - ${validation.errors.join(", ")}`);
+                return;
+            }
+            if (validation.warnings.length > 0) {
+                const proceed = await vscode.window.showWarningMessage(`Warnings: ${validation.warnings.join(", ")}`, "Publish Anyway", "Cancel");
+                if (proceed !== "Publish Anyway") {
+                    return;
+                }
+            }
+            const versionInput = await vscode.window.showInputBox({
+                prompt: "Publish version (semver)",
+                value: validation.metadata?.publishVersion || "1.0.0",
+                placeHolder: "e.g., 1.0.0",
+                validateInput: (value) => value && isValidPublishVersion(value.replace(/^v/, ""))
+                    ? null
+                    : "Use semver format (e.g., 1.0.0)",
+            });
+            if (!versionInput || !validation.metadata) {
+                return;
+            }
+            const version = versionInput.replace(/^v/, "");
+            const changelog = await vscode.window.showInputBox({
+                prompt: "What changed in this version? (optional)",
+                placeHolder: "Initial release, new widgets...",
+            });
+            const files = await collectViewFiles(selectedView, version, validation.metadata, bundleMode);
+            const bundleLabel = bundleMode === "full"
+                ? "full bundle (scripts + assets + charts/exports)"
+                : "scripts only";
+            const publishDirect = await canPublishDirectlyToStore();
+            const confirm = await vscode.window.showWarningMessage(publishDirect
+                ? `Publish Spotlight view "${selectedView.id}" v${version} (${bundleLabel}) to ${STORE_CONFIG.owner}/${STORE_CONFIG.repo}?\n\nThis will open a pull request on the store repository.`
+                : `Submit Spotlight view "${selectedView.id}" v${version} (${bundleLabel}) to ${STORE_CONFIG.owner}/${STORE_CONFIG.repo}?\n\nThis will create a pull request from your fork.`, { modal: true }, "Submit PR");
+            if (confirm !== "Submit PR") {
+                return;
+            }
+            const result = await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Window,
+                title: `Publishing Spotlight view ${selectedView.id} v${version}`,
+                cancellable: false,
+            }, async (progress) => {
+                progress.report({
+                    message: publishDirect
+                        ? `Publishing to ${STORE_CONFIG.owner}/${STORE_CONFIG.repo}...`
+                        : "Preparing fork...",
+                });
+                return await publishToStore({
+                    type: "view",
+                    slug: selectedView.id,
+                    version,
+                    files,
+                    changelog,
+                }, outputChannel);
+            });
+            const viewAction = await vscode.window.showInformationMessage(`Published Spotlight view "${selectedView.name}" v${version}! PR created.`, "View PR");
+            if (viewAction === "View PR") {
+                vscode.env.openExternal(vscode.Uri.parse(result.prUrl));
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Spotlight publish error: ${errorMsg}`);
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: ${errorMsg}`);
+        }
+    }));
+    // Install from store (routes based on artifact type)
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.store.install", async (urlArg) => {
+        await (0, githubStoreGate_js_1.ensureGitHubStoreAccess)(context);
+        const { parseStoreUrl } = await import("./store/index.js");
+        // Get URL from arg or prompt
+        let url = urlArg;
+        if (!url) {
+            url = await vscode.window.showInputBox({
+                prompt: "Enter store URL or GitHub link",
+                placeHolder: "e.g., engine/gemini or https://github.com/.../engines/gemini",
+                validateInput: (value) => {
+                    if (!value.trim()) {
+                        return "Please enter a URL";
+                    }
+                    // Allow GitHub URLs or path-based URLs
+                    if (!value.includes("/")) {
+                        return "Expected: type/slug, or GitHub URL";
+                    }
+                    return null;
+                },
+            });
+        }
+        if (!url) {
+            return;
+        }
+        try {
+            const artifact = parseStoreUrl(url);
+            // Route to appropriate install command based on type
+            switch (artifact.type) {
+                case "pack":
+                    await vscode.commands.executeCommand("agentide.pack.storeInstall", artifact);
+                    break;
+                case "skill":
+                    await vscode.commands.executeCommand("agentide.skill.install", artifact);
+                    break;
+                case "mcp":
+                    await vscode.commands.executeCommand("agentide.mcp.install", artifact);
+                    break;
+                case "engine":
+                    await vscode.commands.executeCommand("agentide.engine.install", artifact);
+                    break;
+                case "view":
+                    await vscode.commands.executeCommand("agentide.view.install", artifact);
+                    break;
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Store install error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Browse store - unified install command
+    // If URL provided: direct install (detects type automatically)
+    // If no URL: interactive picker with Orama-powered search
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.store.find", async (arg) => {
+        await (0, githubStoreGate_js_1.ensureGitHubStoreAccess)(context);
+        const { isStoreUrl, parseStoreUrl, parseGitHubUrl, detectArtifactType, } = await import("./store/index.js");
+        const { searchMerged, listMergedArtifacts } = await import("./store/oramaIndex.js");
+        let urlArg;
+        let initialTypeFilter = "all";
+        if (typeof arg === "string") {
+            urlArg = arg;
+        }
+        else if (arg && typeof arg === "object" && arg.typeFilter) {
+            initialTypeFilter = arg.typeFilter;
+        }
+        // If URL provided, do direct install
+        if (urlArg) {
+            try {
+                let type;
+                let slug;
+                let version;
+                if (isStoreUrl(urlArg)) {
+                    // Store URL - parse type from path prefix
+                    const parsed = parseStoreUrl(urlArg);
+                    type = parsed.type;
+                    slug = parsed.slug;
+                    version = parsed.version;
+                }
+                else {
+                    // Generic GitHub URL - detect type from marker files
+                    const ghParsed = parseGitHubUrl(urlArg);
+                    type = await vscode.window.withProgress({
+                        location: vscode.ProgressLocation.Notification,
+                        title: "Detecting artifact type...",
+                        cancellable: false,
+                    }, async () => {
+                        return await detectArtifactType(ghParsed.owner, ghParsed.repo, ghParsed.ref, ghParsed.path, outputChannel);
+                    });
+                    // Extract just the last part of the path as the slug name
+                    const pathParts = (ghParsed.path || ghParsed.repo).split("/");
+                    slug = pathParts[pathParts.length - 1] || ghParsed.repo;
+                    version = ghParsed.ref;
+                }
+                // Route to appropriate install command
+                switch (type) {
+                    case "pack":
+                        await vscode.commands.executeCommand("agentide.pack.storeInstall", {
+                            type: "pack",
+                            slug,
+                            version,
+                            sourceUrl: urlArg, // Pass original URL for non-store installs
+                        });
+                        break;
+                    case "skill":
+                        await vscode.commands.executeCommand("agentide.skill.install", {
+                            type: "skill",
+                            slug,
+                            version,
+                            sourceUrl: urlArg,
+                        });
+                        break;
+                    case "mcp":
+                        await vscode.commands.executeCommand("agentide.mcp.install", {
+                            type: "mcp",
+                            slug,
+                            version,
+                            sourceUrl: urlArg,
+                        });
+                        break;
+                    case "engine":
+                        await vscode.commands.executeCommand("agentide.engine.install", {
+                            type: "engine",
+                            slug,
+                            version,
+                            sourceUrl: urlArg,
+                        });
+                        break;
+                    case "view":
+                        await vscode.commands.executeCommand("agentide.view.install", {
+                            type: "view",
+                            slug,
+                            version,
+                            sourceUrl: urlArg,
+                        });
+                        break;
+                }
+                return;
+            }
+            catch (e) {
+                const errorMsg = e instanceof Error ? e.message : String(e);
+                log(outputChannel, `[AgentIDE] Install error: ${errorMsg}`);
+                showError(`AgentIDE: ${errorMsg}`);
+                return;
+            }
+        }
+        // No URL - show interactive picker
+        // Import shared icons (consistent with CLI)
+        const { STORE_ICONS } = await import("./store/shared.js");
+        const typeIcons = {
+            pack: STORE_ICONS.pack,
+            skill: STORE_ICONS.skill,
+            mcp: STORE_ICONS.mcp,
+            engine: STORE_ICONS.engine,
+            view: STORE_ICONS.view,
+        };
+        const typeFilters = ["all", "pack", "skill", "mcp", "engine", "view"];
+        // Create interactive QuickPick
+        const quickPick = vscode.window.createQuickPick();
+        quickPick.title =
+            initialTypeFilter === "view"
+                ? "Install Spotlight View"
+                : "Install Packs, Skills, MCP Tools, Engines, Spotlight Views";
+        quickPick.placeholder = "Search or paste a GitHub URL to install...";
+        quickPick.matchOnDescription = true;
+        quickPick.matchOnDetail = true;
+        quickPick.busy = true;
+        let allItems = [];
+        let currentFilter = initialTypeFilter;
+        let searchDebounceTimer;
+        // Source icons for Local/Remote display (from shared)
+        const sourceIcons = {
+            local: STORE_ICONS.local,
+            remote: STORE_ICONS.remote,
+        };
+        const updateItems = (items) => {
+            const itemsToShow = items ?? allItems;
+            const filtered = currentFilter === "all"
+                ? itemsToShow
+                : itemsToShow.filter((item) => item.type === currentFilter);
+            // Filter header buttons
+            const filterButtons = typeFilters.map((f) => ({
+                label: f === "all"
+                    ? "$(list-flat) All"
+                    : `${typeIcons[f]} ${f.charAt(0).toUpperCase() + f.slice(1)}s`,
+                description: f === currentFilter ? "$(check)" : "",
+                alwaysShow: true,
+                itemType: "filter",
+                filter: f,
+            }));
+            // Artifact items - show source icon (Local/Remote) and installed badge
+            const artifactItems = filtered.map((item) => {
+                const sourceIcon = item.source === "local" ? sourceIcons.local : sourceIcons.remote;
+                const installedBadge = item.installed ? "$(check)" : "";
+                // Build description: source + type + installed badge
+                const descParts = [
+                    item.source === "local" ? "Local" : "Remote",
+                    item.type,
+                ];
+                if (installedBadge) {
+                    descParts.push(installedBadge);
+                }
+                // Build detail: description + installed packs info
+                let detail = item.description || item.path;
+                if (item.installedTo && item.installedTo.length > 0) {
+                    detail += ` • Installed to: ${item.installedTo.join(", ")}`;
+                }
+                return {
+                    label: `${sourceIcon} ${typeIcons[item.type]} ${item.slug}`,
+                    description: descParts.join(" • "),
+                    detail,
+                    itemType: "artifact",
+                    artifact: item,
+                };
+            });
+            quickPick.items = [
+                ...filterButtons,
+                {
+                    label: "",
+                    kind: vscode.QuickPickItemKind.Separator,
+                    itemType: "filter",
+                },
+                ...artifactItems,
+            ];
+        };
+        // Live search handler using Orama
+        const handleSearch = async (query) => {
+            if (searchDebounceTimer) {
+                clearTimeout(searchDebounceTimer);
+            }
+            const trimmedQuery = query.trim();
+            // If empty query or looks like URL, show all items
+            if (!trimmedQuery ||
+                trimmedQuery.startsWith("http") ||
+                trimmedQuery.startsWith("store://") ||
+                trimmedQuery.startsWith("github.com")) {
+                updateItems(allItems);
+                return;
+            }
+            // Debounce search
+            searchDebounceTimer = setTimeout(async () => {
+                try {
+                    const typeFilter = currentFilter === "all"
+                        ? undefined
+                        : currentFilter;
+                    const results = await searchMerged(trimmedQuery, { type: typeFilter, limit: 50 }, outputChannel);
+                    const searchItems = results.map((r) => ({
+                        type: r.type,
+                        slug: r.slug,
+                        path: `${r.type}s/${r.slug}`,
+                        description: r.description,
+                        installed: r.installed,
+                        installedVersion: r.installedVersion,
+                        source: r.source,
+                        installedTo: r.installedTo,
+                    }));
+                    updateItems(searchItems);
+                }
+                catch (e) {
+                    // Fall back to showing all items on search error
+                    log(outputChannel, `[AgentIDE] Search error: ${e instanceof Error ? e.message : String(e)}`);
+                    updateItems(allItems);
+                }
+            }, 150); // 150ms debounce
+        };
+        // Listen for input changes for live search
+        quickPick.onDidChangeValue(handleSearch);
+        // Load items from store using merged Orama index (local + remote)
+        try {
+            const storeItems = await listMergedArtifacts(undefined, outputChannel);
+            // Map to expected format - includes installed status, source, and installedTo
+            allItems = storeItems.map((item) => ({
+                type: item.type,
+                slug: item.slug,
+                path: `${item.type}s/${item.slug}`,
+                description: item.description,
+                installed: item.installed,
+                installedVersion: item.installedVersion,
+                source: item.source,
+                installedTo: item.installedTo,
+            }));
+            quickPick.busy = false;
+            updateItems();
+            if (allItems.length === 0) {
+                quickPick.placeholder =
+                    "Store is empty or index not synced yet. Try again later!";
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Store browse error: ${errorMsg}`);
+            quickPick.hide();
+            showError(`AgentIDE: ${errorMsg}`);
+            return;
+        }
+        // Helper to check if input looks like a URL
+        const looksLikeUrl = (input) => {
+            const trimmed = input.trim();
+            return (trimmed.startsWith("https://") ||
+                trimmed.startsWith("http://") ||
+                trimmed.startsWith("github.com/") ||
+                trimmed.startsWith("store://"));
+        };
+        // Handle selection or URL input
+        quickPick.onDidAccept(async () => {
+            const selected = quickPick.selectedItems[0];
+            const inputValue = quickPick.value.trim();
+            // Check if input looks like a URL FIRST - prioritize URL over selection
+            if (inputValue && looksLikeUrl(inputValue)) {
+                quickPick.hide();
+                log(outputChannel, `[AgentIDE] Browse Store: detected URL input: ${inputValue}`);
+                // Re-run the command with the URL
+                await vscode.commands.executeCommand("agentide.store.find", inputValue);
+                return;
+            }
+            if (!selected) {
+                return;
+            }
+            // Handle filter selection
+            if (selected.itemType === "filter" && selected.filter) {
+                currentFilter = selected.filter;
+                updateItems();
+                return;
+            }
+            // Handle artifact selection
+            if (selected.itemType === "artifact" && selected.artifact) {
+                quickPick.hide();
+                const { artifact } = selected;
+                switch (artifact.type) {
+                    case "pack":
+                        await vscode.commands.executeCommand("agentide.pack.storeInstall", {
+                            type: "pack",
+                            slug: artifact.slug,
+                        });
+                        break;
+                    case "skill":
+                        await vscode.commands.executeCommand("agentide.skill.install", {
+                            type: "skill",
+                            slug: artifact.slug,
+                        });
+                        break;
+                    case "mcp":
+                        await vscode.commands.executeCommand("agentide.mcp.install", {
+                            type: "mcp",
+                            slug: artifact.slug,
+                        });
+                        break;
+                    case "engine":
+                        await vscode.commands.executeCommand("agentide.engine.install", {
+                            type: "engine",
+                            slug: artifact.slug,
+                        });
+                        break;
+                    case "view":
+                        await vscode.commands.executeCommand("agentide.view.install", {
+                            type: "view",
+                            slug: artifact.slug,
+                        });
+                        break;
+                }
+            }
+        });
+        quickPick.onDidHide(() => quickPick.dispose());
+        quickPick.show();
+    }));
+    // Store search API - for agent skill scripts to search without UI
+    // Returns merged results from both local library and remote store
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.store.search", async (query, options) => {
+        const { searchMerged } = await import("./store/oramaIndex.js");
+        return searchMerged(query, options, outputChannel);
+    }));
+    // Store sync API - force refresh the store index
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.store.sync", async () => {
+        const { forceRefresh, getIndexMeta } = await import("./store/oramaIndex.js");
+        await vscode.window.withProgress({
+            location: vscode.ProgressLocation.Notification,
+            title: "Syncing store index...",
+            cancellable: false,
+        }, async () => {
+            await forceRefresh(outputChannel);
+        });
+        const meta = await getIndexMeta();
+        if (meta) {
+            void showInfo(`Store index synced: ${meta.artifactCount} artifacts (updated ${new Date(meta.generatedAt).toLocaleDateString()})`);
+        }
+    }));
+    // Store setup - automate store index in a GitHub repo
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.store.setup", async () => {
+        const { setupStoreAutomation } = await import("./store/github/setup.js");
+        // Get repo URL from user
+        const repoUrl = await vscode.window.showInputBox({
+            prompt: "Enter GitHub repository URL for your store",
+            placeHolder: "https://github.com/owner/repo or owner/repo",
+            validateInput: (value) => {
+                if (!value) {
+                    return "Repository URL is required";
+                }
+                const match = value.match(/(?:github\.com\/)?([^/]+)\/([^/]+)/);
+                if (!match) {
+                    return "Invalid format. Use: owner/repo or https://github.com/owner/repo";
+                }
+                return null;
+            },
+        });
+        if (!repoUrl) {
+            return;
+        }
+        const match = repoUrl.match(/(?:github\.com\/)?([^/]+)\/([^/]+)/);
+        if (!match) {
+            void showError("Invalid repository URL");
+            return;
+        }
+        const [, owner, repo] = match;
+        const cleanRepo = repo.replace(/\.git$/, "");
+        const result = await vscode.window.withProgress({
+            location: vscode.ProgressLocation.Notification,
+            title: `Setting up store automation for ${owner}/${cleanRepo}...`,
+            cancellable: false,
+        }, async () => {
+            return await setupStoreAutomation(owner, cleanRepo, outputChannel);
+        });
+        if (result.success && result.pullRequestUrl) {
+            // Update store configuration to use this repo for publish/find
+            const storeConfig = vscode.workspace.getConfiguration("agentide");
+            const newStoreRepo = `${owner}/${cleanRepo}`;
+            const currentStoreRepo = storeConfig.get("storeRepo", "");
+            const currentIndexUrl = storeConfig.get("store.indexUrl", "");
+            const newIndexUrl = `https://${owner}.github.io/${cleanRepo}`;
+            let currentDefaultIndexUrl = "";
+            if (currentStoreRepo) {
+                const matchStore = currentStoreRepo.match(/^(?:https?:\/\/github\.com\/)?([^/]+)\/([^/]+?)(?:\.git)?$/);
+                if (matchStore) {
+                    currentDefaultIndexUrl = `https://${matchStore[1]}.github.io/${matchStore[2]}`;
+                }
+            }
+            await storeConfig.update("storeRepo", newStoreRepo, vscode.ConfigurationTarget.Global);
+            if (!currentIndexUrl ||
+                (currentDefaultIndexUrl && currentIndexUrl === currentDefaultIndexUrl)) {
+                await storeConfig.update("store.indexUrl", newIndexUrl, vscode.ConfigurationTarget.Global);
+            }
+            const action = await vscode.window.showInformationMessage(
+            // allow-any-unicode-next-line
+            `🦛 ${result.message}`, "Open Pull Request", "Copy URL");
+            if (action === "Open Pull Request") {
+                await vscode.env.openExternal(vscode.Uri.parse(result.pullRequestUrl));
+            }
+            else if (action === "Copy URL") {
+                await vscode.env.clipboard.writeText(result.pullRequestUrl);
+                void showInfo("Pull request URL copied to clipboard");
+            }
+        }
+        else if (!result.success) {
+            void showError(`Setup failed: ${result.message}`);
+        }
+    }));
+    // Install pack from store (internal command)
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.storeInstall", async (artifactArg) => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { downloadFromStore, listStoreVersions } = await import("./store/index.js");
+        const { getAgentRoot } = await import("./agentpack/paths.js");
+        const artifact = artifactArg || {
+            type: "pack",
+            slug: "",
+            version: undefined,
+        };
+        // If no version specified, show version picker or use main
+        if (!artifact.version) {
+            const versions = await listStoreVersions("pack", artifact.slug);
+            if (versions.length === 0) {
+                // No tags - will download from main branch
+                artifact.version = "main";
+            }
+            else {
+                const selected = await vscode.window.showQuickPick(versions.map((v) => ({
+                    label: v.version,
+                    description: v.isPrerelease ? "(pre-release)" : "",
+                })), { placeHolder: "Select version to install" });
+                if (!selected) {
+                    return;
+                }
+                artifact.version = selected.label;
+            }
+        }
+        const targetDir = getAgentRoot(workspaceRoot, artifact.slug);
+        const targetExists = await fs_1.promises
+            .access(targetDir)
+            .then(() => true)
+            .catch(() => false);
+        if (targetExists) {
+            const overwrite = await vscode.window.showWarningMessage(`Pack "${artifact.slug}" already exists. Overwrite?`, { modal: true }, "Overwrite", "Cancel");
+            if (overwrite !== "Overwrite") {
+                return;
+            }
+            await fs_1.promises.rm(targetDir, { recursive: true, force: true });
+        }
+        await vscode.window.withProgress({
+            location: vscode.ProgressLocation.Window,
+            title: `Installing pack "${artifact.slug}"`,
+            cancellable: false,
+        }, async (progress) => {
+            progress.report({ message: "Downloading from store..." });
+            const files = await downloadFromStore({
+                type: "pack",
+                slug: artifact.slug,
+                version: artifact.version,
+            }, outputChannel);
+            progress.report({ message: "Extracting files..." });
+            await fs_1.promises.mkdir(targetDir, { recursive: true });
+            for (const file of files) {
+                const filePath = path.join(targetDir, file.path);
+                await fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+                await fs_1.promises.writeFile(filePath, file.content);
+            }
+        });
+        await vscode.commands.executeCommand("agentide.packsChanged");
+        // Register the installed pack in local registry
+        const { getRegistry } = await import("./registry/index.js");
+        const registry = getRegistry(outputChannel);
+        await registry.registerPack({
+            slug: artifact.slug,
+            displayName: artifact.slug,
+            latestVersion: artifact.version || "main",
+            tags: [],
+            stats: { installs: 1, stars: 0 },
+        });
+        // Invalidate local index cache so merged search sees the new item
+        const { invalidateLocalIndex } = await import("./store/oramaIndex.js");
+        invalidateLocalIndex();
+        const activateAction = await vscode.window.showInformationMessage(`Installed pack "${artifact.slug}" v${artifact.version}`, "Activate");
+        if (activateAction === "Activate") {
+            await vscode.commands.executeCommand("agentide.pack.switch", artifact.slug);
+        }
+    }));
+    // Install skill from store or external GitHub
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.skill.install", async (artifactArg) => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { downloadFromStore, downloadFromExternalGitHub, listStoreVersions, isStoreUrl, parseGitHubUrl, } = await import("./store/index.js");
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        // Get artifact info
+        let artifact = artifactArg;
+        if (!artifact) {
+            const url = await vscode.window.showInputBox({
+                prompt: "Enter skill store URL or GitHub URL",
+                placeHolder: "e.g., skills/typescript-testing@v1.0.0 or https://github.com/user/repo",
+            });
+            if (!url) {
+                return;
+            }
+            const { parseStoreUrl } = await import("./store/index.js");
+            artifact = parseStoreUrl(url);
+        }
+        // Determine if this is a store URL or external GitHub
+        const isExternal = artifact.sourceUrl && !isStoreUrl(artifact.sourceUrl);
+        // If no version specified and not external, show version picker
+        if (!artifact.version && !isExternal) {
+            const versions = await listStoreVersions("skill", artifact.slug);
+            if (versions.length === 0) {
+                artifact.version = "main";
+            }
+            else {
+                const selected = await vscode.window.showQuickPick(versions.map((v) => ({
+                    label: v.version,
+                    description: v.isPrerelease ? "(pre-release)" : "",
+                })), { placeHolder: "Select version to install" });
+                if (!selected) {
+                    return;
+                }
+                artifact.version = selected.label;
+            }
+        }
+        // Select which agent to install the skill to
+        const packs = await packManager.listInstalledWithCleanup();
+        if (packs.length === 0) {
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: No agents found. Create an agent first.`);
+            return;
+        }
+        const targetPack = await vscode.window.showQuickPick(packs.map((p) => ({ label: p.id, description: `v${p.version}` })), { placeHolder: "Select agent to install skill to" });
+        if (!targetPack) {
+            return;
+        }
+        const { getAgentRoot } = await import("./agentpack/paths.js");
+        const agentRoot = getAgentRoot(workspaceRoot, targetPack.label);
+        const skillsDir = path.join(agentRoot, "skills", artifact.slug);
+        const targetExists = await fs_1.promises
+            .access(skillsDir)
+            .then(() => true)
+            .catch(() => false);
+        if (targetExists) {
+            const overwrite = await vscode.window.showWarningMessage(`Skill "${artifact.slug}" already exists in ${targetPack.label}. Overwrite?`, { modal: true }, "Overwrite", "Cancel");
+            if (overwrite !== "Overwrite") {
+                return;
+            }
+            await fs_1.promises.rm(skillsDir, { recursive: true, force: true });
+        }
+        await vscode.window.withProgress({
+            location: vscode.ProgressLocation.Window,
+            title: `Installing skill "${artifact.slug}"`,
+            cancellable: false,
+        }, async (progress) => {
+            let files;
+            if (isExternal && artifact.sourceUrl) {
+                // Download from external GitHub
+                progress.report({ message: "Downloading from GitHub..." });
+                const parsed = parseGitHubUrl(artifact.sourceUrl);
+                files = await downloadFromExternalGitHub({
+                    owner: parsed.owner,
+                    repo: parsed.repo,
+                    ref: parsed.ref || "main",
+                    path: parsed.path,
+                }, outputChannel);
+            }
+            else {
+                // Download from store
+                progress.report({ message: "Downloading from store..." });
+                files = await downloadFromStore({
+                    type: "skill",
+                    slug: artifact.slug,
+                    version: artifact.version,
+                }, outputChannel);
+            }
+            progress.report({ message: "Extracting files..." });
+            await fs_1.promises.mkdir(skillsDir, { recursive: true });
+            for (const file of files) {
+                const filePath = path.join(skillsDir, file.path);
+                await fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+                await fs_1.promises.writeFile(filePath, file.content);
+            }
+        });
+        // Register the installed skill in local registry
+        const { getRegistry } = await import("./registry/index.js");
+        const registry = getRegistry(outputChannel);
+        await registry.registerSkill({
+            slug: artifact.slug,
+            displayName: artifact.slug,
+            latestVersion: artifact.version || "main",
+            tags: [],
+            stats: { installs: 1 },
+            agentPackId: targetPack.label,
+        });
+        // Invalidate local index cache so merged search sees the new item
+        const { invalidateLocalIndex } = await import("./store/oramaIndex.js");
+        invalidateLocalIndex();
+        showInfo(`Installed skill "${artifact.slug}" to ${targetPack.label}`);
+    }));
+    // Install MCP from store
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.mcp.install", async (artifactArg) => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { downloadFromStore, listStoreVersions } = await import("./store/index.js");
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        // Get artifact info
+        let artifact = artifactArg;
+        if (!artifact) {
+            const url = await vscode.window.showInputBox({
+                prompt: "Enter MCP store URL",
+                placeHolder: "e.g., mcp/github@v1.0.0",
+            });
+            if (!url) {
+                return;
+            }
+            const { parseStoreUrl } = await import("./store/index.js");
+            artifact = parseStoreUrl(url);
+        }
+        // If no version specified, show version picker or use main
+        if (!artifact.version) {
+            const versions = await listStoreVersions("mcp", artifact.slug);
+            if (versions.length === 0) {
+                // No tags - will download from main branch
+                artifact.version = "main";
+            }
+            else {
+                const selected = await vscode.window.showQuickPick(versions.map((v) => ({
+                    label: v.version,
+                    description: v.isPrerelease ? "(pre-release)" : "",
+                })), { placeHolder: "Select version to install" });
+                if (!selected) {
+                    return;
+                }
+                artifact.version = selected.label;
+            }
+        }
+        // Select which agent to install the MCP to
+        const packs = await packManager.listInstalledWithCleanup();
+        if (packs.length === 0) {
+            showError(`${branding_1.AGENTIDE_BRAND_NAME}: No agents found. Create an agent first.`);
+            return;
+        }
+        const targetPack = await vscode.window.showQuickPick(packs.map((p) => ({ label: p.id, description: `v${p.version}` })), { placeHolder: "Select agent to add MCP server to" });
+        if (!targetPack) {
+            return;
+        }
+        await vscode.window.withProgress({
+            location: vscode.ProgressLocation.Window,
+            title: `Installing MCP "${artifact.slug}"`,
+            cancellable: false,
+        }, async (progress) => {
+            progress.report({ message: "Downloading from store..." });
+            const files = await downloadFromStore({
+                type: "mcp",
+                slug: artifact.slug,
+                version: artifact.version,
+            }, outputChannel);
+            progress.report({ message: "Merging MCP config..." });
+            // Find mcp.json in downloaded files
+            const mcpJsonFile = files.find((f) => f.path === "mcp.json" || f.path.endsWith("/mcp.json"));
+            if (!mcpJsonFile) {
+                throw new Error("Downloaded MCP package missing mcp.json");
+            }
+            const mcpConfig = JSON.parse(mcpJsonFile.content.toString());
+            // Read existing .mcp.json or create new one
+            const { getAgentRoot } = await import("./agentpack/paths.js");
+            const agentRoot = getAgentRoot(workspaceRoot, targetPack.label);
+            const mcpDir = path.join(agentRoot, "mcp");
+            const mcpJsonPath = path.join(mcpDir, ".mcp.json");
+            await fs_1.promises.mkdir(mcpDir, { recursive: true });
+            let existingConfig = {
+                mcpServers: {},
+            };
+            try {
+                const content = await fs_1.promises.readFile(mcpJsonPath, "utf-8");
+                existingConfig = JSON.parse(content);
+                if (!existingConfig.mcpServers) {
+                    existingConfig.mcpServers = {};
+                }
+            }
+            catch {
+                // File doesn't exist, use default
+            }
+            // Add/update the MCP server
+            existingConfig.mcpServers[artifact.slug] = {
+                transport: mcpConfig.transport || "stdio",
+                command: mcpConfig.command,
+                args: mcpConfig.args,
+                env: mcpConfig.env,
+                url: mcpConfig.url,
+                npmPackage: mcpConfig.npmPackage,
+                // Store metadata
+                _version: artifact.version,
+                _description: mcpConfig.description,
+            };
+            // Write back
+            await fs_1.promises.writeFile(mcpJsonPath, JSON.stringify(existingConfig, null, 2));
+            // Also save any additional source files
+            for (const file of files) {
+                if (file.path !== "mcp.json" &&
+                    !file.path.endsWith("/mcp.json")) {
+                    const filePath = path.join(mcpDir, artifact.slug, file.path);
+                    await fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
+                    await fs_1.promises.writeFile(filePath, file.content);
+                }
+            }
+        });
+        // Register the installed MCP in local registry
+        const { getRegistry } = await import("./registry/index.js");
+        const registry = getRegistry(outputChannel);
+        await registry.registerMcp({
+            slug: artifact.slug,
+            displayName: artifact.slug,
+            transport: "stdio",
+            latestVersion: artifact.version || "main",
+            tags: [],
+            stats: { installs: 1 },
+            agentPackId: targetPack.label,
+        });
+        // Invalidate local index cache so merged search sees the new item
+        const { invalidateLocalIndex } = await import("./store/oramaIndex.js");
+        invalidateLocalIndex();
+        showInfo(`Installed MCP "${artifact.slug}" v${artifact.version} to ${targetPack.label}`);
+    }));
+    // Install custom engine from store or external GitHub
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.engine.install", async (artifactArg) => {
+        const { downloadFromStore, downloadFromExternalGitHub, listStoreVersions, isStoreUrl, parseGitHubUrl, parseStoreUrl, } = await import("./store/index.js");
+        const { installCustomEngineFromFiles } = await import("./engines/install.js");
+        let artifact = artifactArg;
+        if (!artifact) {
+            const url = await vscode.window.showInputBox({
+                prompt: "Enter custom engine store URL or GitHub URL",
+                placeHolder: "e.g., engine/gemini or https://github.com/user/repo/tree/main/gemini",
+            });
+            if (!url) {
+                return;
+            }
+            if (isStoreUrl(url)) {
+                artifact = parseStoreUrl(url);
+            }
+            else {
+                const parsed = parseGitHubUrl(url);
+                const pathParts = (parsed.path || parsed.repo).split("/");
+                artifact = {
+                    type: "engine",
+                    slug: pathParts[pathParts.length - 1] || parsed.repo,
+                    version: parsed.ref,
+                    sourceUrl: url,
+                };
+            }
+        }
+        const isExternal = artifact.sourceUrl && !isStoreUrl(artifact.sourceUrl);
+        if (!artifact.version && !isExternal) {
+            const versions = await listStoreVersions("engine", artifact.slug);
+            if (versions.length === 0) {
+                artifact.version = "main";
+            }
+            else {
+                const selected = await vscode.window.showQuickPick(versions.map((v) => ({
+                    label: v.version,
+                    description: v.isPrerelease ? "(pre-release)" : "",
+                })), { placeHolder: "Select version to install" });
+                if (!selected) {
+                    return;
+                }
+                artifact.version = selected.label;
+            }
+        }
+        const installOnce = async (overwrite) => {
+            return await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Window,
+                title: `Installing engine "${artifact.slug}"`,
+                cancellable: false,
+            }, async (progress) => {
+                let files;
+                if (isExternal && artifact.sourceUrl) {
+                    progress.report({ message: "Downloading from GitHub..." });
+                    const parsed = parseGitHubUrl(artifact.sourceUrl);
+                    files = await downloadFromExternalGitHub({
+                        owner: parsed.owner,
+                        repo: parsed.repo,
+                        ref: parsed.ref || "main",
+                        path: parsed.path,
+                    }, outputChannel);
+                }
+                else {
+                    progress.report({ message: "Downloading from store..." });
+                    files = await downloadFromStore({
+                        type: "engine",
+                        slug: artifact.slug,
+                        version: artifact.version,
+                    }, outputChannel);
+                }
+                progress.report({ message: "Validating and installing..." });
+                return await installCustomEngineFromFiles(files, {
+                    slug: artifact.slug,
+                    version: artifact.version,
+                    sourceUrl: artifact.sourceUrl,
+                    overwrite,
+                    logger: outputChannel,
+                });
+            });
+        };
+        let result;
+        try {
+            result = await installOnce(false);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (!errorMsg.includes("already exists")) {
+                log(outputChannel, `[AgentIDE] Engine install error: ${errorMsg}`);
+                showError(`AgentIDE: ${errorMsg}`);
+                return;
+            }
+            const overwrite = await vscode.window.showWarningMessage(errorMsg, { modal: true }, "Overwrite", "Cancel");
+            if (overwrite !== "Overwrite") {
+                return;
+            }
+            try {
+                result = await installOnce(true);
+            }
+            catch (retryError) {
+                const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
+                log(outputChannel, `[AgentIDE] Engine install error: ${retryMsg}`);
+                showError(`AgentIDE: ${retryMsg}`);
+                return;
+            }
+        }
+        const { invalidateLocalIndex } = await import("./store/oramaIndex.js");
+        invalidateLocalIndex();
+        if (!result) {
+            return;
+        }
+        clearCustomEngineRuntimeCache(state, result.id);
+        await refreshCustomEnginePicker(outputChannel);
+        const action = await vscode.window.showInformationMessage(`Installed engine "${result.displayName}"`, "List Engines");
+        if (action === "List Engines") {
+            await vscode.commands.executeCommand("agentide.customEngine.list");
+        }
+    }));
+    // Install Spotlight view from store or external GitHub
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.view.install", async (artifactArg) => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { downloadFromStore, downloadFromExternalGitHub, listStoreVersions, isStoreUrl, parseGitHubUrl, parseStoreUrl, } = await import("./store/index.js");
+        const { installSpotlightViewFromFiles } = await import("./spotlight/install.js");
+        let artifact = artifactArg;
+        if (!artifact) {
+            const url = await vscode.window.showInputBox({
+                prompt: "Enter Spotlight view store URL or GitHub URL",
+                placeHolder: "e.g., view/cost-ops or https://github.com/user/repo/tree/main/spotlight/cost-ops",
+            });
+            if (!url) {
+                return;
+            }
+            if (isStoreUrl(url)) {
+                artifact = parseStoreUrl(url);
+            }
+            else {
+                const parsed = parseGitHubUrl(url);
+                const pathParts = (parsed.path || parsed.repo).split("/");
+                artifact = {
+                    type: "view",
+                    slug: pathParts[pathParts.length - 1] || parsed.repo,
+                    version: parsed.ref,
+                    sourceUrl: url,
+                };
+            }
+        }
+        const isExternal = artifact.sourceUrl && !isStoreUrl(artifact.sourceUrl);
+        if (!artifact.version && !isExternal) {
+            const versions = await listStoreVersions("view", artifact.slug);
+            if (versions.length === 0) {
+                artifact.version = "main";
+            }
+            else {
+                const selected = await vscode.window.showQuickPick(versions.map((v) => ({
+                    label: v.version,
+                    description: v.isPrerelease ? "(pre-release)" : "",
+                })), { placeHolder: "Select version to install" });
+                if (!selected) {
+                    return;
+                }
+                artifact.version = selected.label;
+            }
+        }
+        const installOnce = async (overwrite, activate) => {
+            return await vscode.window.withProgress({
+                location: vscode.ProgressLocation.Window,
+                title: `Installing Spotlight view "${artifact.slug}"`,
+                cancellable: false,
+            }, async (progress) => {
+                let files;
+                if (isExternal && artifact.sourceUrl) {
+                    progress.report({ message: "Downloading from GitHub..." });
+                    const parsed = parseGitHubUrl(artifact.sourceUrl);
+                    const externalFiles = await downloadFromExternalGitHub({
+                        owner: parsed.owner,
+                        repo: parsed.repo,
+                        ref: parsed.ref || "main",
+                        path: parsed.path,
+                    }, outputChannel);
+                    files = externalFiles.map((file) => ({
+                        path: file.path,
+                        content: file.content,
+                    }));
+                }
+                else {
+                    progress.report({ message: "Downloading from store..." });
+                    const storeFiles = await downloadFromStore({
+                        type: "view",
+                        slug: artifact.slug,
+                        version: artifact.version,
+                    }, outputChannel);
+                    files = storeFiles;
+                }
+                progress.report({ message: "Installing view..." });
+                return await installSpotlightViewFromFiles(files, {
+                    slug: artifact.slug,
+                    version: artifact.version,
+                    overwrite,
+                    activate,
+                    workspaceRoot,
+                    logger: outputChannel,
+                });
+            });
+        };
+        let result;
+        try {
+            result = await installOnce(false, false);
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            if (!errorMsg.includes("already exists")) {
+                log(outputChannel, `[AgentIDE] Spotlight view install error: ${errorMsg}`);
+                showError(`AgentIDE: ${errorMsg}`);
+                return;
+            }
+            const overwrite = await vscode.window.showWarningMessage(errorMsg, { modal: true }, "Overwrite", "Cancel");
+            if (overwrite !== "Overwrite") {
+                return;
+            }
+            try {
+                result = await installOnce(true, false);
+            }
+            catch (retryError) {
+                const retryMsg = retryError instanceof Error ? retryError.message : String(retryError);
+                log(outputChannel, `[AgentIDE] Spotlight view install error: ${retryMsg}`);
+                showError(`AgentIDE: ${retryMsg}`);
+                return;
+            }
+        }
+        const { invalidateLocalIndex } = await import("./store/oramaIndex.js");
+        invalidateLocalIndex();
+        if (!result) {
+            return;
+        }
+        const dashboard = _state?.analyticsDashboard;
+        if (dashboard) {
+            await dashboard.refreshViewsFromDisk();
+        }
+        const action = await vscode.window.showInformationMessage(`Installed Spotlight view "${result.id}" v${result.version || artifact.version || "main"}`, "Open Spotlight", "Activate View");
+        if (action === "Open Spotlight") {
+            await vscode.commands.executeCommand("agentide.analytics.openDashboard");
+        }
+        else if (action === "Activate View") {
+            const { setActiveSpotlightView } = await import("./spotlight/install.js");
+            await setActiveSpotlightView(result.viewsConfigPath, result.id);
+            const dashboardAfterActivate = _state?.analyticsDashboard;
+            if (dashboardAfterActivate) {
+                await dashboardAfterActivate.refreshViewsFromDisk();
+            }
+            await vscode.commands.executeCommand("agentide.analytics.openDashboard");
+        }
+    }));
+    // Update agent from User Library
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.update", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        const packs = await packManager.listInstalledWithCleanup();
+        const updatable = [];
+        for (const pack of packs) {
+            if (pack.id === "default") {
+                continue;
+            }
+            const newVersion = await packManager.checkAgentUpdate(pack.id);
+            if (newVersion) {
+                updatable.push({ id: pack.id, version: pack.version, newVersion });
+            }
+        }
+        if (updatable.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: All agents are up to date`);
+            return;
+        }
+        const items = updatable.map((u) => ({
+            label: u.id,
+            description: `v${u.version} → v${u.newVersion}`,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select an agent to update",
+            title: "Update Agent from User Library",
+        });
+        if (!selected) {
+            return;
+        }
+        const confirm = await vscode.window.showWarningMessage(`Update "${selected.label}" from User Library? Current version will be backed up.`, { modal: true }, "Update", "Cancel");
+        if (confirm !== "Update") {
+            return;
+        }
+        try {
+            const version = await packManager.updateFromLibrary(selected.label);
+            showInfo(`AgentIDE: Updated "${selected.label}" to v${version}`);
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Update error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Duplicate agent
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.duplicate", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        const packs = await packManager.listInstalledWithCleanup();
+        if (packs.length === 0) {
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No agents to duplicate`);
+            return;
+        }
+        const items = packs.map((p) => ({
+            label: p.id,
+            description: `v${p.version}`,
+        }));
+        const selected = await vscode.window.showQuickPick(items, {
+            placeHolder: "Select an agent to duplicate",
+            title: "Duplicate Agent",
+        });
+        if (!selected) {
+            return;
+        }
+        try {
+            const newAgentId = await packManager.duplicate(selected.label);
+            showInfo(`AgentIDE: Created "${newAgentId}" as copy of "${selected.label}"`);
+            // Open the new agent's AGENTS.md
+            const agentsPath = path.join((0, paths_1.getAgentideDir)(workspaceRoot), paths_1.AGENT_CONSTANTS.AGENTS_DIR, newAgentId, paths_1.AGENT_CONSTANTS.AGENTS_MD);
+            if (await (0, utils_1.pathExists)(agentsPath)) {
+                const doc = await vscode.workspace.openTextDocument(agentsPath);
+                await vscode.window.showTextDocument(doc);
+            }
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Duplicate error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Refresh/discover packs - finds and registers any new packs on disk
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.refresh", async () => {
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        try {
+            const { registered } = await packManager.repairUnregisteredAgents();
+            if (registered.length > 0) {
+                showInfo(`AgentIDE: Discovered ${registered.length} new pack(s): ${registered.join(", ")}`);
+            }
+            else {
+                showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: No new packs found`);
+            }
+            return { registered };
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Pack refresh error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+            return { registered: [] };
+        }
+    }));
+    // Reset default agent
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.pack.resetDefault", async () => {
+        const confirm = await vscode.window.showWarningMessage("Reset the default agent? This will restore it from bundled templates. Current default agent will be backed up.", { modal: true }, "Reset", "Cancel");
+        if (confirm !== "Reset") {
+            return;
+        }
+        const { workspaceRoot } = getWorkspaceRoot(outputChannel);
+        const { AgentPackManager } = await import("./agentpack/index.js");
+        const packManager = new AgentPackManager(syncService, () => workspaceRoot, () => config.storagePath, outputChannel);
+        try {
+            await packManager.resetDefault(getBundledBasePromptsDir());
+            showInfo(`${branding_1.AGENTIDE_BRAND_NAME}: Default agent reset from bundled templates`);
+            // Force sync
+            await syncService.flushAgentideRootUpdate(workspaceRoot, outputChannel, { force: true, allowDuringActiveTurn: true });
+        }
+        catch (e) {
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            log(outputChannel, `[AgentIDE] Reset error: ${errorMsg}`);
+            showError(`AgentIDE: ${errorMsg}`);
+        }
+    }));
+    // Main chat command
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.chat", async (args) => {
+        return handleChatCommand(state, args);
+    }));
+    // Cancel an in-flight streamed chat run
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.chat.cancel", async (args) => {
+        const streamId = args?.streamId;
+        if (!streamId) {
+            return { cancelled: false, error: "streamId is required" };
+        }
+        const run = _activeRunsByStreamId.get(streamId);
+        if (!run) {
+            log(outputChannel, `[AgentIDE] Cancel ignored: no active run for streamId=${streamId}`);
+            rejectPendingQuestionsForStream(streamId, 'Run cancelled');
+            return { cancelled: false };
+        }
+        log(outputChannel, `[AgentIDE] Cancel requested: streamId=${streamId}, engine=${run.engine}, ageMs=${Date.now() - run.startedAt}`);
+        try {
+            run.abortController.abort();
+        }
+        catch {
+            // ignore
+        }
+        rejectPendingQuestionsForStream(streamId, 'Run cancelled');
+        return { cancelled: true };
+    }));
+    context.subscriptions.push(vscode.commands.registerCommand("agentide.chat.answerQuestion", async (args) => {
+        const streamId = args?.streamId;
+        const questionId = args?.questionId;
+        if (!streamId || !questionId) {
+            return { ok: false, error: 'streamId and questionId are required' };
+        }
+        const pending = _pendingQuestionsById.get(questionId);
+        if (!pending || pending.streamId !== streamId) {
+            return { ok: false, error: 'Question not found or already resolved' };
+        }
+        const normalized = normalizeQuestionAnswer(args?.answer);
+        resolvePendingQuestion(questionId, normalized);
+        return { ok: true };
+    }));
+}
+// -----------------------------------------------------------------------------
+// User Permission Mapping
+// -----------------------------------------------------------------------------
+/**
+ * Get user permissions from VS Code settings (unified model).
+ */
+function getUserPermissions() {
+    const cfg = vscode.workspace.getConfiguration("agentide");
+    return {
+        fileAccess: cfg.get("permissions.fileAccess", "full"),
+    };
+}
+function getConfiguredAdditionalEngineDir() {
+    return vscode.workspace
+        .getConfiguration("agentide")
+        .get("additionalEngineDir");
+}
+function clearCustomEngineRuntimeCache(state, engineId) {
+    const customEngine = state.engines.custom;
+    try {
+        customEngine?.clearInstances?.(engineId);
+    }
+    catch (error) {
+        log(state.outputChannel, `[AgentIDE] Custom engine cache clear warning: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function refreshCustomEnginePicker(outputChannel) {
+    try {
+        await vscode.commands.executeCommand("agentide.engine.refresh");
+    }
+    catch (error) {
+        log(outputChannel, `[AgentIDE] Custom engine picker refresh warning: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// -----------------------------------------------------------------------------
+// Chat Command Handler
+// -----------------------------------------------------------------------------
+// Shared session event writer for IDE Layer 2 analytics (singleton to avoid repeated mkdir)
+const _sessionEventWriter = new sessionEvents_1.SessionEventWriter();
+async function handleChatCommand(state, args) {
+    const { outputChannel, engines, syncService, config } = state;
+    const { engine: engineId, streamId } = args;
+    let { message } = args;
+    const incomingOptions = args.options ?? {};
+    // Check for gateway request marker: [gw:token]message
+    // If present, extract the token and look up the gateway emitter for composite streaming
+    let gatewayEmitter;
+    const gatewayMarkerMatch = message.match(/^\[gw:(gw-[^\]]+)\]/);
+    if (gatewayMarkerMatch) {
+        const gatewayToken = gatewayMarkerMatch[1];
+        // Strip the marker from the message
+        message = message.slice(gatewayMarkerMatch[0].length);
+        log(outputChannel, `[AgentIDE] Gateway request detected, token=${gatewayToken.slice(0, 20)}...`);
+        // Look up the gateway emitter
+        const { GatewayService } = await import("./gateway/service.js");
+        gatewayEmitter = GatewayService.getGatewayEmitter(gatewayToken);
+        if (gatewayEmitter) {
+            log(outputChannel, `[AgentIDE] Gateway emitter found, will stream to both Chat UI and Gateway`);
+        }
+        else {
+            log(outputChannel, `[AgentIDE] Gateway emitter NOT found for token ${gatewayToken.slice(0, 20)}...`);
+        }
+    }
+    // Resolve workspace root
+    const { workspaceRoot, additionalDirectories, isHomeFallback } = getWorkspaceRoot(outputChannel, incomingOptions.workspaceRoot, incomingOptions.additionalDirectories);
+    if (streamId && isHomeFallback) {
+        await warnHomeFallbackOnce(outputChannel, streamId);
+    }
+    const remoteManifest = await syncService.getActiveAgentManifest(workspaceRoot, outputChannel, syncService.getActivePackId(workspaceRoot) ?? state.activePackId);
+    const remoteUrl = remoteManifest?.spec?.remote?.url?.trim();
+    if (remoteUrl) {
+        return (0, handleRemoteChat_js_1.handleRemoteServeChat)({
+            outputChannel,
+            syncService,
+            sessionEventWriter: _sessionEventWriter,
+            activeRunsByStreamId: _activeRunsByStreamId,
+            rejectPendingQuestionsForStream,
+            askQuestionViaWorkbenchTool,
+            askQuestionFromChatUI,
+            getServeAuth: async () => {
+                if (!_extensionContext) {
+                    return undefined;
+                }
+                const session = await (0, provider_js_1.getAgentHippoAccessToken)(_extensionContext);
+                if (!session) {
+                    return undefined;
+                }
+                return {
+                    accessToken: session.accessToken,
+                    userEmail: session.email,
+                };
+            },
+            ensureSignedIn: async () => {
+                if (!_extensionContext) {
+                    return undefined;
+                }
+                const session = await (0, signInFlow_js_1.ensureAgentHippoSignedIn)(_extensionContext);
+                if (!session) {
+                    return undefined;
+                }
+                return {
+                    accessToken: session.accessToken,
+                    userEmail: session.email,
+                };
+            },
+            log,
+        }, {
+            engine: engineId,
+            message,
+            options: args.options,
+            streamId,
+            sessionResource: args.sessionResource,
+            requestId: args.requestId,
+            remoteUrl,
+            remoteManifest,
+            workspaceRoot,
+            incomingOptions,
+            gatewayEmitter,
+        });
+    }
+    // Build resolved options (include activePackId from state)
+    let options = {
+        ...incomingOptions,
+        workspaceRoot,
+        additionalDirectories,
+        agentPackId: state.activePackId, // Pass active pack to engine
+        // agentPackVersion is set below after manifest is loaded
+    };
+    if (!streamId) {
+        return {
+            error: "streamId is required - non-streaming mode is no longer supported",
+        };
+    }
+    // Resolve engine. Custom engine IDs are routed through the dynamic custom loader.
+    let runtimeEngineId = engineId;
+    let engine = engines[runtimeEngineId];
+    if (!engine &&
+        runtimeEngineId !== "codex" &&
+        runtimeEngineId !== "claude" &&
+        engines.custom) {
+        options = {
+            ...options,
+            engineId: options.engineId ?? runtimeEngineId,
+        };
+        runtimeEngineId = "custom";
+        engine = engines.custom;
+        log(outputChannel, `[AgentIDE] Routing requested engine "${engineId}" through custom runtime loader`);
+    }
+    if (!engine) {
+        const errorMsg = `Unknown engine: ${engineId}`;
+        log(outputChannel, `[AgentIDE] Error: ${errorMsg}`);
+        return { error: errorMsg };
+    }
+    log(outputChannel, `[AgentIDE] Chat request for engine=${engineId} (runtime=${runtimeEngineId}), streamId: ${streamId}, useLiteLLM: ${options.useLiteLLM || false}`);
+    // Create per-run abort controller so Workbench can cancel this stream
+    const abortController = new AbortController();
+    _activeRunsByStreamId.set(streamId, {
+        streamId,
+        engine: runtimeEngineId,
+        startedAt: Date.now(),
+        abortController,
+    });
+    // Create emitter - if gateway emitter is present, create a composite that streams to both
+    const ipcEmitter = (0, utils_1.createIPCStreamEmitter)(streamId);
+    const chatSessionResource = args.sessionResource;
+    const chatRequestId = args.requestId;
+    const questionEmitter = {
+        ...ipcEmitter,
+        async question(payload) {
+            // Use workbench askQuestions tool when we have session context (same path as Copilot)
+            if (chatSessionResource) {
+                return await askQuestionViaWorkbenchTool(chatSessionResource, chatRequestId, payload, abortController.signal);
+            }
+            return await askQuestionFromChatUI(streamId, payload);
+        },
+    };
+    const emitter = gatewayEmitter ? {
+        ...questionEmitter,
+        // Composite emitter: streams to both Chat UI (via IPC) and Gateway (via websocket)
+        async thinking(delta) {
+            await ipcEmitter.thinking(delta);
+            // Send to Gateway with raw tags for CLI formatting
+            await gatewayEmitter.thinking(`<thinking>${delta}</thinking>`);
+        },
+        async text(delta) {
+            await ipcEmitter.text(delta);
+            await gatewayEmitter.text(delta);
+        },
+        async toolStart(toolName, input, toolCallId, metadata) {
+            await ipcEmitter.toolStart(toolName, input, toolCallId, metadata);
+            await gatewayEmitter.toolStart(toolName, input, toolCallId, metadata);
+        },
+        async toolEnd(toolName, toolCallId, result, isError, metadata) {
+            await ipcEmitter.toolEnd(toolName, toolCallId, result, isError, metadata);
+            await gatewayEmitter.toolEnd(toolName, toolCallId, result, isError, metadata);
+        },
+        async progress(msg) {
+            await ipcEmitter.progress(msg);
+            await gatewayEmitter.progress(msg);
+        },
+        async question(payload) {
+            const answer = await questionEmitter.question(payload);
+            await gatewayEmitter.progress(`Question answered: ${questionPromptToHeader(payload.prompt)}`);
+            return answer;
+        },
+        async error(msg) {
+            await ipcEmitter.error(msg);
+            await gatewayEmitter.error(msg);
+        },
+        async done() {
+            await ipcEmitter.done();
+            await gatewayEmitter.done();
+        },
+    } : questionEmitter;
+    const terminalLog = getTerminalLogInfo(options);
+    await appendTerminalAttachmentsToLog(args.context, streamId, outputChannel, terminalLog?.uri);
+    // Persist image attachments (so agents can read a real file path instead of guessing)
+    await persistImageAttachments(args.context, options, outputChannel);
+    // Persist file/folder attachments (so agents can read them even if they were outside the workspace)
+    await persistFileAndDirectoryAttachments(args.context, options, outputChannel);
+    const contextSuffix = formatSdkContextSuffix(args.context, terminalLog?.relativePath);
+    const enrichedMessage = contextSuffix
+        ? `${message}\n\n${contextSuffix}`
+        : message;
+    // Create Layer 2 session event observability (before try so it's accessible in catch)
+    const requestId = (0, base_1.generateRequestId)();
+    const sessionId = options.sessionId ?? `ide-${Date.now()}`;
+    const observableEmitter = (0, sessionEvents_1.wrapEmitterWithObservability)(emitter, _sessionEventWriter, sessionId, requestId);
+    try {
+        // Prepare project sync
+        syncService.incrementActiveAgentTurns();
+        await syncService.ensureAgentideProjectPrepared(workspaceRoot, additionalDirectories, outputChannel);
+        // Always write paths.md for the effective workspaceRoot so users can discover what AgentIDE manages.
+        await syncService.writeManagedPathsManifest(config.codexHome, config.claudeConfigDir, workspaceRoot, additionalDirectories, outputChannel);
+        // Load manifest and resolve permissions
+        const manifest = await syncService.getActiveAgentManifest(workspaceRoot, outputChannel);
+        const manifestPerms = (0, permissions_1.parseManifestPermissions)(manifest);
+        const userPerms = getUserPermissions();
+        const effectivePerms = (0, permissions_1.enforcePermissions)(manifestPerms, userPerms);
+        log(outputChannel, `[AgentIDE] Permissions: manifest(files=${manifestPerms.fileAccess}) + user(files=${userPerms.fileAccess}) = effective(files=${effectivePerms.fileAccess})`);
+        // Add permissions + agent version + requestId to options
+        const optionsWithPerms = {
+            ...options,
+            sessionId,
+            permissions: effectivePerms,
+            agentPackVersion: manifest?.metadata?.version,
+            requestId, // Same requestId used by ObservableStreamEmitter for Layer 1/2 correlation
+        };
+        // Create runtime context with VS Code implementations.
+        // V1 permissions are non-interactive; always auto-approve tool requests.
+        const logger = new vscode_logger_1.VSCodeLogger(outputChannel);
+        const permissionHandler = new permission_handler_1.AutoApprovePermissionHandler();
+        const configuredCliPath = vscode.workspace
+            .getConfiguration("agentide")
+            .get("cli.path", "");
+        const cliHealth = await (0, runtime_1.getCliHealth)({
+            configuredPath: configuredCliPath,
+            extensionPath: _extensionContext?.extensionPath,
+        });
+        const userInstalledToolsDir = _extensionContext?.globalState?.get(BUNDLED_TOOLS_DIR_KEY);
+        const cliEnvPatch = (0, runtime_1.buildCliEnvPatch)({
+            cliPath: cliHealth.path,
+            workspaceRoot,
+            agentId: optionsWithPerms.agentPackId ?? 'default',
+            chatSessionId: optionsWithPerms.sessionId?.trim() || optionsWithPerms.contextSessionId?.trim(),
+            baseEnv: process.env,
+            extensionPath: _extensionContext?.extensionPath,
+            userInstalledToolsDir: userInstalledToolsDir ?? undefined,
+        });
+        if (cliEnvPatch.AGENTHIPPO_TOOLS_DIR) {
+            log(outputChannel, `[AgentIDE] Bundled tools dir available for runtime: ${cliEnvPatch.AGENTHIPPO_TOOLS_DIR}`);
+        }
+        const runtimeContext = {
+            logger,
+            editTracker: new vscode_edit_tracker_1.VSCodeEditTracker(new vscode_logger_1.VSCodeLogger(outputChannel, "[EditTracker]")),
+            configProvider: new vscode_config_provider_1.VSCodeConfigProvider(),
+            permissionHandler,
+            cliEnvPatch,
+        };
+        if (cliHealth.installed && cliHealth.path) {
+            log(outputChannel, `[AgentIDE] CLI available for agent runtime: ${cliHealth.path}`);
+        }
+        else {
+            log(outputChannel, `[AgentIDE] CLI not detected for runtime (skills may rely on '${branding_1.AGENTIDE_CLI_NAME}' on PATH)`);
+        }
+        log(outputChannel, `[AgentIDE] Analytics: session=${sessionId}, request=${requestId}, agent=${optionsWithPerms.agentPackId ?? 'default'}, version=${optionsWithPerms.agentPackVersion ?? 'workspace'}`);
+        // Emit turn_start event
+        await observableEmitter.emitTurnStart();
+        // Stream response
+        await engine.stream(enrichedMessage, optionsWithPerms, observableEmitter, runtimeContext, abortController.signal);
+        // Emit turn_end event
+        await observableEmitter.emitTurnEnd(true);
+        return { streaming: true };
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        log(outputChannel, `[AgentIDE] Error: ${errorMsg}`);
+        // Use observableEmitter (not raw emitter) so error is captured in Layer 2 session events
+        await observableEmitter.error(errorMsg);
+        await observableEmitter.emitTurnEnd(false);
+        return { error: errorMsg };
+    }
+    finally {
+        rejectPendingQuestionsForStream(streamId, 'Run finished');
+        _activeRunsByStreamId.delete(streamId);
+        syncService.decrementActiveAgentTurns();
+    }
+}
+function resolveWorkspaceRootUri(workspaceRoot) {
+    const folders = vscode.workspace.workspaceFolders ?? [];
+    const match = folders.find((f) => f.uri.fsPath === workspaceRoot);
+    if (match) {
+        return match.uri;
+    }
+    const primary = folders[0];
+    if (primary && workspaceRoot.startsWith("/")) {
+        // Preserve remote scheme/authority when possible.
+        return vscode.Uri.from({
+            scheme: primary.uri.scheme,
+            authority: primary.uri.authority,
+            path: workspaceRoot,
+        });
+    }
+    return vscode.Uri.file(workspaceRoot);
+}
+function dirnameUri(uri) {
+    const idx = uri.path.lastIndexOf("/");
+    return idx >= 0 ? uri.with({ path: uri.path.slice(0, idx) }) : uri;
+}
+function getTerminalLogInfo(options) {
+    const contextSessionId = options.contextSessionId?.trim() || options.sessionId?.trim();
+    if (!contextSessionId) {
+        return undefined;
+    }
+    const workspaceRootUri = resolveWorkspaceRootUri(options.workspaceRoot);
+    const uri = vscode.Uri.joinPath(workspaceRootUri, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, paths_1.AGENT_CONSTANTS.SESSIONS_DIR, contextSessionId, TERMINAL_LOG_FILE_NAME);
+    return {
+        uri,
+        relativePath: `${AGENTIDE_SESSIONS_DIR_NAME}/${contextSessionId}/${TERMINAL_LOG_FILE_NAME}`,
+    };
+}
+function getSessionAttachmentsDirInfo(options) {
+    const contextSessionId = options.contextSessionId?.trim() || options.sessionId?.trim();
+    if (!contextSessionId) {
+        return undefined;
+    }
+    const workspaceRootUri = resolveWorkspaceRootUri(options.workspaceRoot);
+    const dirUri = vscode.Uri.joinPath(workspaceRootUri, paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME, paths_1.AGENT_CONSTANTS.SESSIONS_DIR, contextSessionId, ATTACHMENTS_DIR_NAME);
+    return {
+        dirUri,
+        relativeDirPath: `${AGENTIDE_SESSIONS_DIR_NAME}/${contextSessionId}/${ATTACHMENTS_DIR_NAME}`,
+    };
+}
+function slugifyFileStem(name) {
+    const stem = name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 60);
+    return stem || "attachment";
+}
+function imageExtensionFromMimeType(mimeType) {
+    switch ((mimeType ?? "").toLowerCase()) {
+        case "image/png":
+            return "png";
+        case "image/jpeg":
+        case "image/jpg":
+            return "jpg";
+        case "image/gif":
+            return "gif";
+        case "image/webp":
+            return "webp";
+        default:
+            return "png";
+    }
+}
+async function persistImageAttachments(ctx, options, outputChannel) {
+    const variables = ctx?.variables ?? [];
+    if (!ctx || variables.length === 0) {
+        return;
+    }
+    const images = variables.filter((v) => v.kind === "image" &&
+        typeof v.dataBase64 === "string" &&
+        v.dataBase64.length > 0);
+    if (images.length === 0) {
+        return;
+    }
+    const info = getSessionAttachmentsDirInfo(options);
+    if (!info) {
+        // No stable session folder -> cannot persist; leave bytes for now.
+        log(outputChannel, "[AgentIDE] Note: image attachment present but no contextSessionId; skipping persistence");
+        return;
+    }
+    try {
+        await (0, terminalLogger_1.ensureDirectory)(info.dirUri);
+    }
+    catch (e) {
+        log(outputChannel, `[AgentIDE] Warning: failed to create session attachments dir: ${e instanceof Error ? e.message : String(e)}`);
+        return;
+    }
+    let index = 0;
+    for (const img of images) {
+        index++;
+        const stem = slugifyFileStem(img.name || `image-${index}`);
+        const ext = imageExtensionFromMimeType(img.mimeType);
+        const fileName = images.length > 1 ? `${stem}-${index}.${ext}` : `${stem}.${ext}`;
+        const fileUri = vscode.Uri.joinPath(info.dirUri, fileName);
+        try {
+            const bytes = Buffer.from(img.dataBase64, "base64");
+            await vscode.workspace.fs.writeFile(fileUri, bytes);
+            // Update the variable entry to point at a real workspace path the agent can read.
+            img.uri = `${info.relativeDirPath}/${fileName}`;
+            // Drop bytes from the payload to keep prompt + memory small downstream.
+            delete img.dataBase64;
+        }
+        catch (e) {
+            log(outputChannel, `[AgentIDE] Warning: failed to persist image attachment "${img.name}": ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+}
+async function persistFileAndDirectoryAttachments(ctx, options, outputChannel) {
+    const variables = ctx?.variables ?? [];
+    if (!ctx || variables.length === 0) {
+        return;
+    }
+    const candidates = variables.filter((v) => (v.kind === "file" || v.kind === "directory") &&
+        typeof v.uri === "string" &&
+        v.uri.trim().length > 0);
+    if (candidates.length === 0) {
+        return;
+    }
+    const info = getSessionAttachmentsDirInfo(options);
+    if (!info) {
+        log(outputChannel, "[AgentIDE] Note: file/folder attachment present but no contextSessionId; skipping persistence");
+        return;
+    }
+    try {
+        await (0, terminalLogger_1.ensureDirectory)(info.dirUri);
+    }
+    catch (e) {
+        log(outputChannel, `[AgentIDE] Warning: failed to create session attachments dir: ${e instanceof Error ? e.message : String(e)}`);
+        return;
+    }
+    const manifestUri = vscode.Uri.joinPath(info.dirUri, "manifest.json");
+    const readManifest = async () => {
+        try {
+            const raw = await vscode.workspace.fs.readFile(manifestUri);
+            const parsed = JSON.parse(Buffer.from(raw).toString("utf8"));
+            if (parsed &&
+                parsed.version === 1 &&
+                typeof parsed.files === "object" &&
+                typeof parsed.directories === "object") {
+                return parsed;
+            }
+        }
+        catch {
+            // ignore
+        }
+        return { version: 1, files: {}, directories: {} };
+    };
+    const writeManifest = async (manifest) => {
+        try {
+            const bytes = Buffer.from(JSON.stringify(manifest, null, 2), "utf8");
+            await vscode.workspace.fs.writeFile(manifestUri, bytes);
+        }
+        catch {
+            // ignore (best-effort)
+        }
+    };
+    const manifest = await readManifest();
+    let manifestDirty = false;
+    const MAX_FILES = 500;
+    const MAX_TOTAL_BYTES = 25 * 1024 * 1024; // 25MB total per request (best-effort)
+    const MAX_SINGLE_FILE_BYTES = 10 * 1024 * 1024; // 10MB per file (best-effort)
+    let totalFiles = 0;
+    let totalBytes = 0;
+    const isUnder = (parent, candidate) => {
+        try {
+            const parentNorm = path.resolve(parent);
+            const candidateNorm = path.resolve(candidate);
+            const rel = path.relative(parentNorm, candidateNorm);
+            return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+        }
+        catch {
+            return false;
+        }
+    };
+    const workspaceRoot = options.workspaceRoot;
+    const sessionRootSegment = path.normalize(`${path.sep}${AGENTIDE_SESSIONS_DIR_NAME.split("/").join(path.sep)}${path.sep}`);
+    const exists = async (uri) => {
+        try {
+            await vscode.workspace.fs.stat(uri);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const uniqueNameInDir = async (dir, name) => {
+        let candidateName = name;
+        let attempt = 1;
+        while (await exists(vscode.Uri.joinPath(dir, candidateName))) {
+            attempt++;
+            const ext = path.extname(name);
+            const base = ext ? name.slice(0, -ext.length) : name;
+            candidateName = `${base}-${attempt}${ext}`;
+        }
+        return candidateName;
+    };
+    const copyFile = async (srcPath, destDir) => {
+        const srcUri = vscode.Uri.file(srcPath);
+        try {
+            const stat = await vscode.workspace.fs.stat(srcUri);
+            if (stat.type !== vscode.FileType.File) {
+                return undefined;
+            }
+            const key = `${srcPath}::${stat.size}::${stat.mtime}`;
+            const existing = manifest.files[key];
+            if (existing) {
+                const existingUri = vscode.Uri.joinPath(destDir, existing.destName);
+                if (await exists(existingUri)) {
+                    return existing.destName;
+                }
+            }
+            const baseName = path.basename(srcPath);
+            const destName = await uniqueNameInDir(destDir, baseName || "attachment");
+            const destUri = vscode.Uri.joinPath(destDir, destName);
+            if (stat.size > MAX_SINGLE_FILE_BYTES) {
+                log(outputChannel, `[AgentIDE] Note: skipping large file attachment (${stat.size} bytes): ${srcPath}`);
+                return undefined;
+            }
+            if (totalFiles + 1 > MAX_FILES ||
+                totalBytes + stat.size > MAX_TOTAL_BYTES) {
+                log(outputChannel, "[AgentIDE] Note: skipping additional file attachments due to size limits");
+                return undefined;
+            }
+            const bytes = await vscode.workspace.fs.readFile(srcUri);
+            await vscode.workspace.fs.writeFile(destUri, bytes);
+            totalFiles += 1;
+            totalBytes += stat.size;
+            manifest.files[key] = {
+                destName,
+                sourcePath: srcPath,
+                size: stat.size,
+                mtime: stat.mtime,
+            };
+            manifestDirty = true;
+            return destName;
+        }
+        catch (e) {
+            log(outputChannel, `[AgentIDE] Warning: failed to persist file attachment "${srcPath}": ${e instanceof Error ? e.message : String(e)}`);
+            return undefined;
+        }
+    };
+    const copyDirRecursive = async (srcUri, destUri) => {
+        const entries = await vscode.workspace.fs.readDirectory(srcUri);
+        for (const [name, type] of entries) {
+            if (totalFiles >= MAX_FILES || totalBytes >= MAX_TOTAL_BYTES) {
+                return;
+            }
+            const childSrc = vscode.Uri.joinPath(srcUri, name);
+            const childDest = vscode.Uri.joinPath(destUri, name);
+            if (type === vscode.FileType.Directory) {
+                await (0, terminalLogger_1.ensureDirectory)(childDest);
+                await copyDirRecursive(childSrc, childDest);
+            }
+            else if (type === vscode.FileType.File) {
+                try {
+                    const stat = await vscode.workspace.fs.stat(childSrc);
+                    if (stat.size > MAX_SINGLE_FILE_BYTES) {
+                        continue;
+                    }
+                    if (totalFiles + 1 > MAX_FILES ||
+                        totalBytes + stat.size > MAX_TOTAL_BYTES) {
+                        return;
+                    }
+                    const bytes = await vscode.workspace.fs.readFile(childSrc);
+                    await vscode.workspace.fs.writeFile(childDest, bytes);
+                    totalFiles += 1;
+                    totalBytes += stat.size;
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    };
+    for (const v of candidates) {
+        const sourcePath = v.uri.trim();
+        // Only persist absolute, local paths outside the workspace root.
+        if (!path.isAbsolute(sourcePath)) {
+            continue;
+        }
+        if (workspaceRoot && isUnder(workspaceRoot, sourcePath)) {
+            continue;
+        }
+        if (path.normalize(sourcePath).includes(sessionRootSegment)) {
+            continue;
+        }
+        try {
+            const srcUri = vscode.Uri.file(sourcePath);
+            const stat = await vscode.workspace.fs.stat(srcUri);
+            if (stat.type === vscode.FileType.Directory && v.kind === "directory") {
+                const key = `${sourcePath}::${stat.mtime}`;
+                const existing = manifest.directories[key];
+                if (existing) {
+                    const existingUri = vscode.Uri.joinPath(info.dirUri, existing.destName);
+                    if (await exists(existingUri)) {
+                        v.uri = `${info.relativeDirPath}/${existing.destName}`;
+                        continue;
+                    }
+                }
+                const baseName = path.basename(sourcePath) || "folder";
+                const destName = await uniqueNameInDir(info.dirUri, baseName);
+                const destDirUri = vscode.Uri.joinPath(info.dirUri, destName);
+                await (0, terminalLogger_1.ensureDirectory)(destDirUri);
+                await copyDirRecursive(srcUri, destDirUri);
+                manifest.directories[key] = { destName, sourcePath, mtime: stat.mtime };
+                manifestDirty = true;
+                v.uri = `${info.relativeDirPath}/${destName}`;
+            }
+            else if (stat.type === vscode.FileType.File && v.kind === "file") {
+                const destName = await copyFile(sourcePath, info.dirUri);
+                if (destName) {
+                    v.uri = `${info.relativeDirPath}/${destName}`;
+                }
+            }
+        }
+        catch {
+            // ignore (best-effort)
+        }
+    }
+    if (manifestDirty) {
+        await writeManifest(manifest);
+    }
+}
+async function appendTerminalAttachmentsToLog(ctx, streamId, outputChannel, terminalLogUri) {
+    if (!terminalLogUri) {
+        return;
+    }
+    const variables = ctx?.variables ?? [];
+    // Terminal command attachments (from @terminalCommand or terminal command history)
+    const terminalCmdVars = variables.filter((v) => v.kind === "terminalCommand" &&
+        typeof v.output === "string" &&
+        v.output.trim().length > 0);
+    // Terminal selection attachments (generated by terminal chat tools with a stable id prefix).
+    const terminalSelectionVars = variables.filter((v) => v.kind === "generic" &&
+        typeof v.text === "string" &&
+        v.text.trim().length > 0 &&
+        (v.isTerminalSelection ||
+            (typeof v.id === "string" && v.id.startsWith("terminal-selection-"))));
+    if (terminalCmdVars.length === 0 && terminalSelectionVars.length === 0) {
+        return;
+    }
+    try {
+        await (0, terminalLogger_1.ensureDirectory)(dirnameUri(terminalLogUri));
+        const nowIso = new Date().toISOString();
+        const lines = [];
+        lines.push(`<!-- TERMINAL_ATTACHMENTS STREAM:${streamId} TIME:${nowIso} -->`);
+        lines.push("");
+        // Write terminal command outputs
+        for (const t of terminalCmdVars) {
+            const cmd = (t.command ?? t.name ?? "").toString().trim();
+            lines.push("## Terminal Command");
+            if (cmd) {
+                lines.push(`- Command: ${cmd}`);
+            }
+            if (typeof t.exitCode === "number") {
+                lines.push(`- Exit code: ${t.exitCode}`);
+            }
+            if (t.uri) {
+                lines.push(`- Resource: ${t.uri}`);
+            }
+            lines.push("");
+            lines.push("```text");
+            lines.push(t.output ?? "");
+            lines.push("```");
+            lines.push("");
+        }
+        // Write terminal selection content
+        for (const t of terminalSelectionVars) {
+            const title = t.name || "Terminal Selection";
+            lines.push(`## ${title}`);
+            lines.push("");
+            lines.push("```text");
+            lines.push(t.text ?? "");
+            lines.push("```");
+            lines.push("");
+        }
+        lines.push(`<!-- TERMINAL_ATTACHMENTS_END STREAM:${streamId} -->`);
+        lines.push("");
+        await (0, terminalLogger_1.appendTextFileWithRotation)(terminalLogUri, lines.join("\n"), MAX_TERMINAL_LOG_BYTES);
+    }
+    catch (e) {
+        log(outputChannel, `[AgentIDE] Warning: failed to persist terminal attachments for grep: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+function formatSdkContextSuffix(ctx, terminalLogRelPath) {
+    if (!ctx) {
+        return "";
+    }
+    const parts = [];
+    if (ctx.selection?.text && ctx.selection.text.trim()) {
+        const headerBits = [];
+        if (ctx.selection.uri) {
+            headerBits.push(`**File:** \`${ctx.selection.uri}\``);
+        }
+        if (ctx.selection.range) {
+            const r = ctx.selection.range;
+            headerBits.push(`**Range:** ${r.startLineNumber}:${r.startColumn}-${r.endLineNumber}:${r.endColumn}`);
+        }
+        parts.push("## Currently Selected Code");
+        if (headerBits.length) {
+            parts.push(headerBits.join("  \n"));
+            parts.push("");
+        }
+        const lang = (ctx.selection.languageId ?? "").trim();
+        parts.push(`\`\`\`${lang}`);
+        parts.push(ctx.selection.text);
+        parts.push("```");
+    }
+    const variables = ctx.variables ?? [];
+    if (variables.length) {
+        parts.push("## Attached Context");
+        for (const v of variables) {
+            switch (v.kind) {
+                case "terminalCommand": {
+                    const cmd = v.command?.trim() || v.name;
+                    parts.push(`### Terminal`);
+                    parts.push(`**Command:** \`${cmd}\``);
+                    if (v.uri) {
+                        parts.push(`**Resource:** \`${v.uri}\``);
+                    }
+                    if (typeof v.exitCode === "number") {
+                        parts.push(`**Exit code:** ${v.exitCode}`);
+                    }
+                    // Keep prompt small: persist output to a session log file and tell the agent where to grep.
+                    if (terminalLogRelPath) {
+                        parts.push(`**Output:** saved to \`${terminalLogRelPath}\` (use \`rg\`/ \`grep\`)`);
+                    }
+                    else if (v.output && v.output.trim()) {
+                        // Fallback when no session id is available: inline a small tail so the agent still sees errors.
+                        const tail = v.output.length > 2000
+                            ? `…(truncated)\n${v.output.slice(-2000)}`
+                            : v.output;
+                        parts.push("");
+                        parts.push("```text");
+                        parts.push(tail);
+                        parts.push("```");
+                    }
+                    parts.push("");
+                    break;
+                }
+                case "paste": {
+                    const lang = (v.language ?? "").trim();
+                    const title = v.name || "Paste";
+                    parts.push(`### ${title}`);
+                    if (v.code && v.code.trim()) {
+                        parts.push(`\`\`\`${lang}`);
+                        parts.push(v.code);
+                        parts.push("```");
+                    }
+                    parts.push("");
+                    break;
+                }
+                case "file":
+                case "directory":
+                case "promptFile": {
+                    const target = v.uri ?? v.name;
+                    parts.push(`- **${v.kind}**: \`${target}\``);
+                    break;
+                }
+                case "image":
+                case "notebookOutput": {
+                    const target = v.uri ?? v.name;
+                    const extra = v.mimeType ? ` (${v.mimeType})` : "";
+                    parts.push(`- **${v.kind}**: \`${target}\`${extra}`);
+                    break;
+                }
+                case "implicit": {
+                    if (v.isSelection) {
+                        const target = v.uri ?? v.name;
+                        parts.push(`- **selection reference**: \`${target}\``);
+                    }
+                    else if (v.uri) {
+                        parts.push(`- **reference**: \`${v.uri}\``);
+                    }
+                    break;
+                }
+                case "generic": {
+                    // Generic attachments like Terminal Selection
+                    const title = v.name || "Context";
+                    const isTerminalSelection = !!v.isTerminalSelection ||
+                        (typeof v.id === "string" &&
+                            v.id.startsWith("terminal-selection-"));
+                    parts.push(`### ${title}`);
+                    if (isTerminalSelection && v.text && v.text.trim()) {
+                        // Terminal selection content is stored in terminal.md for grep-ability
+                        if (terminalLogRelPath) {
+                            parts.push(`**Content:** saved to \`${terminalLogRelPath}\` (use \`rg\`/\`grep\`)`);
+                        }
+                        else {
+                            // Fallback: inline small tail if no session
+                            const tail = v.text.length > 2000
+                                ? `…(truncated)\n${v.text.slice(-2000)}`
+                                : v.text;
+                            parts.push("```text");
+                            parts.push(tail);
+                            parts.push("```");
+                        }
+                        // Parse terminal name from "Terminal Selection (zsh)" format and point to the activity log
+                        const terminalNameMatch = v.name?.match(/Terminal Selection \((.+)\)/);
+                        if (terminalNameMatch) {
+                            const terminalName = terminalNameMatch[1];
+                            const terminalSlug = (0, terminalLogger_1.terminalNameToSlug)(terminalName);
+                            parts.push(`**Full terminal history:** \`${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}/terminals/${terminalSlug}.md\``);
+                        }
+                        else {
+                            // Point to the terminals directory for all terminal logs
+                            parts.push(`**All terminal logs:** \`${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}/terminals/\``);
+                        }
+                    }
+                    else if (v.text && v.text.trim()) {
+                        // Non-terminal generic content: inline it
+                        parts.push("```text");
+                        parts.push(v.text);
+                        parts.push("```");
+                    }
+                    else if (v.uri) {
+                        parts.push(`**Resource:** \`${v.uri}\``);
+                    }
+                    parts.push("");
+                    break;
+                }
+                default: {
+                    const target = v.uri ?? v.name;
+                    parts.push(`- **${v.kind}**: ${target}`);
+                    break;
+                }
+            }
+        }
+    }
+    const out = parts.join("\n").trim();
+    return out ? out + "\n" : "";
+}
+// -----------------------------------------------------------------------------
+// Helpers
+// -----------------------------------------------------------------------------
+function getBundledBasePromptsDir() {
+    if (!_extensionContext) {
+        return undefined;
+    }
+    return path.join(_extensionContext.extensionPath, "base-prompts");
+}
+/**
+ * Register bundled MCP servers with VS Code's MCP infrastructure.
+ * This allows the VS Code native chat (DirectLLM) to discover and use MCP servers.
+ */
+async function registerBundledMcpServers(context, outputChannel) {
+    const basePromptsDir = getBundledBasePromptsDir();
+    if (!basePromptsDir) {
+        log(outputChannel, "[AgentIDE] Cannot register MCP servers: base-prompts dir not found");
+        return;
+    }
+    try {
+        const servers = await (0, mcp_1.loadBundledMcpServers)(basePromptsDir);
+        if (servers.length === 0) {
+            log(outputChannel, "[AgentIDE] No bundled MCP servers found");
+            return;
+        }
+        // Register MCP server definition provider with VS Code
+        // The ID must match what's declared in package.json contributes.mcpServerDefinitionProviders
+        const disposable = vscode.lm.registerMcpServerDefinitionProvider("bundled-mcp-servers", {
+            provideMcpServerDefinitions: async () => {
+                return servers.map((server) => new vscode.McpStdioServerDefinition(server.label, server.command, server.args, server.env ?? {}));
+            },
+        });
+        context.subscriptions.push(disposable);
+        log(outputChannel, `[AgentIDE] Registered ${servers.length} bundled MCP server(s) with VS Code: ${servers.map((s) => s.name).join(", ")}`);
+    }
+    catch (e) {
+        log(outputChannel, `[AgentIDE] Warning: failed to register MCP servers: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+async function refreshAgentideProject(state) {
+    const { outputChannel, syncService, config } = state;
+    const { workspaceRoot, additionalDirectories, isHomeFallback } = getWorkspaceRoot(outputChannel);
+    if (isHomeFallback) {
+        // Don't sync/watch when no workspace is open; fallback is only for running ad-hoc agent tools.
+        return;
+    }
+    try {
+        await syncService.ensureAgentideProjectPrepared(workspaceRoot, additionalDirectories, outputChannel);
+        await syncService.writeManagedPathsManifest(config.codexHome, config.claudeConfigDir, workspaceRoot, additionalDirectories, outputChannel);
+        log(outputChannel, "[AgentIDE] Project sync complete");
+    }
+    catch (e) {
+        log(outputChannel, `[AgentIDE] Warning: failed to refresh project sync: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+/**
+ * Get the configured fallback directory path.
+ * Reads from `agentide.fallbackDirectory` setting (directory name relative to home).
+ */
+function getFallbackDirectoryPath() {
+    const config = vscode.workspace.getConfiguration("agentide");
+    const dirName = config.get("fallbackDirectory") || ".agent-hippo";
+    return path.join(os.homedir(), dirName);
+}
+function getWorkspaceRoot(outputChannel, explicitWorkspaceRoot, explicitAdditionalDirs) {
+    const folders = vscode.workspace.workspaceFolders;
+    const allFolderPaths = (0, workspaceFolders_1.getWorkspaceFolderFsPaths)();
+    const candidate = explicitWorkspaceRoot?.trim();
+    if (candidate) {
+        const additionalDirectories = explicitAdditionalDirs ?? allFolderPaths.filter((p) => p !== candidate);
+        if (folders && folders.length > 1) {
+            log(outputChannel, `[AgentIDE] Multi-root workspace (${folders.length} folders). Primary: ${candidate}, Additional: ${additionalDirectories.length}`);
+        }
+        else {
+            log(outputChannel, `[AgentIDE] Using explicit workspaceRoot=${candidate}`);
+        }
+        return {
+            workspaceRoot: candidate,
+            additionalDirectories,
+            isHomeFallback: false,
+        };
+    }
+    if (folders && folders.length > 0) {
+        const primaryFolder = folders[0].uri.fsPath;
+        const additionalDirectories = allFolderPaths.slice(1);
+        if (folders.length > 1) {
+            log(outputChannel, `[AgentIDE] Multi-root workspace (${folders.length} folders). Primary: ${primaryFolder}, Additional: ${additionalDirectories.length}`);
+        }
+        else {
+            log(outputChannel, `[AgentIDE] Using workspace folder: ${primaryFolder}`);
+        }
+        return {
+            workspaceRoot: primaryFolder,
+            additionalDirectories,
+            isHomeFallback: false,
+        };
+    }
+    // Use fallback workspace (configurable via agentide.fallbackDirectory, default: ~/myagentide)
+    const fallbackDir = getFallbackDirectoryPath();
+    log(outputChannel, `[AgentIDE] No workspace open, using fallback directory: ${fallbackDir}`);
+    return {
+        workspaceRoot: fallbackDir,
+        additionalDirectories: [],
+        isHomeFallback: true,
+    };
+}
+/**
+ * Ensure the fallback directory exists with git initialized.
+ * Called before using the fallback as a workspace root.
+ */
+async function ensureFallbackDirectoryExists(outputChannel) {
+    const fallbackDir = getFallbackDirectoryPath();
+    try {
+        // Check if directory exists
+        const exists = await (0, utils_1.pathExists)(fallbackDir);
+        if (!exists) {
+            // Create the directory
+            await fs_1.promises.mkdir(fallbackDir, { recursive: true });
+            log(outputChannel, `[AgentIDE] Created fallback directory: ${fallbackDir}`);
+            // Initialize git repository
+            try {
+                const { execFile } = await import("child_process");
+                const { promisify } = await import("util");
+                const execFileAsync = promisify(execFile);
+                await execFileAsync("git", ["init"], { cwd: fallbackDir });
+                log(outputChannel, `[AgentIDE] Initialized git in fallback directory`);
+                // Create a .gitignore to keep things clean
+                const gitignorePath = path.join(fallbackDir, ".gitignore");
+                const gitignoreContent = `# ${branding_1.AGENTIDE_BRAND_NAME} fallback workspace
+${paths_1.AGENT_CONSTANTS.AGENTIDE_DIR_NAME}/${paths_1.AGENT_CONSTANTS.SESSIONS_DIR}/
+*.log
+`;
+                await fs_1.promises.writeFile(gitignorePath, gitignoreContent, "utf8");
+                // Create a README
+                const readmePath = path.join(fallbackDir, "README.md");
+                const readmeContent = `# My ${branding_1.AGENTIDE_BRAND_NAME} Workspace
+
+This is the default ${branding_1.AGENTIDE_BRAND_NAME} workspace, created automatically when no folder is open.
+
+**Recommendation:** Open a specific project folder for better context and safety.
+
+Files created here:
+- Agent-generated files when no workspace is open
+- Temporary experiments
+`;
+                await fs_1.promises.writeFile(readmePath, readmeContent, "utf8");
+            }
+            catch (gitError) {
+                // Git init failed - that's okay, directory still exists
+                log(outputChannel, `[AgentIDE] Note: Could not initialize git in fallback directory: ${gitError instanceof Error ? gitError.message : String(gitError)}`);
+            }
+        }
+    }
+    catch (error) {
+        log(outputChannel, `[AgentIDE] Warning: Failed to ensure fallback directory: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return fallbackDir;
+}
+let _hasWarnedHomeFallbackInThisSession = false;
+async function warnHomeFallbackOnce(outputChannel, streamId) {
+    if (_hasWarnedHomeFallbackInThisSession) {
+        return;
+    }
+    _hasWarnedHomeFallbackInThisSession = true;
+    // Ensure fallback directory exists with git init
+    const fallbackDir = await ensureFallbackDirectoryExists(outputChannel);
+    const msg = `No folder is open. Running agent tools in: ${fallbackDir}`;
+    log(outputChannel, `[AgentIDE] ${msg}`);
+    void vscode.commands.executeCommand("agentide.streamCallback", {
+        streamId,
+        type: "progress",
+        data: msg,
+    });
+}