@hashicorp/kits 0.1.5 → 0.1.8

package/dist/cli/install.js

@@ -7,12 +7,13 @@
 import { ExitCode } from "./types.js";
 import * as clack from "@clack/prompts";
 import fs from "node:fs/promises";
+import os from "node:os";
 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 { hashHookProgram } from "../core/hook-instance.js";
 import { readLockfile } from "../lockfile/read.js";
 import { writeLockfile } from "../lockfile/write.js";
 import { createEmptyLockfile, } from "../lockfile/types.js";
@@ -131,16 +132,18 @@ async function resolveManifestTarget(source) {
 }
 function buildLockedVersionMap(lockfile) {
     const locked = new Map();
-    for (const harnessEntry of Object.values(lockfile.harnesses)) {
-        if (!harnessEntry)
-            continue;
-        for (const kit of Object.values(harnessEntry.kits)) {
-            for (const primitive of kit.primitives) {
-                if (!primitive.version)
-                    continue;
-                const key = `${primitive.type}:${primitive.name}`;
-                if (!locked.has(key)) {
-                    locked.set(key, primitive.version);
+    for (const kit of Object.values(lockfile.kits)) {
+        for (const harnessEntry of Object.values(kit.harnesses)) {
+            if (!harnessEntry)
+                continue;
+            for (const [type, primitives] of Object.entries(harnessEntry.primitives)) {
+                for (const primitive of primitives ?? []) {
+                    if (!primitive.version)
+                        continue;
+                    const key = `${type}:${primitive.name}`;
+                    if (!locked.has(key)) {
+                        locked.set(key, primitive.version);
+                    }
                 }
             }
         }
@@ -282,6 +285,20 @@ export async function runInstall(source, options) {
         }
         return { success: false, exitCode: ExitCode.ScopeRequired, error: message };
     }
+    if (scope === "project") {
+        const resolvedProjectRoot = path.resolve(projectRoot);
+        const homeDir = path.resolve(os.homedir());
+        if (resolvedProjectRoot === homeDir) {
+            const message = "Project scope installs are not allowed in the home directory.";
+            if (options.json) {
+                console.log(JSON.stringify({ success: false, error: message }));
+            }
+            else {
+                console.error(`Error: ${message}`);
+            }
+            return { success: false, exitCode: ExitCode.InvalidArguments, error: message };
+        }
+    }
     try {
         // Start interactive UI if applicable
         if (isInteractive) {
@@ -706,25 +723,19 @@ export async function runInstall(source, options) {
             : undefined;
         const outputSource = manifestInstall && manifestPath ? manifestPath : source;
         const overwriteTargets = new Map();
-        const existingInstances = new Set();
-        for (const harness of selectedHarnesses) {
-            const harnessEntry = lockfile.harnesses[harness.name];
-            if (!harnessEntry)
-                continue;
-            for (const instanceName of Object.keys(harnessEntry.kits)) {
-                existingInstances.add(instanceName);
-            }
-        }
+        const existingInstances = new Set(Object.keys(lockfile.kits));
         const usedInstanceNames = new Set(selectedKits.map((kit) => kit.installAs));
         for (const kit of selectedKits) {
             const collidingHarnesses = [];
             const existingKits = [];
-            for (const harness of selectedHarnesses) {
-                const existing = lockfile.harnesses[harness.name]?.kits[kit.installAs];
-                if (!existing)
-                    continue;
-                collidingHarnesses.push(harness.name);
-                existingKits.push(existing);
+            const existingKit = lockfile.kits[kit.installAs];
+            if (existingKit) {
+                for (const harness of selectedHarnesses) {
+                    if (existingKit.harnesses[harness.name]) {
+                        collidingHarnesses.push(harness.name);
+                        existingKits.push(existingKit);
+                    }
+                }
             }
             if (collidingHarnesses.length === 0) {
                 continue;
@@ -1297,14 +1308,17 @@ async function buildHookPrimitiveInfoBySourcePath(resolvedByKit) {
                 continue;
             if (!primitive.hookProgram || !primitive.hookBinding)
                 continue;
+            if (!primitive.hookEntryPath)
+                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);
+            const entryContents = await fs.readFile(primitive.hookEntryPath, "utf-8");
+            const checksum = hashHookProgram(primitive.hookProgram, entryContents);
             infoBySourcePath.set(key, {
                 instanceName,
-                configHash,
+                checksum,
                 program: primitive.hookProgram,
                 binding: primitive.hookBinding,
                 primitiveName: primitive.name,
@@ -1344,8 +1358,8 @@ function getMcpConfigPath(adapter, scope, projectRoot) {
     return expandPath(mcpPath);
 }
 function getHookConfigPath(adapter, scope, projectRoot) {
-    const paths = adapter.getInstallationPaths(scope);
-    const hookPath = paths.hooks ?? adapter.getConfigLocations(scope).primary;
+    const configLocations = adapter.getConfigLocations(scope);
+    const hookPath = configLocations.hooks ?? configLocations.primary;
     if (scope === "project" && projectRoot) {
         return path.join(projectRoot, hookPath.replace(/^\.\//, ""));
     }
@@ -1386,69 +1400,92 @@ async function promptForMcpInstanceName(instanceName, usedNames) {
         return trimmed;
     }
 }
+function getChecksumSuffix(checksum) {
+    const delimiterIndex = checksum.indexOf(":");
+    return delimiterIndex === -1 ? checksum : checksum.slice(delimiterIndex + 1);
+}
+function buildHookInstanceAlias(instanceName, checksum, existing) {
+    const suffix = getChecksumSuffix(checksum);
+    const lengths = [8, 12, 16, suffix.length];
+    for (const length of lengths) {
+        const alias = `${instanceName}@${suffix.slice(0, length)}`;
+        const entry = existing?.[alias];
+        if (!entry || entry.checksum === checksum) {
+            return alias;
+        }
+    }
+    return `${instanceName}@${suffix}`;
+}
 async function removeOverwrittenKitsForHarness(harness, kitsToOverwrite, lockfile, scope, projectRoot, options) {
-    const harnessEntry = lockfile.harnesses[harness.name];
-    if (!harnessEntry || kitsToOverwrite.size === 0) {
+    if (kitsToOverwrite.size === 0) {
         return;
     }
-    const mcpInstances = harnessEntry.mcpInstances;
-    const hookInstances = harnessEntry.hookInstances;
+    const mcpInstances = lockfile.mcpInstances;
+    const hookInstances = lockfile.hookInstances;
     const mcpCandidates = new Set();
     const hookCandidates = new Set();
     for (const kitName of kitsToOverwrite) {
-        const kit = harnessEntry.kits[kitName];
+        const kit = lockfile.kits[kitName];
         if (!kit)
             continue;
-        for (const primitive of kit.primitives) {
-            if (primitive.type === "mcp") {
-                const instanceName = primitive.instanceName ?? primitive.namespacedName;
-                if (instanceName) {
-                    mcpCandidates.add(instanceName);
-                }
-                continue;
-            }
-            if (primitive.type === "hooks") {
-                const instanceName = primitive.instanceName ?? primitive.namespacedName;
-                if (instanceName) {
-                    hookCandidates.add(instanceName);
-                }
-                continue;
-            }
-            const filePath = expandPath(primitive.installedPath);
-            try {
-                await remove(filePath);
-                if (options.verbose) {
-                    if (options.isInteractive) {
-                        clack.log.info(`  ✓ Removed ${primitive.namespacedName}`);
+        const harnessEntry = kit.harnesses[harness.name];
+        if (!harnessEntry)
+            continue;
+        for (const [type, entries] of Object.entries(harnessEntry.primitives)) {
+            for (const primitive of entries ?? []) {
+                const displayName = `${kitName}.${primitive.name}`;
+                if (type === "mcp") {
+                    if ("instanceRef" in primitive && primitive.instanceRef) {
+                        mcpCandidates.add(primitive.instanceRef);
                     }
-                    else {
-                        console.error(`  Removed: ${filePath}`);
+                    continue;
+                }
+                if (type === "hooks") {
+                    if ("instanceRef" in primitive && primitive.instanceRef) {
+                        hookCandidates.add(primitive.instanceRef);
                     }
+                    continue;
                 }
-            }
-            catch (error) {
-                if (options.verbose) {
-                    const msg = error instanceof Error ? error.message : String(error);
-                    if (options.isInteractive) {
-                        clack.log.warn(`  ⚠ Could not remove ${primitive.namespacedName}: ${msg}`);
+                const filePath = expandPath(primitive.installedPath);
+                try {
+                    await remove(filePath);
+                    if (options.verbose) {
+                        if (options.isInteractive) {
+                            clack.log.info(`  ✓ Removed ${displayName}`);
+                        }
+                        else {
+                            console.error(`  Removed: ${filePath}`);
+                        }
                     }
-                    else {
-                        console.error(`  Warning: Could not remove ${filePath}: ${msg}`);
+                }
+                catch (error) {
+                    if (options.verbose) {
+                        const msg = error instanceof Error ? error.message : String(error);
+                        if (options.isInteractive) {
+                            clack.log.warn(`  ⚠ Could not remove ${displayName}: ${msg}`);
+                        }
+                        else {
+                            console.error(`  Warning: Could not remove ${filePath}: ${msg}`);
+                        }
                     }
                 }
             }
         }
+        delete kit.harnesses[harness.name];
+        if (Object.keys(kit.harnesses).length === 0) {
+            delete lockfile.kits[kitName];
+        }
     }
     const mcpInstancesToRemove = [];
     if (mcpInstances) {
-        for (const instanceName of mcpCandidates) {
-            const entry = mcpInstances[instanceName];
+        for (const instanceRef of mcpCandidates) {
+            const entry = mcpInstances[instanceRef];
             if (!entry)
                 continue;
             entry.usedBy = entry.usedBy.filter((name) => !kitsToOverwrite.has(name));
             if (entry.usedBy.length === 0) {
-                delete mcpInstances[instanceName];
-                mcpInstancesToRemove.push(instanceName);
+                delete mcpInstances[instanceRef];
+                mcpInstancesToRemove.push(entry.instanceName);
             }
         }
     }
@@ -1468,14 +1505,14 @@ async function removeOverwrittenKitsForHarness(harness, kitsToOverwrite, lockfil
     }
     const hookInstancesToRemove = [];
     if (hookInstances) {
-        for (const instanceName of hookCandidates) {
-            const entry = hookInstances[instanceName];
+        for (const instanceRef of hookCandidates) {
+            const entry = hookInstances[instanceRef];
             if (!entry)
                 continue;
             entry.usedBy = entry.usedBy.filter((name) => !kitsToOverwrite.has(name));
             if (entry.usedBy.length === 0) {
-                delete hookInstances[instanceName];
-                hookInstancesToRemove.push(instanceName);
+                delete hookInstances[instanceRef];
+                hookInstancesToRemove.push(instanceRef);
             }
         }
     }
@@ -1493,9 +1530,7 @@ async function removeOverwrittenKitsForHarness(harness, kitsToOverwrite, lockfil
             }
         }
     }
-    for (const kitName of kitsToOverwrite) {
-        delete harnessEntry.kits[kitName];
-    }
+    // kits are removed above when their harness entries are cleared
 }
 /**
  * Execute the actual installation of kits to harnesses.
@@ -1701,11 +1736,12 @@ async function executeInstallation(kits, harnesses, registryBySource, options) {
                 };
             }
         }
-        const existingInstances = lockfile.harnesses[harness.name]?.mcpInstances ?? {};
+        const existingInstances = lockfile.mcpInstances ?? {};
         const overwriteKits = filterOverwriteKits(overwriteKitsByHarness.get(harness.name), kitsToCheck);
         const usedInstanceNames = new Set(Object.entries(existingInstances)
-            .filter(([, entry]) => entry.usedBy.some((name) => !overwriteKits.has(name)))
-            .map(([name]) => name));
+            .filter(([, entry]) => entry.harness === harness.name &&
+            entry.usedBy.some((name) => !overwriteKits.has(name)))
+            .map(([, entry]) => entry.instanceName));
         const assignments = new Map();
         const forkedInstances = new Map();
         const instancesToInstall = new Set();
@@ -1714,7 +1750,8 @@ async function executeInstallation(kits, harnesses, registryBySource, options) {
             let finalName = instanceName;
             let finalHash = candidate.info.configHash;
             let action = "install";
-            const existing = existingInstances[instanceName];
+            const instanceKey = `${harness.name}:${instanceName}`;
+            const existing = existingInstances[instanceKey];
             const existingUsers = existing?.usedBy.filter((name) => !overwriteKits.has(name)) ?? [];
             if (existing && existingUsers.length > 0) {
                 if (existing.configHash === candidate.info.configHash) {
@@ -1822,60 +1859,67 @@ async function executeInstallation(kits, harnesses, registryBySource, options) {
                 const info = hookInfoByPrimitiveKey.get(key);
                 if (!info)
                     continue;
-                const byHash = desiredByName.get(info.instanceName) ?? new Map();
-                const entry = byHash.get(info.configHash) ?? {
+                const byChecksum = desiredByName.get(info.instanceName) ?? new Map();
+                const entry = byChecksum.get(info.checksum) ?? {
                     primitives: [],
                     kits: new Set(),
                     info,
                 };
                 entry.primitives.push({ primitive, kitName: kit.installAs });
                 entry.kits.add(kit.installAs);
-                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,
-                };
+                byChecksum.set(info.checksum, entry);
+                desiredByName.set(info.instanceName, byChecksum);
             }
         }
-        const existingInstances = lockfile.harnesses[harness.name]?.hookInstances ?? {};
+        const existingInstances = lockfile.hookInstances ?? {};
         const overwriteKits = filterOverwriteKits(overwriteKitsByHarness.get(harness.name), kitsToCheck);
         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];
-            const existingUsers = existing?.usedBy.filter((name) => !overwriteKits.has(name)) ?? [];
-            if (existing && existingUsers.length > 0) {
-                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.`,
-                    };
+        const plannedBaseChecksums = new Map();
+        for (const [instanceName, byChecksum] of desiredByName) {
+            for (const candidate of byChecksum.values()) {
+                let instanceRef = instanceName;
+                let action = "install";
+                const checksum = candidate.info.checksum;
+                const existingBase = existingInstances[instanceName];
+                const existingBaseUsers = existingBase?.usedBy.filter((name) => !overwriteKits.has(name)) ?? [];
+                const baseInUse = Boolean(existingBase && existingBaseUsers.length > 0);
+                if (baseInUse && existingBase?.checksum && existingBase.checksum !== checksum) {
+                    instanceRef = buildHookInstanceAlias(instanceName, checksum, existingInstances);
+                }
+                const plannedChecksum = plannedBaseChecksums.get(instanceName);
+                if (instanceRef === instanceName && plannedChecksum && plannedChecksum !== checksum) {
+                    instanceRef = buildHookInstanceAlias(instanceName, checksum, existingInstances);
+                }
+                if (instanceRef === instanceName) {
+                    plannedBaseChecksums.set(instanceName, checksum);
+                }
+                const existing = existingInstances[instanceRef];
+                const existingUsers = existing?.usedBy.filter((name) => !overwriteKits.has(name)) ?? [];
+                if (existing && existingUsers.length > 0) {
+                    if (existing.checksum === checksum) {
+                        action = "reuse";
+                    }
+                    else {
+                        instanceRef = buildHookInstanceAlias(instanceName, checksum, existingInstances);
+                    }
+                }
+                const aliasEntry = existingInstances[instanceRef];
+                const aliasUsers = aliasEntry?.usedBy.filter((name) => !overwriteKits.has(name)) ?? [];
+                if (aliasEntry && aliasUsers.length > 0 && aliasEntry.checksum === checksum) {
+                    action = "reuse";
+                }
+                if (action === "install") {
+                    instancesToInstall.add(instanceRef);
+                }
+                for (const { primitive, kitName } of candidate.primitives) {
+                    const key = buildPrimitiveKey(kitName, primitive.sourcePath);
+                    assignments.set(key, {
+                        instanceRef,
+                        checksum,
+                        action,
+                    });
                 }
-                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) {
@@ -1961,15 +2005,10 @@ async function executeInstallation(kits, harnesses, registryBySource, options) {
                         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.instanceRef });
+                    if (assignment.action === "install") {
+                        installedHookInstanceNames.add(assignment.instanceRef);
                     }
-                    primitivesForAdapter.push({ ...primitive, instanceName: assignment.instanceName });
-                    installedHookInstanceNames.add(assignment.instanceName);
                     continue;
                 }
                 primitivesForAdapter.push(primitive);
@@ -2048,66 +2087,83 @@ async function executeInstallation(kits, harnesses, registryBySource, options) {
                 }
             }
             // Record in lockfile
-            if (!lockfile.harnesses[harness.name]) {
-                lockfile.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 kitEntry = (lockfile.kits[kit.installAs] ??= {
+                name: kit.name,
+                installAs: kit.installAs,
+                version: kit.manifest.version,
+                installedAt: new Date().toISOString(),
+                source: kit.source,
+                harnesses: {},
+            });
+            kitEntry.version = kit.manifest.version;
+            kitEntry.installedAt = new Date().toISOString();
+            kitEntry.source = kit.source;
+            const primitivesByType = {};
+            for (const primitive of resolvedPrimitives) {
                 const key = `${primitive.type}:${primitive.name}`;
                 const status = statusByKey.get(key);
-                const namespacedName = status?.namespacedName
-                    ?? harness.adapter.getNamespacedName(kit.installAs, primitive.name);
                 const installedPath = status?.destination
                     ?? (primitive.type === "mcp" ? mcpConfigPath : "");
-                const installed = {
+                const entry = {
                     name: primitive.name,
-                    type: primitive.type,
-                    namespacedName,
-                    isInline: !primitive.ref,
+                    version: primitive.resolvedVersion ?? kit.manifest.version,
                     installedPath,
                 };
-                if (primitive.resolvedVersion) {
-                    installed.version = primitive.resolvedVersion;
+                if (!primitive.ref) {
+                    entry.isInline = true;
                 }
-                if (primitive.ref) {
-                    // Extract version spec from ref (e.g., "tf-plan@^1.0.0" -> "^1.0.0")
+                else {
                     const atIndex = primitive.ref.indexOf("@");
                     if (atIndex !== -1) {
-                        installed.versionSpec = primitive.ref.substring(atIndex + 1);
+                        entry.versionSpec = primitive.ref.substring(atIndex + 1);
                     }
                 }
                 if (primitive.type === "mcp") {
                     const assignment = mcpAssignments?.get(buildPrimitiveKey(kit.installAs, primitive.sourcePath));
                     if (assignment) {
-                        installed.instanceName = assignment.instanceName;
-                        installed.configHash = assignment.configHash;
+                        const instanceRef = `${harness.name}:${assignment.instanceName}`;
+                        const mcpEntry = {
+                            ...entry,
+                            configPath: mcpConfigPath,
+                            instanceRef,
+                        };
+                        (primitivesByType.mcp ??= []).push(mcpEntry);
                     }
+                    continue;
                 }
                 if (primitive.type === "hooks") {
                     const assignment = hookAssignments?.get(buildPrimitiveKey(kit.installAs, primitive.sourcePath));
                     if (assignment) {
-                        installed.instanceName = assignment.instanceName;
-                        installed.configHash = assignment.configHash;
+                        if (!primitive.hookBinding) {
+                            continue;
+                        }
+                        const destinationDir = status?.destination ?? "";
+                        const programPath = primitive.hookEntryPath
+                            ? path.join(destinationDir, path.basename(primitive.hookEntryPath))
+                            : destinationDir;
+                        const hookEntry = {
+                            ...entry,
+                            installedPath: programPath,
+                            configPath: hookConfigPath,
+                            instanceRef: assignment.instanceRef,
+                            binding: primitive.hookBinding,
+                        };
+                        (primitivesByType.hooks ??= []).push(hookEntry);
                     }
+                    continue;
                 }
-                return installed;
-            });
-            const installedKit = {
-                name: kit.name,
-                installAs: kit.installAs,
-                version: kit.manifest.version,
-                installedAt: new Date().toISOString(),
-                source: kit.source,
-                primitives: installedPrimitives,
+                (primitivesByType[primitive.type] ??= []).push(entry);
+            }
+            kitEntry.harnesses[harness.name] = {
+                primitives: primitivesByType,
             };
-            lockfile.harnesses[harness.name].kits[kit.installAs] = installedKit;
             if (mcpAssignments && mcpInfoByPrimitiveKey.size > 0) {
-                const harnessEntry = lockfile.harnesses[harness.name];
-                if (!harnessEntry.mcpInstances) {
-                    harnessEntry.mcpInstances = {};
+                if (!lockfile.mcpInstances) {
+                    lockfile.mcpInstances = {};
                 }
                 for (const primitive of resolvedPrimitives) {
                     if (primitive.type !== "mcp")
@@ -2115,8 +2171,8 @@ async function executeInstallation(kits, harnesses, registryBySource, options) {
                     const assignment = mcpAssignments.get(buildPrimitiveKey(kit.installAs, primitive.sourcePath));
                     if (!assignment)
                         continue;
-                    const instanceName = assignment.instanceName;
-                    const existingInstance = harnessEntry.mcpInstances[instanceName];
+                    const instanceKey = `${harness.name}:${assignment.instanceName}`;
+                    const existingInstance = lockfile.mcpInstances[instanceKey];
                     if (existingInstance) {
                         if (!existingInstance.usedBy.includes(kit.installAs)) {
                             existingInstance.usedBy.push(kit.installAs);
@@ -2126,9 +2182,12 @@ async function executeInstallation(kits, harnesses, registryBySource, options) {
                     const info = mcpInfoByPrimitiveKey.get(buildPrimitiveKey(kit.installAs, primitive.sourcePath));
                     if (!info)
                         continue;
-                    harnessEntry.mcpInstances[instanceName] = {
-                        version: info.version,
+                    lockfile.mcpInstances[instanceKey] = {
+                        harness: harness.name,
+                        instanceName: assignment.instanceName,
+                        config: info.config,
                         configHash: assignment.configHash,
+                        version: info.version,
                         usedBy: [kit.installAs],
                         sourcePrimitive: info.primitiveName,
                         installedAt: new Date().toISOString(),
@@ -2136,9 +2195,8 @@ async function executeInstallation(kits, harnesses, registryBySource, options) {
                 }
             }
             if (hookAssignments && hookInfoByPrimitiveKey.size > 0) {
-                const harnessEntry = lockfile.harnesses[harness.name];
-                if (!harnessEntry.hookInstances) {
-                    harnessEntry.hookInstances = {};
+                if (!lockfile.hookInstances) {
+                    lockfile.hookInstances = {};
                 }
                 for (const primitive of resolvedPrimitives) {
                     if (primitive.type !== "hooks")
@@ -2146,8 +2204,7 @@ async function executeInstallation(kits, harnesses, registryBySource, options) {
                     const assignment = hookAssignments.get(buildPrimitiveKey(kit.installAs, primitive.sourcePath));
                     if (!assignment)
                         continue;
-                    const instanceName = assignment.instanceName;
-                    const existingInstance = harnessEntry.hookInstances[instanceName];
+                    const existingInstance = lockfile.hookInstances[assignment.instanceRef];
                     if (existingInstance) {
                         if (!existingInstance.usedBy.includes(kit.installAs)) {
                             existingInstance.usedBy.push(kit.installAs);
@@ -2157,12 +2214,17 @@ async function executeInstallation(kits, harnesses, registryBySource, options) {
                     const info = hookInfoByPrimitiveKey.get(buildPrimitiveKey(kit.installAs, primitive.sourcePath));
                     if (!info)
                         continue;
-                    harnessEntry.hookInstances[instanceName] = {
+                    const status = statusByKey.get(`hooks:${primitive.name}`);
+                    const destinationDir = status?.destination ?? "";
+                    const programPath = primitive.hookEntryPath
+                        ? path.join(destinationDir, path.basename(primitive.hookEntryPath))
+                        : destinationDir;
+                    lockfile.hookInstances[assignment.instanceRef] = {
+                        instanceName: assignment.instanceRef,
+                        programPath,
+                        checksum: assignment.checksum,
                         version: info.version,
-                        configHash: assignment.configHash,
                         usedBy: [kit.installAs],
-                        sourcePrimitive: info.primitiveName,
-                        installedAt: new Date().toISOString(),
                     };
                 }
             }