akm-cli 0.0.16 → 0.0.17

package/dist/file-context.js

@@ -22,8 +22,8 @@ export function buildFileContext(stashRoot, absPath) {
     const parentDirAbs = path.dirname(absPath);
     const parentDir = path.basename(parentDirAbs);
     // Compute ancestor directory segments from the POSIX relPath's directory portion.
-    // For "tools/azure/deploy/run.sh" the dir portion is "tools/azure/deploy"
-    // which splits into ["tools", "azure", "deploy"].
+    // For "scripts/azure/deploy/run.sh" the dir portion is "scripts/azure/deploy"
+    // which splits into ["scripts", "azure", "deploy"].
     const relDir = toPosix(path.dirname(relPath));
     const ancestorDirs = relDir === "." ? [] : relDir.split("/").filter((seg) => seg.length > 0);
     // Lazy caches
@@ -69,41 +69,16 @@ const matchers = [];
 /** Renderer lookup by name. */
 const renderers = new Map();
 let builtinsInitialized = false;
-/** Pluggable initializer set via `setBuiltinRegistrar`. */
-let builtinRegistrar = null;
-/**
- * Set the function that registers built-in matchers and renderers.
- *
- * This breaks the static import cycle: `file-context.ts` does not need to
- * import `matchers.ts` or `renderers.ts` at the top level. Instead, a
- * one-time call from outside (e.g. the test file or CLI entry) provides the
- * registration callback.
- *
- * If no registrar is set by the time `ensureBuiltinsRegistered` runs, it
- * falls back to a dynamic `require()` for backward compatibility.
- */
-export function setBuiltinRegistrar(fn) {
-    builtinRegistrar = fn;
-}
 /**
  * Ensure that built-in matchers and renderers are registered.
  * Called lazily on first use of runMatchers/getRenderer.
- *
- * Uses the registrar set via `setBuiltinRegistrar`, or falls back to
- * a direct import of the registration modules. The dynamic import
- * avoids a static circular dependency between file-context, renderers,
- * and asset-spec.
  */
 function ensureBuiltinsRegistered() {
     if (builtinsInitialized)
         return;
     builtinsInitialized = true;
-    if (builtinRegistrar) {
-        builtinRegistrar();
-        return;
-    }
     // Lazy inline require avoids a top-level static import cycle.
-    // These are only evaluated once and only when no explicit registrar was set.
+    // These are only evaluated once.
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { registerBuiltinMatchers } = require("./matchers");
     // eslint-disable-next-line @typescript-eslint/no-require-imports

package/dist/indexer.js

@@ -1,9 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { deriveCanonicalAssetName, TYPE_DIRS } from "./asset-spec";
 import { resolveStashDir } from "./common";
 import { closeDatabase, DB_VERSION, deleteEntriesByDir, getEntriesByDir, getEntryCount, getMeta, isVecAvailable, openDatabase, rebuildFts, setMeta, upsertEmbedding, upsertEntry, warnIfVecMissing, } from "./db";
-import { buildFileContext } from "./file-context";
 import { generateMetadataFlat, loadStashFile } from "./metadata";
 import { getDbPath } from "./paths";
 import { walkStashFlat } from "./walker";
@@ -128,10 +126,6 @@ function indexEntries(db, allStashDirs, _stashDir, isIncremental, builtAtMs) {
                 // Try loading existing .stash.json (user metadata overrides)
                 let stash = loadStashFile(dirPath);
                 if (stash) {
-                    // Re-derive canonical names for generated entries using the matcher system.
-                    // This fixes legacy .stash.json files that may have stale names (e.g. "SKILL"
-                    // instead of the directory-based canonical name "code-review").
-                    fixGeneratedEntryNames(stash, files, currentStashDir);
                     // Check for files on disk that aren't covered by existing .stash.json entries.
                     const coveredFiles = new Set(stash.entries.map((e) => (e.filename ? path.basename(e.filename) : "")).filter((e) => !!e));
                     const uncoveredFiles = files.filter((f) => !coveredFiles.has(path.basename(f)));
@@ -226,30 +220,6 @@ function attachFileSize(entry, entryPath) {
     }
 }
 /** Set of all known type directory names */
-const TYPE_DIR_NAMES = new Set(Object.values(TYPE_DIRS));
-/**
- * Re-derive canonical names for generated skill .stash.json entries.
- *
- * Legacy .stash.json files for skills may have name "SKILL" (derived from the
- * filename SKILL.md) instead of the canonical directory name (e.g. "code-review").
- * This fixes those names using the matcher system.
- */
-function fixGeneratedEntryNames(stash, files, stashRoot) {
-    const fileByBaseName = new Map(files.map((f) => [path.basename(f), f]));
-    for (const entry of stash.entries) {
-        if (entry.quality !== "generated" || entry.type !== "skill")
-            continue;
-        const filePath = entry.filename ? fileByBaseName.get(path.basename(entry.filename)) : undefined;
-        if (!filePath)
-            continue;
-        const firstAncestor = buildFileContext(stashRoot, filePath).ancestorDirs[0];
-        const effectiveRoot = firstAncestor && TYPE_DIR_NAMES.has(firstAncestor) ? path.join(stashRoot, firstAncestor) : stashRoot;
-        const canonicalName = deriveCanonicalAssetName("skill", effectiveRoot, filePath);
-        if (canonicalName && canonicalName !== entry.name) {
-            entry.name = canonicalName;
-        }
-    }
-}
 function isDirStale(dirPath, currentFiles, previousEntries, builtAtMs) {
     // Check if file set changed (additions or deletions)
     const prevFileNames = new Set(previousEntries.map((ie) => ie.entry.filename).filter((e) => !!e));

package/dist/llm.js

@@ -22,7 +22,7 @@ async function chatCompletion(config, messages) {
     return json.choices?.[0]?.message?.content?.trim() ?? "";
 }
 // ── Metadata Enhancement ────────────────────────────────────────────────────
-const SYSTEM_PROMPT = `You are a metadata generator for a developer tool registry. Given a tool/skill/command/agent entry, generate improved metadata. Respond with ONLY valid JSON, no markdown fencing.`;
+const SYSTEM_PROMPT = `You are a metadata generator for a developer asset registry. Given a script/skill/command/agent entry, generate improved metadata. Respond with ONLY valid JSON, no markdown fencing.`;
 /**
  * Use an LLM to enhance a stash entry's metadata: improve description,
  * generate searchHints, and suggest tags.

package/dist/matchers.js

@@ -16,7 +16,7 @@
  *   at specificity 5 when no signals are found. Command signals (`agent`
  *   frontmatter, `$ARGUMENTS`/`$1`-`$3` placeholders) return 18.
  */
-import { SCRIPT_EXTENSIONS_BROAD } from "./asset-spec";
+import { SCRIPT_EXTENSIONS } from "./asset-spec";
 import { registerMatcher } from "./file-context";
 // ── extensionMatcher (specificity: 3) ────────────────────────────────────────
 /**
@@ -36,7 +36,7 @@ export function extensionMatcher(ctx) {
         return { type: "skill", specificity: 25, renderer: "skill-md" };
     }
     // Known script extensions (excluding .md, handled by smartMdMatcher)
-    if (SCRIPT_EXTENSIONS_BROAD.has(ctx.ext)) {
+    if (SCRIPT_EXTENSIONS.has(ctx.ext)) {
         return { type: "script", specificity: 3, renderer: "script-source" };
     }
     return null;
@@ -45,19 +45,13 @@ export function extensionMatcher(ctx) {
 /**
  * Directory-based matcher that boosts specificity when the first ancestor
  * directory segment from the stash root matches a known type name.
- *
- * Accepts ALL known script extensions in both `tools/` and `scripts/`
- * directories -- the distinction is purely organizational.
  */
 export function directoryMatcher(ctx) {
     const topDir = ctx.ancestorDirs[0];
     if (!topDir)
         return null;
     const ext = ctx.ext;
-    if (topDir === "tools" && SCRIPT_EXTENSIONS_BROAD.has(ext)) {
-        return { type: "tool", specificity: 10, renderer: "script-source" };
-    }
-    if (topDir === "scripts" && SCRIPT_EXTENSIONS_BROAD.has(ext)) {
+    if (topDir === "scripts" && SCRIPT_EXTENSIONS.has(ext)) {
         return { type: "script", specificity: 10, renderer: "script-source" };
     }
     if (topDir === "skills" && ctx.fileName === "SKILL.md") {
@@ -80,15 +74,10 @@ export function directoryMatcher(ctx) {
  * the ancestor-based directory matcher because the file might be nested
  * several levels deep, yet its immediate parent can still carry strong
  * naming conventions (e.g. `my-project/agents/planning.md`).
- *
- * Accepts ALL known script extensions in both `tools/` and `scripts/`.
  */
 export function parentDirHintMatcher(ctx) {
     const { parentDir, ext, fileName } = ctx;
-    if (parentDir === "tools" && SCRIPT_EXTENSIONS_BROAD.has(ext)) {
-        return { type: "tool", specificity: 15, renderer: "script-source" };
-    }
-    if (parentDir === "scripts" && SCRIPT_EXTENSIONS_BROAD.has(ext)) {
+    if (parentDir === "scripts" && SCRIPT_EXTENSIONS.has(ext)) {
         return { type: "script", specificity: 15, renderer: "script-source" };
     }
     if (parentDir === "skills" && fileName === "SKILL.md") {

package/dist/metadata.js

@@ -176,7 +176,7 @@ export function generateMetadata(dirPath, assetType, files, typeRoot = dirPath)
                 entry.confidence = 0.9;
             }
         }
-        // Priority 3: Type-specific metadata extraction (e.g. TOC for knowledge, comments for tools/scripts)
+        // Priority 3: Type-specific metadata extraction (e.g. TOC for knowledge, comments for scripts)
         const fileCtx = buildFileContext(typeRoot, file);
         const match = runMatchers(fileCtx);
         if (match) {
@@ -204,7 +204,7 @@ export function generateMetadata(dirPath, assetType, files, typeRoot = dirPath)
     }
     return { entries };
 }
-/** Set of all known type directory names (e.g. "tools", "skills", "scripts") */
+/** Set of all known type directory names (e.g. "scripts", "skills", "agents") */
 const TYPE_DIR_NAMES = new Set(Object.values(TYPE_DIRS));
 /**
  * Generate metadata for files using the matcher system instead of a fixed asset type.
@@ -226,7 +226,7 @@ export function generateMetadataFlat(stashRoot, files) {
             continue;
         // If the file lives under a known type directory, use that as the root
         // for canonical naming so names don't include the type prefix.
-        // e.g. tools/deploy.sh → "deploy.sh" not "tools/deploy.sh"
+        // e.g. scripts/deploy.sh → "deploy.sh" not "scripts/deploy.sh"
         const firstAncestor = ctx.ancestorDirs[0];
         const effectiveRoot = firstAncestor && TYPE_DIR_NAMES.has(firstAncestor) ? path.join(stashRoot, firstAncestor) : stashRoot;
         const ext = path.extname(file).toLowerCase();

package/dist/registry-install.js

@@ -154,23 +154,23 @@ async function installGitRegistryRef(parsed, options) {
 }
 export function upsertInstalledRegistryEntry(entry) {
     const current = loadConfig();
-    const currentInstalled = current.registry?.installed ?? [];
+    const currentInstalled = current.installed ?? [];
     const withoutExisting = currentInstalled.filter((item) => item.id !== entry.id);
     const nextInstalled = [...withoutExisting, normalizeInstalledEntry(entry)];
     const nextConfig = {
         ...current,
-        registry: { installed: nextInstalled },
+        installed: nextInstalled,
     };
     saveConfig(nextConfig);
     return nextConfig;
 }
 export function removeInstalledRegistryEntry(id) {
     const current = loadConfig();
-    const currentInstalled = current.registry?.installed ?? [];
+    const currentInstalled = current.installed ?? [];
     const nextInstalled = currentInstalled.filter((item) => item.id !== id);
     const nextConfig = {
         ...current,
-        registry: nextInstalled.length > 0 ? { installed: nextInstalled } : undefined,
+        installed: nextInstalled.length > 0 ? nextInstalled : undefined,
     };
     saveConfig(nextConfig);
     return nextConfig;
@@ -405,7 +405,7 @@ function countStashDirs(dirPath) {
 /**
  * BFS to find the shallowest directory that looks like a stash root.
  * Checks for both `.stash` directories and well-known type directories
- * (tools/, skills/, etc.), so nested layouts like `project/my-kit/tools/`
+ * (scripts/, skills/, etc.), so nested layouts like `project/my-kit/scripts/`
  * are discovered even without a `.stash` marker.
  *
  * Skips `root` itself since the caller already checked it via `hasStashDirs`.

package/dist/registry-search.js

@@ -1,10 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fetchWithRetry } from "./common";
+import { DEFAULT_CONFIG, loadConfig } from "./config";
 import { getRegistryIndexCacheDir } from "./paths";
 // ── Constants ───────────────────────────────────────────────────────────────
-/** Default registry index URL. Override via config or AKM_REGISTRY_URL env var. */
-const DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/itlackey/akm-registry/main/index.json";
 /** Cache TTL in milliseconds (1 hour). */
 const CACHE_TTL_MS = 60 * 60 * 1000;
 /** Maximum age before cache is considered stale but still usable as fallback (7 days). */
@@ -16,28 +15,59 @@ export async function searchRegistry(query, options) {
         return { query: "", hits: [], warnings: [] };
     }
     const limit = clampLimit(options?.limit);
-    const urls = resolveRegistryUrls(options?.registryUrls);
+    const entries = (options?.registries ?? resolveRegistries()).filter((r) => r.enabled !== false);
     const warnings = [];
     // Load index from all configured registries, merge kits
     const allKits = [];
-    for (const url of urls) {
+    for (const entry of entries) {
         try {
-            const index = await loadIndex(url);
+            const index = await loadIndex(entry);
             if (index) {
-                allKits.push(...index.kits);
+                const regName = entry.name;
+                for (const kit of index.kits) {
+                    allKits.push({ kit, registryName: regName });
+                }
             }
         }
         catch (err) {
-            warnings.push(`Registry ${url}: ${toErrorMessage(err)}`);
+            const label = entry.name ? `${entry.name} (${entry.url})` : entry.url;
+            warnings.push(`Registry ${label}: ${toErrorMessage(err)}`);
         }
     }
     // Score and rank
     const hits = scoreKits(allKits, trimmed, limit);
-    return { query: trimmed, hits, warnings };
+    // When includeAssets is enabled, also search asset-level metadata
+    let assetHits = [];
+    if (options?.includeAssets) {
+        assetHits = scoreAssets(allKits, trimmed, limit);
+    }
+    return { query: trimmed, hits, warnings, assetHits: assetHits.length > 0 ? assetHits : undefined };
+}
+// ── Registry resolution ─────────────────────────────────────────────────────
+/**
+ * Resolve the list of enabled registries.
+ *
+ * Priority:
+ * 1. AKM_REGISTRY_URL env var (CI override, comma-separated)
+ * 2. config.registries (filtered by enabled !== false)
+ * 3. Default registries from DEFAULT_CONFIG
+ */
+export function resolveRegistries(configRegistries) {
+    // Allow env var override (comma-separated URLs) — CI escape hatch
+    const envUrls = process.env.AKM_REGISTRY_URL?.trim();
+    if (envUrls) {
+        return envUrls
+            .split(",")
+            .map((u) => u.trim())
+            .filter(Boolean)
+            .map((url) => ({ url }));
+    }
+    const registries = configRegistries ?? loadConfig().registries ?? DEFAULT_CONFIG.registries ?? [];
+    return registries.filter((r) => r.enabled !== false);
 }
 // ── Index loading with cache ────────────────────────────────────────────────
-async function loadIndex(url) {
-    const cachePath = indexCachePath(url);
+async function loadIndex(entry) {
+    const cachePath = indexCachePath(entry.url);
     const cached = readCachedIndex(cachePath);
     // Fresh cache: return immediately
     if (cached && !isCacheExpired(cached.mtime)) {
@@ -45,7 +75,7 @@ async function loadIndex(url) {
     }
     // Try to fetch fresh index
     try {
-        const response = await fetchWithRetry(url, undefined, { timeout: 10_000 });
+        const response = await fetchWithRetry(entry.url, undefined, { timeout: 10_000 });
         if (!response.ok) {
             throw new Error(`HTTP ${response.status}`);
         }
@@ -110,7 +140,7 @@ function parseRegistryIndex(data) {
     if (typeof data !== "object" || data === null || Array.isArray(data))
         return null;
     const obj = data;
-    if (typeof obj.version !== "number" || obj.version !== 1)
+    if (typeof obj.version !== "number" || (obj.version !== 1 && obj.version !== 2))
         return null;
     if (typeof obj.updatedAt !== "string")
         return null;
@@ -120,7 +150,7 @@ function parseRegistryIndex(data) {
         const kit = parseKitEntry(raw);
         return kit ? [kit] : [];
     });
-    return { version: 1, updatedAt: obj.updatedAt, kits };
+    return { version: obj.version, updatedAt: obj.updatedAt, kits };
 }
 function parseKitEntry(raw) {
     if (typeof raw !== "object" || raw === null || Array.isArray(raw))
@@ -141,6 +171,7 @@ function parseKitEntry(raw) {
         homepage: asString(obj.homepage),
         tags: asStringArray(obj.tags),
         assetTypes: asStringArray(obj.assetTypes),
+        assets: parseAssets(obj.assets),
         author: asString(obj.author),
         license: asString(obj.license),
         latestVersion: asString(obj.latestVersion),
@@ -151,14 +182,14 @@ function parseKitEntry(raw) {
 function scoreKits(kits, query, limit) {
     const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
     const scored = [];
-    for (const kit of kits) {
+    for (const { kit, registryName } of kits) {
         const score = scoreKit(kit, tokens);
         if (score > 0) {
-            scored.push({ kit, score });
+            scored.push({ kit, registryName, score });
         }
     }
     scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, limit).map(({ kit, score }) => toSearchHit(kit, score));
+    return scored.slice(0, limit).map(({ kit, registryName, score }) => toSearchHit(kit, score, registryName));
 }
 function scoreKit(kit, tokens) {
     let score = 0;
@@ -192,7 +223,7 @@ function scoreKit(kit, tokens) {
     // Normalize by token count so multi-word queries don't inflate scores
     return tokens.length > 0 ? score / tokens.length : 0;
 }
-function toSearchHit(kit, score) {
+function toSearchHit(kit, score, registryName) {
     const metadata = {};
     if (kit.latestVersion)
         metadata.version = kit.latestVersion;
@@ -212,23 +243,102 @@ function toSearchHit(kit, score) {
         score: Math.round(score * 1000) / 1000,
         metadata,
         curated: kit.curated,
+        registryName,
     };
 }
-// ── Registry URL resolution ─────────────────────────────────────────────────
-function resolveRegistryUrls(override) {
-    if (override) {
-        const urls = Array.isArray(override) ? override : [override];
-        return urls.filter(Boolean);
+// ── Asset parsing ────────────────────────────────────────────────────────────
+function parseAssets(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const parsed = raw.flatMap((item) => {
+        const entry = parseAssetEntry(item);
+        return entry ? [entry] : [];
+    });
+    return parsed.length > 0 ? parsed : undefined;
+}
+function parseAssetEntry(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const type = asString(obj.type);
+    const name = asString(obj.name);
+    if (!type || !name)
+        return null;
+    return {
+        type,
+        name,
+        description: asString(obj.description),
+        tags: asStringArray(obj.tags),
+    };
+}
+// ── Asset-level scoring ──────────────────────────────────────────────────────
+function scoreAssets(kits, query, limit) {
+    const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (tokens.length === 0)
+        return [];
+    const scored = [];
+    for (const { kit, registryName } of kits) {
+        if (!kit.assets || kit.assets.length === 0)
+            continue;
+        const installRef = kit.source === "npm"
+            ? `npm:${kit.ref}`
+            : kit.source === "git"
+                ? `git+${kit.ref}`
+                : kit.source === "local"
+                    ? kit.ref
+                    : `github:${kit.ref}`;
+        for (const asset of kit.assets) {
+            const score = scoreAsset(asset, tokens);
+            if (score > 0) {
+                scored.push({
+                    hit: {
+                        type: "registry-asset",
+                        assetType: asset.type,
+                        assetName: asset.name,
+                        description: asset.description,
+                        kit: { id: kit.id, name: kit.name },
+                        registryName,
+                        action: `akm add ${installRef}`,
+                        score: Math.round(score * 1000) / 1000,
+                    },
+                    score,
+                });
+            }
+        }
     }
-    // Allow env var override (comma-separated)
-    const envUrls = process.env.AKM_REGISTRY_URL?.trim();
-    if (envUrls) {
-        return envUrls
-            .split(",")
-            .map((u) => u.trim())
-            .filter(Boolean);
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit).map(({ hit }) => hit);
+}
+function scoreAsset(asset, tokens) {
+    let score = 0;
+    const nameLower = asset.name.toLowerCase();
+    const descLower = (asset.description ?? "").toLowerCase();
+    const tagsLower = (asset.tags ?? []).map((t) => t.toLowerCase());
+    const typeLower = asset.type.toLowerCase();
+    for (const token of tokens) {
+        if (nameLower === token) {
+            score += 1.0;
+        }
+        else if (nameLower.includes(token)) {
+            score += 0.6;
+        }
+        if (typeLower === token) {
+            score += 0.4;
+        }
+        else if (typeLower.includes(token)) {
+            score += 0.2;
+        }
+        if (tagsLower.some((tag) => tag === token)) {
+            score += 0.5;
+        }
+        else if (tagsLower.some((tag) => tag.includes(token))) {
+            score += 0.25;
+        }
+        if (descLower.includes(token)) {
+            score += 0.2;
+        }
     }
-    return [DEFAULT_REGISTRY_URL];
+    return tokens.length > 0 ? score / tokens.length : 0;
 }
 // ── Utilities ───────────────────────────────────────────────────────────────
 function clampLimit(limit) {

package/dist/renderers.js

@@ -112,7 +112,7 @@ export function detectExecHints(filePath) {
 }
 // ── Resolution ───────────────────────────────────────────────────────────────
 /**
- * Resolve execution hints for a script/tool asset.
+ * Resolve execution hints for a script asset.
  *
  * Resolution order (first non-empty value wins for each field):
  * 1. `.stash.json` fields (`run`/`setup`/`cwd`) take priority

package/dist/stash-add.js

@@ -11,7 +11,7 @@ export async function agentikitAdd(input) {
         throw new UsageError("Install ref or local directory is required.");
     const stashDir = resolveStashDir();
     const installed = await installRegistryRef(ref);
-    const replaced = loadConfig().registry?.installed.find((entry) => entry.id === installed.id);
+    const replaced = (loadConfig().installed ?? []).find((entry) => entry.id === installed.id);
     const config = upsertInstalledRegistryEntry({
         id: installed.id,
         source: installed.source,
@@ -59,7 +59,7 @@ export async function agentikitAdd(input) {
         },
         config: {
             searchPaths: config.searchPaths,
-            installedRegistryCount: config.registry?.installed.length ?? 0,
+            installedKitCount: config.installed?.length ?? 0,
         },
         index: {
             mode: index.mode,

package/dist/stash-ref.js

@@ -6,21 +6,19 @@ import { UsageError } from "./errors";
  * Build a ref string from components.
  *
  * Examples:
- *   makeAssetRef("tool", "deploy.sh")
- *     → "tool:deploy.sh"
- *   makeAssetRef("tool", "deploy.sh", "npm:@scope/pkg")
- *     → "npm:@scope/pkg//tool:deploy.sh"
+ *   makeAssetRef("script", "deploy.sh")
+ *     → "script:deploy.sh"
+ *   makeAssetRef("script", "deploy.sh", "npm:@scope/pkg")
+ *     → "npm:@scope/pkg//script:deploy.sh"
  *   makeAssetRef("skill", "code-review", "local")
  *     → "local//skill:code-review"
- *   makeAssetRef("tool", "db/migrate/run.sh", "owner/repo")
- *     → "owner/repo//tool:db/migrate/run.sh"
+ *   makeAssetRef("script", "db/migrate/run.sh", "owner/repo")
+ *     → "owner/repo//script:db/migrate/run.sh"
  */
 export function makeAssetRef(type, name, origin) {
     validateName(name);
     const normalized = normalizeName(name);
-    // "tool" is a transparent alias for "script" -- normalize to "script" in refs
-    const resolvedType = type === "tool" ? "script" : type;
-    const asset = `${resolvedType}:${normalized}`;
+    const asset = `${type}:${normalized}`;
     if (!origin)
         return asset;
     return `${origin}//${asset}`;

package/dist/stash-registry.js

@@ -9,7 +9,7 @@ import { parseRegistryRef } from "./registry-resolve";
 export async function agentikitList(input) {
     const stashDir = input?.stashDir ?? resolveStashDir();
     const config = loadConfig();
-    const installed = config.registry?.installed ?? [];
+    const installed = config.installed ?? [];
     return {
         schemaVersion: 1,
         stashDir,
@@ -29,7 +29,7 @@ export async function agentikitRemove(input) {
         throw new UsageError("Target is required.");
     const stashDir = input.stashDir ?? resolveStashDir();
     const config = loadConfig();
-    const installed = config.registry?.installed ?? [];
+    const installed = config.installed ?? [];
     const entry = resolveInstalledTarget(installed, target);
     const updatedConfig = removeInstalledRegistryEntry(entry.id);
     removeLockEntry(entry.id);
@@ -52,7 +52,7 @@ export async function agentikitRemove(input) {
         },
         config: {
             searchPaths: updatedConfig.searchPaths,
-            installedRegistryCount: updatedConfig.registry?.installed.length ?? 0,
+            installedKitCount: updatedConfig.installed?.length ?? 0,
         },
         index: {
             mode: index.mode,
@@ -67,7 +67,7 @@ export async function agentikitUpdate(input) {
     const target = input?.target?.trim();
     const all = input?.all === true;
     const force = input?.force === true;
-    const installedEntries = loadConfig().registry?.installed ?? [];
+    const installedEntries = loadConfig().installed ?? [];
     const selectedEntries = selectTargets(installedEntries, target, all);
     const processed = [];
     for (const entry of selectedEntries) {
@@ -116,7 +116,7 @@ export async function agentikitUpdate(input) {
         processed,
         config: {
             searchPaths: config.searchPaths,
-            installedRegistryCount: config.registry?.installed.length ?? 0,
+            installedKitCount: config.installed?.length ?? 0,
         },
         index: {
             mode: index.mode,
@@ -156,7 +156,7 @@ function resolveInstalledTarget(installed, target) {
         if (byParsedId)
             return byParsedId;
     }
-    throw new NotFoundError(`No installed registry entry matched target: ${target}`);
+    throw new NotFoundError(`No installed kit matched target: ${target}`);
 }
 function toInstalledEntry(status) {
     return {