@hashicorp/kits 0.1.0

package/dist/cli/install.js

@@ -0,0 +1,1624 @@
+/**
+ * Install command implementation.
+ *
+ * Handles fetching sources, discovering kits, and installing to harnesses.
+ * Uses the TUI layer for interactive user interaction.
+ */
+import { ExitCode } from "./types.js";
+import * as clack from "@clack/prompts";
+import path from "node:path";
+import pc from "picocolors";
+import { fetchSource, scanKits, filterKitsByName as filterDiscoveryKitsByName, getMissingKitNames as getDiscoveryMissingKitNames, NoFetcherError, SourceParseError, } from "../discovery/index.js";
+import { resolvePrimitiveReferences, PrimitivesRegistryLoader, validateCliEnvFlags, mergeEnvDefs, resolveEnvVarsFromConfig, } from "../resolution/index.js";
+import { hashMcpConfig } from "../core/mcp-instance.js";
+import { hashHookConfig } from "../core/hook-instance.js";
+import { readManifest } from "../manifest/read.js";
+import { writeManifest } from "../manifest/write.js";
+import { createEmptyManifest, } from "../manifest/types.js";
+import { getAdapterRegistry } from "../adapters/index.js";
+import { debugLog, enableDebugLogging, getDebugLogPath, checkDebugLogWritable, } from "../core/debug.js";
+import { expandPath } from "../adapters/file-operations.js";
+import { 
+// TUI components
+intro, outroSuccess, outroError, outroCancel, logInfo, logError, confirmInstallPlan, displayInstallPlanSummary, 
+// Spinner utilities
+startSpinner, stopSpinnerSuccess, stopSpinnerError, formatSource, formatCount, formatKit, 
+// Harness selection
+selectHarnesses, warnMissingHarnesses, displayNoHarnessesDetected, filterHarnessesByName, getMissingHarnesses, 
+// Kit selection
+selectKits, displayAvailableKits, displayKitsJson, displayNoKitsFound, displayMissingKits, filterKitsByName, 
+// Compatibility
+runCompatibilityCheck, buildCompatibilityMatrix, hasIncompatibilities, 
+// Scope selection
+selectScope, 
+// Summary
+displayDryRunSummary, 
+// Env prompts (Phase 6)
+promptForEnvVars, promptForSharedMcpInstances, } from "../tui/index.js";
+/**
+ * Detect installed harnesses.
+ */
+async function detectAllHarnesses() {
+    const registry = getAdapterRegistry();
+    const adapters = registry.list();
+    const results = [];
+    for (const adapter of adapters) {
+        const detection = await adapter.detect();
+        const info = {
+            name: adapter.name,
+            displayName: adapter.displayName,
+            detected: detection.detected,
+            supportedPrimitives: adapter.getSupportedPrimitives(),
+            adapter,
+        };
+        if (detection.version) {
+            info.version = detection.version;
+        }
+        if (detection.configPath) {
+            info.configPath = detection.configPath;
+        }
+        results.push(info);
+    }
+    return results;
+}
+/**
+ * Run the install command.
+ */
+/**
+ * Determine scope from CLI options.
+ * Returns null if scope needs to be determined via TUI.
+ */
+function getScopeFromOptions(options) {
+    if (options.global) {
+        return "global";
+    }
+    if (options.project) {
+        return "project";
+    }
+    return null;
+}
+/**
+ * Run the install command.
+ */
+export async function runInstall(source, options) {
+    const isInteractive = !options.yes && !options.json;
+    let fetchResult;
+    enableDebugLogging(options.debug ?? false);
+    if (options.debug) {
+        const debugCheck = checkDebugLogWritable();
+        if (!debugCheck.ok) {
+            console.error(`Warning: Debug logging enabled but cannot write to ${debugCheck.path}: ${debugCheck.error}`);
+        }
+        void debugLog({
+            level: "info",
+            event: "debug.enabled",
+            message: "Debug logging enabled",
+            data: { logPath: getDebugLogPath() },
+        });
+    }
+    void debugLog({
+        level: "info",
+        event: "install.start",
+        data: {
+            source,
+            options: {
+                agent: options.agent,
+                kit: options.kit,
+                list: options.list ?? false,
+                yes: options.yes ?? false,
+                dryRun: options.dryRun ?? false,
+                json: options.json ?? false,
+                verbose: options.verbose ?? false,
+                global: options.global ?? false,
+                project: options.project ?? false,
+                envKeys: options.env ? Object.keys(options.env) : [],
+                mcpInstanceKits: options.mcpInstance ? Object.keys(options.mcpInstance) : [],
+            },
+        },
+    });
+    // Parse scope from options
+    let scope = getScopeFromOptions(options);
+    const projectRoot = process.cwd();
+    // In non-interactive mode, scope must be specified
+    // Exception: --list flag doesn't require scope
+    if (!isInteractive && !scope && !options.list) {
+        const message = "Scope is required in non-interactive mode. Use --global (-g) or --project (-p).";
+        if (options.json) {
+            console.log(JSON.stringify({ success: false, error: message }));
+        }
+        else {
+            console.error(`Error: ${message}`);
+        }
+        return { success: false, exitCode: ExitCode.ScopeRequired, error: message };
+    }
+    try {
+        // Start interactive UI if applicable
+        if (isInteractive) {
+            intro("@hashicorp/kits");
+        }
+        // Fetch source
+        const fetchSpinner = isInteractive
+            ? startSpinner(`Fetching ${formatSource(source)}...`)
+            : undefined;
+        if (!fetchSpinner && options.verbose) {
+            console.error(`Fetching ${source}...`);
+        }
+        try {
+            fetchResult = await fetchSource(source);
+            if (fetchSpinner) {
+                stopSpinnerSuccess(fetchSpinner, `Fetched ${formatSource(source)}`);
+            }
+            else if (options.verbose) {
+                console.error(`Fetched to ${fetchResult.localPath}`);
+            }
+            void debugLog({
+                level: "info",
+                event: "install.fetch.success",
+                data: { localPath: fetchResult.localPath },
+            });
+        }
+        catch (error) {
+            if (fetchSpinner) {
+                stopSpinnerError(fetchSpinner, "Failed to fetch source");
+            }
+            if (error instanceof NoFetcherError || error instanceof SourceParseError) {
+                const message = error.message;
+                if (isInteractive) {
+                    logError(message);
+                    outroError("Installation failed");
+                }
+                else if (options.json) {
+                    console.log(JSON.stringify({ success: false, error: message }));
+                }
+                else {
+                    console.error(`Error: ${message}`);
+                }
+                return { success: false, exitCode: ExitCode.SourceNotFound, error: message };
+            }
+            throw error;
+        }
+        // Scan for kits
+        const scanSpinner = isInteractive ? startSpinner("Scanning for kits...") : undefined;
+        let discovery = await scanKits(fetchResult.localPath, source);
+        if (scanSpinner) {
+            const kitCount = discovery.kits.length;
+            stopSpinnerSuccess(scanSpinner, `Found ${formatCount(kitCount, "kit")}`);
+        }
+        void debugLog({
+            level: "info",
+            event: "install.scan.success",
+            data: { kits: discovery.kits.map((kit) => kit.name) },
+        });
+        // Filter by requested kit names
+        if (options.kit && options.kit.length > 0) {
+            const missing = getDiscoveryMissingKitNames(discovery, options.kit);
+            if (missing.length > 0) {
+                const message = `Kit${missing.length === 1 ? "" : "s"} not found: ${missing.join(", ")}`;
+                if (isInteractive) {
+                    displayMissingKits(missing, discovery.kits);
+                    outroError("Installation failed");
+                }
+                else if (options.json) {
+                    console.log(JSON.stringify({ success: false, error: message }));
+                }
+                else {
+                    console.error(`Error: ${message}`);
+                    console.error("Available kits: " + discovery.kits.map((k) => k.name).join(", "));
+                }
+                return { success: false, exitCode: ExitCode.KitNotFound, error: message };
+            }
+            discovery = filterDiscoveryKitsByName(discovery, options.kit);
+        }
+        // Handle --list flag
+        if (options.list) {
+            if (options.json) {
+                displayKitsJson(discovery.kits, discovery.source, discovery.repository);
+            }
+            else {
+                displayAvailableKits(discovery.kits);
+            }
+            return { success: true, exitCode: ExitCode.Success };
+        }
+        // Check if any kits were found
+        if (discovery.kits.length === 0) {
+            const message = "No kits found in repository";
+            if (isInteractive) {
+                displayNoKitsFound();
+                outroError("Installation failed");
+            }
+            else if (options.json) {
+                console.log(JSON.stringify({ success: false, error: message }));
+            }
+            else {
+                console.error(`Error: ${message}`);
+            }
+            return { success: false, exitCode: ExitCode.KitNotFound, error: message };
+        }
+        // Interactive kit selection (stage 1)
+        let selectedKits = discovery.kits;
+        if (isInteractive && !options.kit) {
+            const result = await selectKits(discovery.kits, {
+                showAvailable: false,
+            });
+            if (result.cancelled) {
+                outroCancel("Installation cancelled");
+                return { success: false, exitCode: ExitCode.InstallationFailed };
+            }
+            selectedKits = filterKitsByName(discovery.kits, result.selected);
+        }
+        void debugLog({
+            level: "info",
+            event: "install.kits.selected",
+            data: { kits: selectedKits.map((kit) => kit.name) },
+        });
+        // Detect harnesses
+        const harnessSpinner = isInteractive ? startSpinner("Detecting AI harnesses...") : undefined;
+        const allHarnesses = await detectAllHarnesses();
+        const detectedHarnesses = allHarnesses.filter((h) => h.detected);
+        if (harnessSpinner) {
+            const count = detectedHarnesses.length;
+            const message = isInteractive && !options.agent
+                ? "Detected harnesses"
+                : `Found ${formatCount(count, "harness", "harnesses")}`;
+            stopSpinnerSuccess(harnessSpinner, message);
+        }
+        void debugLog({
+            level: "info",
+            event: "install.harnesses.detected",
+            data: { harnesses: detectedHarnesses.map((h) => h.name) },
+        });
+        // Filter by requested harnesses
+        let targetHarnesses = detectedHarnesses;
+        if (options.agent && options.agent.length > 0) {
+            const missing = getMissingHarnesses(detectedHarnesses, options.agent);
+            if (missing.length > 0) {
+                if (isInteractive) {
+                    warnMissingHarnesses(missing);
+                }
+                else if (options.verbose) {
+                    const label = missing.length === 1 ? "Harness" : "Harnesses";
+                    console.error(`Warning: ${label} not detected: ${missing.join(", ")}`);
+                }
+            }
+            targetHarnesses = filterHarnessesByName(detectedHarnesses, options.agent);
+        }
+        // Check if any harnesses are available
+        if (targetHarnesses.length === 0) {
+            const message = "No compatible AI harnesses detected";
+            if (isInteractive) {
+                displayNoHarnessesDetected();
+                outroError("Installation failed");
+            }
+            else if (options.json) {
+                console.log(JSON.stringify({ success: false, error: message }));
+            }
+            else {
+                console.error(`Error: ${message}`);
+            }
+            return { success: false, exitCode: ExitCode.NoHarnessesDetected, error: message };
+        }
+        // Interactive harness selection
+        let selectedHarnesses = targetHarnesses;
+        if (isInteractive && !options.agent) {
+            const result = await selectHarnesses(detectedHarnesses, {
+                showDetected: true,
+                includeAllOption: true,
+            });
+            if (result.cancelled) {
+                outroCancel("Installation cancelled");
+                return { success: false, exitCode: ExitCode.InstallationFailed };
+            }
+            selectedHarnesses = filterHarnessesByName(detectedHarnesses, result.selected);
+        }
+        void debugLog({
+            level: "info",
+            event: "install.harnesses.selected",
+            data: { harnesses: selectedHarnesses.map((h) => h.name) },
+        });
+        // Interactive scope selection
+        let effectiveScope;
+        if (scope) {
+            // Scope specified via CLI flag
+            effectiveScope = scope;
+        }
+        else if (isInteractive) {
+            // Prompt for scope selection
+            const scopeResult = await selectScope({ showInfo: true });
+            if (scopeResult.cancelled) {
+                outroCancel("Installation cancelled");
+                return { success: false, exitCode: ExitCode.InstallationFailed };
+            }
+            effectiveScope = scopeResult.scope;
+        }
+        else {
+            // Default to global scope in non-interactive mode without flag
+            // (This shouldn't happen due to earlier check, but handle gracefully)
+            effectiveScope = "global";
+        }
+        void debugLog({
+            level: "info",
+            event: "install.scope.selected",
+            data: { scope: effectiveScope, projectRoot },
+        });
+        // Compatibility check (after scope selection)
+        const compatibilityHarnesses = selectedHarnesses.map((h) => ({
+            ...h,
+            supportedPrimitives: h.adapter.getSupportedPrimitives(effectiveScope),
+        }));
+        let matrices = buildCompatibilityMatrix(selectedKits, compatibilityHarnesses);
+        let compatResult = {
+            cancelled: false,
+            choice: "proceed",
+        };
+        let compatiblePairs = [];
+        let allowCompatibleOnly = false;
+        if (isInteractive) {
+            const compat = await runCompatibilityCheck(selectedKits, compatibilityHarnesses, effectiveScope, {
+                showMatrix: options.verbose ?? false,
+                promptOnIncompatible: true,
+            });
+            matrices = compat.matrices;
+            compatResult = compat.result;
+            compatiblePairs = compat.compatiblePairs;
+            allowCompatibleOnly = compat.result.choice === "install-compatible";
+        }
+        if (hasIncompatibilities(matrices)) {
+            void debugLog({
+                level: "warn",
+                event: "install.compatibility.failed",
+                data: { scope: effectiveScope },
+            });
+            if (isInteractive) {
+                if (compatResult.cancelled || compatResult.choice === "cancel") {
+                    outroCancel("Installation cancelled");
+                    return { success: false, exitCode: ExitCode.InstallationFailed };
+                }
+                if (compatResult.choice === "go-back") {
+                    outroCancel("Installation cancelled - please run again with different selections");
+                    return { success: false, exitCode: ExitCode.InstallationFailed };
+                }
+                if (compatResult.choice === "install-compatible") {
+                    void debugLog({
+                        level: "info",
+                        event: "install.compatibility.proceed",
+                        data: { mode: "compatible-only", pairs: compatiblePairs.length },
+                    });
+                }
+            }
+            if (!isInteractive || !allowCompatibleOnly) {
+                const message = "No compatible kit-harness combinations for the selected scope";
+                if (options.json) {
+                    console.log(JSON.stringify({ success: false, error: message }));
+                }
+                else if (!isInteractive) {
+                    console.error(`Error: ${message}`);
+                }
+                return { success: false, exitCode: ExitCode.KitIncompatible, error: message };
+            }
+        }
+        void debugLog({
+            level: "info",
+            event: "install.compatibility.ok",
+            data: { scope: effectiveScope },
+        });
+        // Installation summary (interactive only)
+        if (isInteractive && !options.dryRun) {
+            const planKitNames = allowCompatibleOnly
+                ? new Set(compatiblePairs.map((pair) => pair.kit))
+                : new Set(selectedKits.map((kit) => kit.name));
+            const planHarnessNames = allowCompatibleOnly
+                ? new Set(compatiblePairs.map((pair) => pair.harness))
+                : new Set(selectedHarnesses.map((h) => h.name));
+            const planKits = selectedKits.filter((kit) => planKitNames.has(kit.name));
+            const planHarnesses = selectedHarnesses.filter((h) => planHarnessNames.has(h.name));
+            displayInstallPlanSummary(planKits.map((kit) => ({ name: kit.name, version: kit.manifest.version })), planHarnesses.map((h) => ({ displayName: h.displayName })), effectiveScope);
+            const proceed = await confirmInstallPlan();
+            if (proceed.cancelled || !proceed.proceed) {
+                outroCancel("Installation cancelled");
+                return { success: false, exitCode: ExitCode.InstallationFailed };
+            }
+        }
+        // Dry run - show what would be installed
+        if (options.dryRun) {
+            if (options.json) {
+                const output = {
+                    success: true,
+                    source,
+                    scope: effectiveScope,
+                    harnesses: selectedHarnesses.map((h) => ({
+                        name: h.name,
+                        configPath: h.configPath || "",
+                        kits: selectedKits.map((kit) => ({
+                            name: kit.name,
+                            version: kit.manifest.version,
+                            installed: [],
+                        })),
+                    })),
+                    skipped: [],
+                };
+                if (effectiveScope === "project") {
+                    output.projectRoot = projectRoot;
+                }
+                console.log(JSON.stringify(output, null, 2));
+            }
+            else {
+                displayDryRunSummary(selectedKits.map((k) => ({ name: k.name, version: k.manifest.version })), selectedHarnesses.map((h) => ({ name: h.name, displayName: h.displayName })), { scope: effectiveScope, projectRoot });
+            }
+            return { success: true, exitCode: ExitCode.Success };
+        }
+        // Execute installation
+        const installResults = await executeInstallation(selectedKits, selectedHarnesses, discovery, source, {
+            isInteractive,
+            verbose: options.verbose ?? false,
+            json: options.json ?? false,
+            scope: effectiveScope,
+            projectRoot,
+            env: options.env ?? {},
+            mcpInstance: options.mcpInstance ?? {},
+            allowCompatibleOnly,
+            compatiblePairs: allowCompatibleOnly ? compatiblePairs : [],
+        });
+        if (!installResults.success) {
+            const errorMsg = installResults.error || "Installation failed";
+            const exitCode = installResults.exitCode ?? ExitCode.InstallationFailed;
+            void debugLog({
+                level: "error",
+                event: "install.failed",
+                message: errorMsg,
+            });
+            if (isInteractive) {
+                outroError(errorMsg);
+            }
+            else if (options.json) {
+                console.log(JSON.stringify({ success: false, error: errorMsg }));
+            }
+            else {
+                console.error(`Error: ${errorMsg}`);
+            }
+            return { success: false, exitCode, error: errorMsg };
+        }
+        // Success output
+        void debugLog({
+            level: "info",
+            event: "install.success",
+            data: {
+                scope: effectiveScope,
+                harnesses: selectedHarnesses.map((h) => h.name),
+                kits: selectedKits.map((k) => k.name),
+            },
+        });
+        if (options.json) {
+            console.log(JSON.stringify(installResults.output, null, 2));
+        }
+        else if (isInteractive) {
+            outroSuccess("Installation complete!");
+        }
+        const result = { success: true, exitCode: ExitCode.Success };
+        if (installResults.output) {
+            result.output = installResults.output;
+        }
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (isInteractive) {
+            logError(message);
+            outroError("Installation failed");
+        }
+        else if (options.json) {
+            console.log(JSON.stringify({ success: false, error: message }));
+        }
+        else {
+            console.error(`Error: ${message}`);
+        }
+        return { success: false, exitCode: ExitCode.InstallationFailed, error: message };
+    }
+    finally {
+        // Clean up fetched source
+        if (fetchResult?.cleanup) {
+            try {
+                await fetchResult.cleanup();
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}
+/**
+ * Load MCP server config from a resolved primitive's source path.
+ *
+ * @param sourcePath - Path to the MCP primitive directory
+ * @returns MCP server config or null if not found/invalid
+ */
+async function loadMcpConfigFromPath(sourcePath) {
+    const fs = await import("node:fs/promises");
+    // Try config.json in the primitive directory
+    const configPath = path.join(sourcePath, "config.json");
+    try {
+        const content = await fs.readFile(configPath, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        // If config.json doesn't exist, the sourcePath might BE the config file
+        // (for inline primitives that point directly to a config.json)
+        if (sourcePath.endsWith(".json")) {
+            try {
+                const content = await fs.readFile(sourcePath, "utf-8");
+                return JSON.parse(content);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+}
+/**
+ * Collect all environment variable definitions from MCP primitives.
+ *
+ * @param primitives - Resolved primitives (from multiple kits)
+ * @returns Merged record of all env var definitions
+ */
+async function collectAllMcpEnvDefs(primitives) {
+    const configs = [];
+    for (const primitive of primitives) {
+        if (primitive.type !== "mcp")
+            continue;
+        const config = await loadMcpConfigFromPath(primitive.sourcePath);
+        if (config) {
+            configs.push(config);
+        }
+    }
+    return mergeEnvDefs(configs);
+}
+/**
+ * Resolve environment variables for all MCP primitives.
+ *
+ * This function iterates through all MCP primitives and resolves their
+ * environment variable definitions to values using the resolution priority:
+ * 1. Sensitive vars: Always passthrough
+ * 2. CLI --env flags: For nonsensitive vars only
+ * 3. process.env: Current environment value
+ * 4. Default value: If specified
+ * 5. Passthrough: If no value resolved
+ *
+ * @param primitives - Resolved primitives (from multiple kits)
+ * @param cliEnvFlags - CLI --env flag values
+ * @returns Array of env var resolution results for each MCP server
+ */
+async function resolveMcpEnvVars(primitives, cliEnvFlags, instanceOverrides) {
+    const resolutions = [];
+    const seenInstances = new Set();
+    for (const primitive of primitives) {
+        if (primitive.type !== "mcp")
+            continue;
+        const config = await loadMcpConfigFromPath(primitive.sourcePath);
+        if (!config)
+            continue;
+        const instanceName = resolveInstanceName(config.name, primitive.instanceName, instanceOverrides, primitive.kitName);
+        if (!instanceName) {
+            continue;
+        }
+        if (seenInstances.has(instanceName)) {
+            continue;
+        }
+        seenInstances.add(instanceName);
+        const resolution = resolveEnvVarsFromConfig(instanceName, config, cliEnvFlags);
+        resolutions.push(resolution);
+    }
+    return resolutions;
+}
+/**
+ * Build TUI env var requirements from resolution results.
+ *
+ * Converts the resolution results into the format expected by the TUI
+ * prompting system, including sensitivity classification.
+ *
+ * @param resolutions - Env var resolution results from resolveMcpEnvVars
+ * @returns Array of env var requirements for TUI prompting
+ */
+function buildEnvVarRequirements(resolutions) {
+    const requirements = [];
+    const seen = new Set();
+    for (const resolution of resolutions) {
+        for (const resolved of resolution.resolved) {
+            // Deduplicate by name (same var may be used by multiple MCP servers)
+            if (seen.has(resolved.name))
+                continue;
+            seen.add(resolved.name);
+            requirements.push({
+                name: resolved.name,
+                description: resolved.description,
+                required: resolved.required,
+                sensitive: resolved.sensitive,
+                defaultValue: resolved.defaultValue,
+                currentValue: process.env[resolved.name],
+                source: resolution.mcpServer,
+            });
+        }
+    }
+    return requirements;
+}
+/**
+ * Apply TUI prompt results back to resolution results.
+ *
+ * Updates the resolution results with values provided by the user through
+ * the TUI prompting flow. Only updates nonsensitive vars.
+ *
+ * @param resolutions - Original resolution results to update
+ * @param promptResults - Results from TUI prompting
+ */
+function applyPromptResultsToResolutions(resolutions, promptResults) {
+    for (const result of promptResults.variables) {
+        // Update all resolutions that have this var
+        for (const resolution of resolutions) {
+            const resolved = resolution.resolved.find((r) => r.name === result.name);
+            if (!resolved)
+                continue;
+            switch (result.choice) {
+                case "use-existing": {
+                    if ("value" in resolved) {
+                        delete resolved.value;
+                    }
+                    resolved.usePassthrough = true;
+                    resolved.source = "environment";
+                    break;
+                }
+                case "use-default": {
+                    if (result.value !== undefined) {
+                        resolved.value = result.value;
+                    }
+                    else if ("value" in resolved) {
+                        delete resolved.value;
+                    }
+                    resolved.usePassthrough = false;
+                    resolved.source = "default";
+                    break;
+                }
+                case "enter-new": {
+                    if (result.value !== undefined) {
+                        resolved.value = result.value;
+                    }
+                    else if ("value" in resolved) {
+                        delete resolved.value;
+                    }
+                    resolved.usePassthrough = false;
+                    resolved.source = "user-input";
+                    break;
+                }
+                case "skip":
+                default: {
+                    if ("value" in resolved) {
+                        delete resolved.value;
+                    }
+                    resolved.usePassthrough = true;
+                    resolved.source = "passthrough";
+                    break;
+                }
+            }
+            // Remove from missingRequired if now satisfied or passthrough selected
+            const idx = resolution.missingRequired.indexOf(result.name);
+            if (idx !== -1) {
+                resolution.missingRequired.splice(idx, 1);
+            }
+        }
+    }
+}
+function resolveEnvForConfig(config, cliEnvFlags, promptResults, instanceNameOverride) {
+    const resolution = resolveEnvVarsFromConfig(instanceNameOverride ?? config.name, config, cliEnvFlags);
+    if (promptResults) {
+        applyPromptResultsToResolutions([resolution], promptResults);
+    }
+    return resolution;
+}
+function resolveInstanceName(configName, primitiveOverride, cliOverrides, kitName) {
+    const baseName = primitiveOverride ?? configName;
+    if (cliOverrides && kitName && cliOverrides[kitName]?.[baseName]) {
+        return cliOverrides[kitName][baseName];
+    }
+    return baseName;
+}
+function resolveHookInstanceName(programName, primitiveOverride, kitName) {
+    if (primitiveOverride) {
+        return primitiveOverride;
+    }
+    if (kitName) {
+        return `${kitName}.${programName}`;
+    }
+    return programName;
+}
+function buildPrimitiveKey(kitName, sourcePath) {
+    return `${kitName}::${sourcePath}`;
+}
+async function buildMcpPrimitiveInfoBySourcePath(resolvedByKit, cliEnvFlags, promptResults, instanceOverrides) {
+    const infoBySourcePath = new Map();
+    for (const [kitName, primitives] of resolvedByKit.entries()) {
+        for (const primitive of primitives) {
+            if (primitive.type !== "mcp")
+                continue;
+            const key = buildPrimitiveKey(kitName, primitive.sourcePath);
+            if (infoBySourcePath.has(key))
+                continue;
+            const config = await loadMcpConfigFromPath(primitive.sourcePath);
+            if (!config?.name)
+                continue;
+            const instanceName = resolveInstanceName(config.name, primitive.instanceName, instanceOverrides, kitName);
+            const resolution = resolveEnvForConfig(config, cliEnvFlags, promptResults, instanceName);
+            const configHash = hashMcpConfig(config, resolution.resolved, resolution.resolvedHeaders);
+            infoBySourcePath.set(key, {
+                instanceName,
+                configHash,
+                config,
+                resolvedEnv: resolution.resolved,
+                resolvedHeaders: resolution.resolvedHeaders,
+                primitiveName: primitive.name,
+                version: primitive.resolvedVersion ?? config.version,
+                configName: config.name,
+            });
+        }
+    }
+    return infoBySourcePath;
+}
+async function buildHookPrimitiveInfoBySourcePath(resolvedByKit) {
+    const infoBySourcePath = new Map();
+    for (const [kitName, primitives] of resolvedByKit.entries()) {
+        for (const primitive of primitives) {
+            if (primitive.type !== "hooks")
+                continue;
+            if (!primitive.hookProgram || !primitive.hookBinding)
+                continue;
+            const key = buildPrimitiveKey(kitName, primitive.sourcePath);
+            if (infoBySourcePath.has(key))
+                continue;
+            const instanceName = resolveHookInstanceName(primitive.hookProgram.name ?? primitive.name, primitive.instanceName, kitName);
+            const configHash = hashHookConfig(primitive.hookProgram, primitive.hookBinding);
+            infoBySourcePath.set(key, {
+                instanceName,
+                configHash,
+                program: primitive.hookProgram,
+                binding: primitive.hookBinding,
+                primitiveName: primitive.name,
+                version: primitive.resolvedVersion ?? primitive.hookProgram.version,
+            });
+        }
+    }
+    return infoBySourcePath;
+}
+async function buildMcpUsageByInstance(resolvedByKit, instanceOverrides) {
+    const usage = new Map();
+    for (const [kitName, primitives] of resolvedByKit.entries()) {
+        for (const primitive of primitives) {
+            if (primitive.type !== "mcp")
+                continue;
+            const config = await loadMcpConfigFromPath(primitive.sourcePath);
+            if (!config?.name)
+                continue;
+            const instanceName = resolveInstanceName(config.name, primitive.instanceName, instanceOverrides, kitName);
+            const existing = usage.get(instanceName);
+            if (existing) {
+                existing.add(kitName);
+            }
+            else {
+                usage.set(instanceName, new Set([kitName]));
+            }
+        }
+    }
+    return usage;
+}
+function getMcpConfigPath(adapter, scope, projectRoot) {
+    const configLocations = adapter.getConfigLocations(scope);
+    const mcpPath = configLocations.mcp || configLocations.primary;
+    if (scope === "project" && projectRoot) {
+        return path.join(projectRoot, mcpPath.replace(/^\.\//, ""));
+    }
+    return expandPath(mcpPath);
+}
+function getHookConfigPath(adapter, scope, projectRoot) {
+    const paths = adapter.getInstallationPaths(scope);
+    const hookPath = paths.hooks ?? adapter.getConfigLocations(scope).primary;
+    if (scope === "project" && projectRoot) {
+        return path.join(projectRoot, hookPath.replace(/^\.\//, ""));
+    }
+    return expandPath(hookPath);
+}
+async function promptMcpConflictResolution(options) {
+    const choice = await clack.select({
+        message: `MCP instance "${options.instanceName}" already exists in ${options.harnessDisplayName} with different configuration. How would you like to proceed?`,
+        options: [
+            { value: "reuse", label: "Reuse existing instance" },
+            { value: "fork", label: "Create a new instance name" },
+            { value: "cancel", label: "Cancel installation" },
+        ],
+    });
+    if (clack.isCancel(choice)) {
+        return "cancel";
+    }
+    return choice;
+}
+async function promptForMcpInstanceName(instanceName, usedNames) {
+    while (true) {
+        const value = await clack.text({
+            message: `Enter a new name for "${instanceName}":`,
+            placeholder: `${instanceName}-alt`,
+        });
+        if (clack.isCancel(value)) {
+            return null;
+        }
+        const trimmed = String(value).trim();
+        if (!trimmed) {
+            clack.log.warn("Instance name cannot be empty.");
+            continue;
+        }
+        if (usedNames.has(trimmed)) {
+            clack.log.warn(`Instance name "${trimmed}" is already in use.`);
+            continue;
+        }
+        return trimmed;
+    }
+}
+/**
+ * Execute the actual installation of kits to harnesses.
+ */
+async function executeInstallation(kits, harnesses, discovery, source, options) {
+    const { isInteractive, verbose, scope, projectRoot, env, mcpInstance, allowCompatibleOnly = false, compatiblePairs = [], } = options;
+    // Load or create primitives registry loader
+    let registryLoader = null;
+    if (discovery.primitivesRegistry) {
+        registryLoader = new PrimitivesRegistryLoader(discovery.localPath);
+        await registryLoader.load();
+    }
+    // Pre-pass: resolve all primitives to collect MCP env var definitions for validation
+    const allResolvedPrimitives = [];
+    const resolvedByKit = new Map();
+    const resolutionFailures = [];
+    for (const kit of kits) {
+        if (registryLoader) {
+            const kitBasePath = path.join(discovery.localPath, kit.path);
+            const resolution = await resolvePrimitiveReferences(kit.manifest, registryLoader, kitBasePath);
+            if (resolution.errors.length > 0) {
+                resolutionFailures.push({
+                    kit: kit.name,
+                    errors: resolution.errors.map((e) => e.message),
+                });
+                continue;
+            }
+            resolvedByKit.set(kit.name, resolution.primitives);
+            allResolvedPrimitives.push(...resolution.primitives);
+        }
+        else {
+            const inlinePrimitives = resolveInlinePrimitivesOnly(kit, discovery.localPath);
+            resolvedByKit.set(kit.name, inlinePrimitives);
+            allResolvedPrimitives.push(...inlinePrimitives);
+        }
+    }
+    if (resolutionFailures.length > 0) {
+        const details = resolutionFailures
+            .map((f) => `${f.kit}: ${f.errors.join("; ")}`)
+            .join(" | ");
+        return {
+            success: false,
+            exitCode: ExitCode.ResolutionFailed,
+            error: `Resolution failed: ${details}`,
+        };
+    }
+    // Collect all MCP env var definitions for validation
+    const allEnvDefs = await collectAllMcpEnvDefs(allResolvedPrimitives);
+    // Validate --env flags against sensitive vars (exit code 13)
+    if (env && Object.keys(env).length > 0) {
+        const invalidFlags = validateCliEnvFlags(env, allEnvDefs);
+        if (invalidFlags.length > 0) {
+            const message = `Cannot provide sensitive variables via --env flag: ${invalidFlags.join(", ")}. Sensitive variables must be set in your shell environment.`;
+            return {
+                success: false,
+                exitCode: ExitCode.SensitiveEnvVarProvided,
+                error: message,
+            };
+        }
+    }
+    // In non-interactive mode, validate required nonsensitive vars are provided (exit code 12)
+    if (!isInteractive) {
+        // Check for missing required nonsensitive vars
+        // A var is considered "provided" if it's in --env flags, process.env, or has a default
+        const missingRequired = [];
+        for (const [name, def] of Object.entries(allEnvDefs)) {
+            // Skip sensitive vars (they're always passthrough, handled differently)
+            if (def.sensitive)
+                continue;
+            // Skip if not required
+            if (!def.required)
+                continue;
+            // Check if value is available from any source
+            const hasCliValue = env && name in env;
+            const hasEnvValue = !!process.env[name];
+            const hasDefault = def.default !== undefined;
+            if (!hasCliValue && !hasEnvValue && !hasDefault) {
+                missingRequired.push(name);
+            }
+        }
+        if (missingRequired.length > 0) {
+            const message = `Required environment variables not provided: ${missingRequired.join(", ")}. Use --env KEY=VALUE to provide values, or run interactively.`;
+            return {
+                success: false,
+                exitCode: ExitCode.EnvVarRequired,
+                error: message,
+            };
+        }
+    }
+    let effectiveMcpInstance = mcpInstance ?? {};
+    if (isInteractive) {
+        const usage = await buildMcpUsageByInstance(resolvedByKit, effectiveMcpInstance);
+        const sharedPrompt = await promptForSharedMcpInstances(usage, effectiveMcpInstance);
+        if (sharedPrompt.cancelled) {
+            return {
+                success: false,
+                exitCode: ExitCode.UserCancelled,
+                error: "Environment variable configuration cancelled",
+            };
+        }
+        if (Object.keys(sharedPrompt.overrides).length > 0) {
+            for (const [kitName, overrides] of Object.entries(sharedPrompt.overrides)) {
+                if (!effectiveMcpInstance[kitName]) {
+                    effectiveMcpInstance[kitName] = {};
+                }
+                for (const [instanceName, override] of Object.entries(overrides)) {
+                    if (!effectiveMcpInstance[kitName][instanceName]) {
+                        effectiveMcpInstance[kitName][instanceName] = override;
+                    }
+                }
+            }
+        }
+    }
+    // Resolve environment variables for all MCP primitives
+    const envResolutions = await resolveMcpEnvVars(allResolvedPrimitives, env, effectiveMcpInstance);
+    let envPromptResults;
+    // Interactive mode: prompt for nonsensitive vars
+    if (isInteractive && envResolutions.length > 0) {
+        const requirements = buildEnvVarRequirements(envResolutions);
+        if (requirements.length > 0) {
+            logInfo("Configuring environment variables for MCP servers...");
+            const sourceToKits = await buildMcpUsageByInstance(resolvedByKit, effectiveMcpInstance);
+            const promptResults = await promptForEnvVars(requirements, {
+                sourceToKits,
+                skipSatisfied: false,
+                skipOptional: false,
+            });
+            if (promptResults.cancelled) {
+                return {
+                    success: false,
+                    exitCode: ExitCode.UserCancelled,
+                    error: "Environment variable configuration cancelled",
+                };
+            }
+            envPromptResults = promptResults;
+            applyPromptResultsToResolutions(envResolutions, promptResults);
+        }
+    }
+    // Read or create manifest for the specified scope
+    let manifest = await readManifest(scope, scope === "project" ? projectRoot : undefined);
+    if (!manifest) {
+        manifest = createEmptyManifest(scope, scope === "project" ? projectRoot : undefined);
+    }
+    manifest.source = source;
+    const harnessResults = [];
+    const skippedResults = [];
+    const compatibleKitsByHarness = new Map();
+    for (const pair of compatiblePairs) {
+        const existing = compatibleKitsByHarness.get(pair.harness);
+        if (existing) {
+            existing.add(pair.kit);
+        }
+        else {
+            compatibleKitsByHarness.set(pair.harness, new Set([pair.kit]));
+        }
+    }
+    const mcpInfoByPrimitiveKey = await buildMcpPrimitiveInfoBySourcePath(resolvedByKit, env, envPromptResults, effectiveMcpInstance);
+    const mcpAssignmentsByHarness = new Map();
+    const mcpForkedInstancesByHarness = new Map();
+    const mcpInstancesToInstallByHarness = new Map();
+    const hookInfoByPrimitiveKey = await buildHookPrimitiveInfoBySourcePath(resolvedByKit);
+    const hookAssignmentsByHarness = new Map();
+    const hookInstancesToInstallByHarness = new Map();
+    for (const harness of harnesses) {
+        const kitsToCheck = allowCompatibleOnly
+            ? kits.filter((kit) => compatibleKitsByHarness.get(harness.name)?.has(kit.name))
+            : kits;
+        if (kitsToCheck.length === 0 || mcpInfoByPrimitiveKey.size === 0) {
+            continue;
+        }
+        const desiredByName = new Map();
+        for (const kit of kitsToCheck) {
+            const primitives = resolvedByKit.get(kit.name) ?? [];
+            for (const primitive of primitives) {
+                if (primitive.type !== "mcp")
+                    continue;
+                const key = buildPrimitiveKey(kit.name, primitive.sourcePath);
+                const info = mcpInfoByPrimitiveKey.get(key);
+                if (!info)
+                    continue;
+                const byHash = desiredByName.get(info.instanceName) ?? new Map();
+                const entry = byHash.get(info.configHash) ?? {
+                    primitives: [],
+                    kits: new Set(),
+                    info,
+                };
+                entry.primitives.push({ primitive, kitName: kit.name });
+                entry.kits.add(kit.name);
+                byHash.set(info.configHash, entry);
+                desiredByName.set(info.instanceName, byHash);
+            }
+        }
+        for (const [instanceName, byHash] of desiredByName) {
+            if (byHash.size > 1) {
+                const message = `Conflicting MCP server configs detected for instance "${instanceName}". ` +
+                    "Resolve the conflict by renaming one of the MCP server instances.";
+                return {
+                    success: false,
+                    exitCode: ExitCode.InstallationFailed,
+                    error: message,
+                };
+            }
+        }
+        const existingInstances = manifest.harnesses[harness.name]?.mcpInstances ?? {};
+        const usedInstanceNames = new Set(Object.keys(existingInstances));
+        const assignments = new Map();
+        const forkedInstances = new Map();
+        const instancesToInstall = new Set();
+        for (const [instanceName, byHash] of desiredByName) {
+            const candidate = Array.from(byHash.values())[0];
+            let finalName = instanceName;
+            let finalHash = candidate.info.configHash;
+            let action = "install";
+            const existing = existingInstances[instanceName];
+            if (existing) {
+                if (existing.configHash === candidate.info.configHash) {
+                    action = "reuse";
+                    finalHash = existing.configHash;
+                }
+                else {
+                    if (!isInteractive) {
+                        return {
+                            success: false,
+                            exitCode: ExitCode.InstallationFailed,
+                            error: `MCP instance "${instanceName}" already exists in ${harness.displayName} with a different configuration.`,
+                        };
+                    }
+                    const decision = await promptMcpConflictResolution({
+                        instanceName,
+                        harnessDisplayName: harness.displayName,
+                    });
+                    if (decision === "cancel") {
+                        return {
+                            success: false,
+                            exitCode: ExitCode.UserCancelled,
+                            error: "Installation cancelled",
+                        };
+                    }
+                    if (decision === "reuse") {
+                        action = "reuse";
+                        finalHash = existing.configHash;
+                    }
+                    else {
+                        const newName = await promptForMcpInstanceName(instanceName, usedInstanceNames);
+                        if (!newName) {
+                            return {
+                                success: false,
+                                exitCode: ExitCode.UserCancelled,
+                                error: "Installation cancelled",
+                            };
+                        }
+                        finalName = newName;
+                        action = "install";
+                        finalHash = candidate.info.configHash;
+                    }
+                }
+            }
+            if (action === "install") {
+                instancesToInstall.add(finalName);
+                usedInstanceNames.add(finalName);
+            }
+            for (const { primitive, kitName } of candidate.primitives) {
+                const key = buildPrimitiveKey(kitName, primitive.sourcePath);
+                assignments.set(key, {
+                    instanceName: finalName,
+                    configHash: finalHash,
+                    action,
+                });
+                if (finalName !== candidate.info.instanceName) {
+                    forkedInstances.set(finalName, candidate.info.instanceName);
+                }
+            }
+        }
+        if (assignments.size > 0) {
+            mcpAssignmentsByHarness.set(harness.name, assignments);
+        }
+        if (forkedInstances.size > 0) {
+            mcpForkedInstancesByHarness.set(harness.name, forkedInstances);
+        }
+        if (instancesToInstall.size > 0) {
+            mcpInstancesToInstallByHarness.set(harness.name, instancesToInstall);
+        }
+    }
+    if (envResolutions.length > 0 && mcpForkedInstancesByHarness.size > 0) {
+        const addedOverrides = new Set();
+        for (const forkedInstances of mcpForkedInstancesByHarness.values()) {
+            for (const [overrideName, baseName] of forkedInstances.entries()) {
+                if (addedOverrides.has(overrideName))
+                    continue;
+                const base = envResolutions.find((r) => r.mcpServer === baseName);
+                if (!base)
+                    continue;
+                envResolutions.push({
+                    mcpServer: overrideName,
+                    resolved: [...base.resolved],
+                    resolvedHeaders: [...base.resolvedHeaders],
+                    missingRequired: [...base.missingRequired],
+                    warnings: [...base.warnings],
+                });
+                addedOverrides.add(overrideName);
+            }
+        }
+    }
+    for (const harness of harnesses) {
+        const kitsToCheck = allowCompatibleOnly
+            ? kits.filter((kit) => compatibleKitsByHarness.get(harness.name)?.has(kit.name))
+            : kits;
+        if (kitsToCheck.length === 0 || hookInfoByPrimitiveKey.size === 0) {
+            continue;
+        }
+        const desiredByName = new Map();
+        for (const kit of kitsToCheck) {
+            const primitives = resolvedByKit.get(kit.name) ?? [];
+            for (const primitive of primitives) {
+                if (primitive.type !== "hooks")
+                    continue;
+                const key = buildPrimitiveKey(kit.name, primitive.sourcePath);
+                const info = hookInfoByPrimitiveKey.get(key);
+                if (!info)
+                    continue;
+                const byHash = desiredByName.get(info.instanceName) ?? new Map();
+                const entry = byHash.get(info.configHash) ?? {
+                    primitives: [],
+                    kits: new Set(),
+                    info,
+                };
+                entry.primitives.push({ primitive, kitName: kit.name });
+                entry.kits.add(kit.name);
+                byHash.set(info.configHash, entry);
+                desiredByName.set(info.instanceName, byHash);
+            }
+        }
+        for (const [instanceName, byHash] of desiredByName) {
+            if (byHash.size > 1) {
+                const message = `Conflicting hook configs detected for instance "${instanceName}". ` +
+                    "Resolve the conflict by renaming one of the hook instances.";
+                return {
+                    success: false,
+                    exitCode: ExitCode.InstallationFailed,
+                    error: message,
+                };
+            }
+        }
+        const existingInstances = manifest.harnesses[harness.name]?.hookInstances ?? {};
+        const assignments = new Map();
+        const instancesToInstall = new Set();
+        for (const [instanceName, byHash] of desiredByName) {
+            const candidate = Array.from(byHash.values())[0];
+            let action = "install";
+            let finalHash = candidate.info.configHash;
+            const existing = existingInstances[instanceName];
+            if (existing) {
+                if (existing.configHash !== candidate.info.configHash) {
+                    return {
+                        success: false,
+                        exitCode: ExitCode.InstallationFailed,
+                        error: `Hook instance "${instanceName}" already exists in ${harness.displayName} with a different configuration.`,
+                    };
+                }
+                action = "reuse";
+                finalHash = existing.configHash;
+            }
+            if (action === "install") {
+                instancesToInstall.add(instanceName);
+            }
+            for (const { primitive, kitName } of candidate.primitives) {
+                const key = buildPrimitiveKey(kitName, primitive.sourcePath);
+                assignments.set(key, {
+                    instanceName,
+                    configHash: finalHash,
+                    action,
+                });
+            }
+        }
+        if (assignments.size > 0) {
+            hookAssignmentsByHarness.set(harness.name, assignments);
+        }
+        if (instancesToInstall.size > 0) {
+            hookInstancesToInstallByHarness.set(harness.name, instancesToInstall);
+        }
+    }
+    // Install to each harness
+    for (const harness of harnesses) {
+        const kitsToInstall = allowCompatibleOnly
+            ? kits.filter((kit) => compatibleKitsByHarness.get(harness.name)?.has(kit.name))
+            : kits;
+        if (kitsToInstall.length === 0) {
+            continue;
+        }
+        const mcpAssignments = mcpAssignmentsByHarness.get(harness.name);
+        const mcpInstancesToInstall = mcpInstancesToInstallByHarness.get(harness.name);
+        const hookAssignments = hookAssignmentsByHarness.get(harness.name);
+        const hookInstancesToInstall = hookInstancesToInstallByHarness.get(harness.name);
+        if (isInteractive) {
+            logInfo(`Installing to ${harness.displayName}...`);
+        }
+        else if (verbose) {
+            console.error(`Installing to ${harness.displayName}...`);
+        }
+        const kitResults = [];
+        for (const kit of kitsToInstall) {
+            // Check compatibility with scope (should already be validated)
+            const compatibility = harness.adapter.checkCompatibility(kit.manifest, scope);
+            if (!compatibility.compatible) {
+                if (allowCompatibleOnly) {
+                    continue;
+                }
+                return {
+                    success: false,
+                    exitCode: ExitCode.KitIncompatible,
+                    error: compatibility.message || "Incompatible kit-harness combination",
+                };
+            }
+            // Use resolved primitives from pre-pass
+            const resolvedPrimitives = resolvedByKit.get(kit.name);
+            if (!resolvedPrimitives) {
+                return {
+                    success: false,
+                    exitCode: ExitCode.ResolutionFailed,
+                    error: `Resolution failed: no primitives resolved for ${kit.name}`,
+                };
+            }
+            const mcpConfigPath = getMcpConfigPath(harness.adapter, scope, projectRoot);
+            const hookConfigPath = getHookConfigPath(harness.adapter, scope, projectRoot);
+            const primitivesForAdapter = [];
+            const skippedMcpPrimitives = [];
+            const skippedHookPrimitives = [];
+            const installedInstanceNames = new Set();
+            const installedHookInstanceNames = new Set();
+            for (const primitive of resolvedPrimitives) {
+                if (primitive.type === "mcp" && mcpAssignments) {
+                    const assignment = mcpAssignments.get(buildPrimitiveKey(kit.name, primitive.sourcePath));
+                    if (!assignment) {
+                        primitivesForAdapter.push(primitive);
+                        continue;
+                    }
+                    const canInstall = assignment.action === "install";
+                    const shouldInstall = canInstall &&
+                        (!mcpInstancesToInstall || mcpInstancesToInstall.has(assignment.instanceName));
+                    if (!shouldInstall) {
+                        skippedMcpPrimitives.push(primitive);
+                        continue;
+                    }
+                    primitivesForAdapter.push({ ...primitive, instanceName: assignment.instanceName });
+                    installedInstanceNames.add(assignment.instanceName);
+                    continue;
+                }
+                if (primitive.type === "hooks" && hookAssignments) {
+                    const assignment = hookAssignments.get(buildPrimitiveKey(kit.name, primitive.sourcePath));
+                    if (!assignment) {
+                        primitivesForAdapter.push(primitive);
+                        continue;
+                    }
+                    const canInstall = assignment.action === "install";
+                    const shouldInstall = canInstall &&
+                        (!hookInstancesToInstall || hookInstancesToInstall.has(assignment.instanceName));
+                    if (!shouldInstall) {
+                        skippedHookPrimitives.push(primitive);
+                        continue;
+                    }
+                    primitivesForAdapter.push({ ...primitive, instanceName: assignment.instanceName });
+                    installedHookInstanceNames.add(assignment.instanceName);
+                    continue;
+                }
+                primitivesForAdapter.push(primitive);
+            }
+            // Install the kit
+            const installOptions = {
+                backup: true,
+                createDirs: true,
+                scope,
+                envResolutions, // Pass resolved env vars to adapter (Phase 6)
+                onProgress: (progress) => {
+                    if (verbose) {
+                        const primitiveInfo = progress.primitive ? ` ${progress.primitive}` : "";
+                        console.error(`  [${progress.phase}] ${progress.operation}${primitiveInfo}`);
+                    }
+                },
+            };
+            if (scope === "project") {
+                installOptions.projectRoot = projectRoot;
+            }
+            const installResult = await harness.adapter.install(kit.manifest, primitivesForAdapter, installOptions);
+            if (!installResult.success) {
+                skippedResults.push({
+                    kit: kit.name,
+                    harness: harness.name,
+                    reason: installResult.error || "Installation failed",
+                });
+                continue;
+            }
+            for (const instanceName of installedInstanceNames) {
+                mcpInstancesToInstall?.delete(instanceName);
+            }
+            for (const instanceName of installedHookInstanceNames) {
+                hookInstancesToInstall?.delete(instanceName);
+            }
+            if (skippedMcpPrimitives.length > 0) {
+                for (const primitive of skippedMcpPrimitives) {
+                    const namespacedName = harness.adapter.getNamespacedName(kit.name, primitive.name);
+                    const status = {
+                        type: primitive.type,
+                        name: primitive.name,
+                        namespacedName,
+                        status: "unchanged",
+                        destination: mcpConfigPath,
+                    };
+                    if (primitive.ref) {
+                        status.ref = primitive.ref;
+                    }
+                    if (primitive.resolvedVersion) {
+                        status.resolvedVersion = primitive.resolvedVersion;
+                    }
+                    installResult.installedPrimitives.push(status);
+                }
+            }
+            if (skippedHookPrimitives.length > 0) {
+                for (const primitive of skippedHookPrimitives) {
+                    const namespacedName = harness.adapter.getNamespacedName(kit.name, primitive.name);
+                    const status = {
+                        type: primitive.type,
+                        name: primitive.name,
+                        namespacedName,
+                        status: "unchanged",
+                        destination: hookConfigPath,
+                    };
+                    if (primitive.ref) {
+                        status.ref = primitive.ref;
+                    }
+                    if (primitive.resolvedVersion) {
+                        status.resolvedVersion = primitive.resolvedVersion;
+                    }
+                    installResult.installedPrimitives.push(status);
+                }
+            }
+            // Record in manifest
+            if (!manifest.harnesses[harness.name]) {
+                manifest.harnesses[harness.name] = { kits: {} };
+            }
+            const statusByKey = new Map();
+            for (const status of installResult.installedPrimitives) {
+                statusByKey.set(`${status.type}:${status.name}`, status);
+            }
+            const installedPrimitives = resolvedPrimitives.map((primitive) => {
+                const key = `${primitive.type}:${primitive.name}`;
+                const status = statusByKey.get(key);
+                const namespacedName = status?.namespacedName
+                    ?? harness.adapter.getNamespacedName(kit.name, primitive.name);
+                const installedPath = status?.destination
+                    ?? (primitive.type === "mcp" ? mcpConfigPath : "");
+                const installed = {
+                    name: primitive.name,
+                    type: primitive.type,
+                    namespacedName,
+                    isInline: !primitive.ref,
+                    installedPath,
+                };
+                if (primitive.resolvedVersion) {
+                    installed.version = primitive.resolvedVersion;
+                }
+                if (primitive.ref) {
+                    // Extract version spec from ref (e.g., "tf-plan@^1.0.0" -> "^1.0.0")
+                    const atIndex = primitive.ref.indexOf("@");
+                    if (atIndex !== -1) {
+                        installed.versionSpec = primitive.ref.substring(atIndex + 1);
+                    }
+                }
+                if (primitive.type === "mcp") {
+                    const assignment = mcpAssignments?.get(buildPrimitiveKey(kit.name, primitive.sourcePath));
+                    if (assignment) {
+                        installed.instanceName = assignment.instanceName;
+                        installed.configHash = assignment.configHash;
+                    }
+                }
+                if (primitive.type === "hooks") {
+                    const assignment = hookAssignments?.get(buildPrimitiveKey(kit.name, primitive.sourcePath));
+                    if (assignment) {
+                        installed.instanceName = assignment.instanceName;
+                        installed.configHash = assignment.configHash;
+                    }
+                }
+                return installed;
+            });
+            const installedKit = {
+                version: kit.manifest.version,
+                installedAt: new Date().toISOString(),
+                source,
+                primitives: installedPrimitives,
+            };
+            manifest.harnesses[harness.name].kits[kit.name] = installedKit;
+            if (mcpAssignments && mcpInfoByPrimitiveKey.size > 0) {
+                const harnessEntry = manifest.harnesses[harness.name];
+                if (!harnessEntry.mcpInstances) {
+                    harnessEntry.mcpInstances = {};
+                }
+                for (const primitive of resolvedPrimitives) {
+                    if (primitive.type !== "mcp")
+                        continue;
+                    const assignment = mcpAssignments.get(buildPrimitiveKey(kit.name, primitive.sourcePath));
+                    if (!assignment)
+                        continue;
+                    const instanceName = assignment.instanceName;
+                    const existingInstance = harnessEntry.mcpInstances[instanceName];
+                    if (existingInstance) {
+                        if (!existingInstance.usedBy.includes(kit.name)) {
+                            existingInstance.usedBy.push(kit.name);
+                        }
+                        continue;
+                    }
+                    const info = mcpInfoByPrimitiveKey.get(buildPrimitiveKey(kit.name, primitive.sourcePath));
+                    if (!info)
+                        continue;
+                    harnessEntry.mcpInstances[instanceName] = {
+                        version: info.version,
+                        configHash: assignment.configHash,
+                        usedBy: [kit.name],
+                        sourcePrimitive: info.primitiveName,
+                        installedAt: new Date().toISOString(),
+                    };
+                }
+            }
+            if (hookAssignments && hookInfoByPrimitiveKey.size > 0) {
+                const harnessEntry = manifest.harnesses[harness.name];
+                if (!harnessEntry.hookInstances) {
+                    harnessEntry.hookInstances = {};
+                }
+                for (const primitive of resolvedPrimitives) {
+                    if (primitive.type !== "hooks")
+                        continue;
+                    const assignment = hookAssignments.get(buildPrimitiveKey(kit.name, primitive.sourcePath));
+                    if (!assignment)
+                        continue;
+                    const instanceName = assignment.instanceName;
+                    const existingInstance = harnessEntry.hookInstances[instanceName];
+                    if (existingInstance) {
+                        if (!existingInstance.usedBy.includes(kit.name)) {
+                            existingInstance.usedBy.push(kit.name);
+                        }
+                        continue;
+                    }
+                    const info = hookInfoByPrimitiveKey.get(buildPrimitiveKey(kit.name, primitive.sourcePath));
+                    if (!info)
+                        continue;
+                    harnessEntry.hookInstances[instanceName] = {
+                        version: info.version,
+                        configHash: assignment.configHash,
+                        usedBy: [kit.name],
+                        sourcePrimitive: info.primitiveName,
+                        installedAt: new Date().toISOString(),
+                    };
+                }
+            }
+            // Build result for output
+            kitResults.push({
+                name: kit.name,
+                version: kit.manifest.version,
+                installed: installResult.installedPrimitives.map((p) => {
+                    const primitiveOutput = {
+                        type: p.type,
+                        name: p.name,
+                        namespacedName: p.namespacedName,
+                        status: p.status,
+                    };
+                    if (p.resolvedVersion) {
+                        primitiveOutput.version = p.resolvedVersion;
+                    }
+                    return primitiveOutput;
+                }),
+            });
+            if (isInteractive) {
+                logInfo(`${formatKit(kit.name, kit.manifest.version)} ${pc.green("✓")}`);
+            }
+        }
+        if (kitResults.length > 0) {
+            harnessResults.push({
+                name: harness.name,
+                configPath: harness.configPath || "",
+                kits: kitResults,
+            });
+        }
+    }
+    // Write manifest
+    try {
+        await writeManifest(manifest, scope, scope === "project" ? projectRoot : undefined);
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to write manifest: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    // Build output
+    const output = {
+        success: true,
+        source,
+        scope,
+        harnesses: harnessResults,
+        skipped: skippedResults,
+    };
+    if (scope === "project") {
+        output.projectRoot = projectRoot;
+    }
+    // Add env var status to output (Phase 6)
+    if (envResolutions.length > 0) {
+        const configured = [];
+        const passthrough = [];
+        const warnings = [];
+        for (const resolution of envResolutions) {
+            for (const resolved of resolution.resolved) {
+                if (resolved.usePassthrough) {
+                    passthrough.push({
+                        name: resolved.name,
+                        sensitive: resolved.sensitive,
+                        mcpServer: resolution.mcpServer,
+                    });
+                }
+                else if (resolved.value !== undefined) {
+                    configured.push({
+                        name: resolved.name,
+                        source: resolved.source,
+                        mcpServer: resolution.mcpServer,
+                    });
+                }
+            }
+            for (const warning of resolution.warnings) {
+                warnings.push({
+                    name: warning.name,
+                    message: warning.message,
+                    type: warning.type,
+                });
+            }
+        }
+        // Only include if there's content
+        if (configured.length > 0 || passthrough.length > 0 || warnings.length > 0) {
+            output.envVars = { configured, passthrough, warnings };
+        }
+    }
+    return { success: true, output };
+}
+/**
+ * Resolve inline primitives only (when no primitives registry exists).
+ */
+function resolveInlinePrimitivesOnly(kit, localPath) {
+    const resolved = [];
+    const kitBasePath = path.join(localPath, kit.path);
+    for (const [type, primitives] of Object.entries(kit.manifest.primitives)) {
+        if (!primitives)
+            continue;
+        for (const primitive of primitives) {
+            // Only handle inline primitives
+            if ("name" in primitive && "entrypoint" in primitive) {
+                resolved.push({
+                    kitName: kit.name,
+                    name: primitive.name,
+                    type: type,
+                    sourcePath: path.resolve(kitBasePath, primitive.entrypoint),
+                    isInline: true,
+                    metadata: primitive.description ? { description: primitive.description } : {},
+                    instanceName: primitive.instanceName,
+                });
+            }
+        }
+    }
+    return resolved;
+}
+//# sourceMappingURL=install.js.map