agentikit 0.0.14 → 0.0.15

package/dist/db.js

@@ -1,16 +1,13 @@
+import { Database } from "bun:sqlite";
 import fs from "node:fs";
-import path from "node:path";
 import { createRequire } from "node:module";
-import { Database } from "bun:sqlite";
+import path from "node:path";
 import { cosineSimilarity } from "./embedder";
-import { getDbPath as _getDbPath } from "./paths";
+import { getDbPath } from "./paths";
+import { warn } from "./warn";
 // ── Constants ───────────────────────────────────────────────────────────────
 export const DB_VERSION = 6;
 export const EMBEDDING_DIM = 384;
-// ── Path ────────────────────────────────────────────────────────────────────
-export function getDbPath() {
-    return _getDbPath();
-}
 // ── Database lifecycle ──────────────────────────────────────────────────────
 export function openDatabase(dbPath, options) {
     const resolvedPath = dbPath ?? getDbPath();
@@ -63,12 +60,14 @@ export function warnIfVecMissing(db, { once } = { once: false }) {
         const row = db.prepare("SELECT COUNT(*) AS cnt FROM embeddings").get();
         const count = row?.cnt ?? 0;
         if (count >= VEC_FALLBACK_THRESHOLD) {
-            console.warn("Semantic search is using JS fallback for %d entries. Install sqlite-vec for faster performance.\n  See: %s", count, VEC_DOCS_URL);
+            warn("Semantic search is using JS fallback for %d entries. Install sqlite-vec for faster performance.\n  See: %s", count, VEC_DOCS_URL);
             if (once)
                 vecInitWarned = true;
         }
     }
-    catch { /* embeddings table may not exist yet during init */ }
+    catch {
+        /* embeddings table may not exist yet during init */
+    }
 }
 // ── Schema ──────────────────────────────────────────────────────────────────
 function ensureSchema(db, embeddingDim) {
@@ -114,9 +113,7 @@ function ensureSchema(db, embeddingDim) {
     );
   `);
     // FTS5 table — standalone with explicit entry_id for joining
-    const ftsExists = db
-        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_fts'")
-        .get();
+    const ftsExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_fts'").get();
     if (!ftsExists) {
         db.exec(`
       CREATE VIRTUAL TABLE entries_fts USING fts5(
@@ -134,11 +131,11 @@ function ensureSchema(db, embeddingDim) {
             try {
                 db.exec("DROP TABLE IF EXISTS entries_vec");
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         }
-        const vecExists = db
-            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_vec'")
-            .get();
+        const vecExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_vec'").get();
         if (!vecExists) {
             db.exec(`
         CREATE VIRTUAL TABLE entries_vec USING vec0(
@@ -182,19 +179,21 @@ export function upsertEntry(db, entryKey, dirPath, filePath, stashDir, entry, se
     return row.id;
 }
 export function deleteEntriesByDir(db, dirPath) {
-    const ids = db
-        .prepare("SELECT id FROM entries WHERE dir_path = ?")
-        .all(dirPath);
+    const ids = db.prepare("SELECT id FROM entries WHERE dir_path = ?").all(dirPath);
     for (const { id } of ids) {
         try {
             db.prepare("DELETE FROM embeddings WHERE id = ?").run(id);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         if (isVecAvailable(db)) {
             try {
                 db.prepare("DELETE FROM entries_vec WHERE id = ?").run(id);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
         }
     }
     db.prepare("DELETE FROM entries WHERE dir_path = ?").run(dirPath);
@@ -213,7 +212,9 @@ export function upsertEmbedding(db, entryId, embedding) {
         try {
             db.prepare("DELETE FROM entries_vec WHERE id = ?").run(entryId);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
         db.prepare("INSERT INTO entries_vec (id, embedding) VALUES (?, ?)").run(entryId, buf);
     }
 }
@@ -243,9 +244,7 @@ function bufferToFloat32(buf) {
 }
 function searchBlobVec(db, queryEmbedding, k) {
     try {
-        const rows = db
-            .prepare("SELECT id, embedding FROM embeddings")
-            .all();
+        const rows = db.prepare("SELECT id, embedding FROM embeddings").all();
         if (rows.length === 0)
             return [];
         const scored = [];
@@ -316,7 +315,7 @@ function sanitizeFtsQuery(query) {
     const tokens = query
         .replace(/[^a-zA-Z0-9\s]/g, " ")
         .split(/\s+/)
-        .filter((t) => t.length > 1);
+        .filter((t) => t.length >= 1);
     if (tokens.length === 0)
         return "";
     // Use unquoted tokens so the porter stemmer can normalize word forms
@@ -327,7 +326,8 @@ export function getAllEntries(db, entryType) {
     let sql;
     let params;
     if (entryType && entryType !== "any") {
-        sql = "SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries WHERE entry_type = ?";
+        sql =
+            "SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries WHERE entry_type = ?";
         params = [entryType];
     }
     else {
@@ -350,9 +350,7 @@ export function getEntryCount(db) {
     return row.cnt;
 }
 export function getEntryById(db, id) {
-    const row = db
-        .prepare("SELECT file_path, entry_json FROM entries WHERE id = ?")
-        .get(id);
+    const row = db.prepare("SELECT file_path, entry_json FROM entries WHERE id = ?").get(id);
     if (!row)
         return undefined;
     return { filePath: row.file_path, entry: JSON.parse(row.entry_json) };

package/dist/errors.js

@@ -0,0 +1,28 @@
+/**
+ * Typed error classes for structured exit code classification.
+ *
+ * - ConfigError  -> exit 78  (configuration / environment problems)
+ * - UsageError   -> exit 2   (bad CLI arguments or invalid input)
+ * - NotFoundError -> exit 1  (requested resource missing)
+ */
+/** Raised when configuration or environment is invalid or missing. */
+export class ConfigError extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = "ConfigError";
+    }
+}
+/** Raised when the user supplies invalid arguments or input. */
+export class UsageError extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = "UsageError";
+    }
+}
+/** Raised when a requested resource (asset, entry, file) is not found. */
+export class NotFoundError extends Error {
+    constructor(msg) {
+        super(msg);
+        this.name = "NotFoundError";
+    }
+}

package/dist/file-context.js

@@ -6,8 +6,8 @@
  */
 import fs from "node:fs";
 import path from "node:path";
-import { parseFrontmatter } from "./frontmatter";
 import { toPosix } from "./common";
+import { parseFrontmatter } from "./frontmatter";
 /**
  * Build a FileContext from a stash root and an absolute file path.
  *
@@ -50,8 +50,7 @@ export function buildFileContext(stashRoot, absPath) {
             if (!frontmatterComputed) {
                 const raw = this.content();
                 const parsed = parseFrontmatter(raw);
-                cachedFrontmatter =
-                    Object.keys(parsed.data).length > 0 ? parsed.data : null;
+                cachedFrontmatter = Object.keys(parsed.data).length > 0 ? parsed.data : null;
                 frontmatterComputed = true;
             }
             return cachedFrontmatter;
@@ -70,17 +69,48 @@ 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;
-    // Side-effect imports that register matchers/renderers at module load
-    require("./matchers");
-    require("./renderers");
+    if (builtinRegistrar) {
+        builtinRegistrar();
+        return;
+    }
+    // Lazy inline require avoids a top-level static import cycle:
+    //   file-context -> renderers -> asset-spec -> asset-type-handler -> handlers -> file-context
+    // These are only evaluated once and only when no explicit registrar was set.
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { registerBuiltinMatchers } = require("./matchers");
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { registerBuiltinRenderers } = require("./renderers");
+    registerBuiltinMatchers();
+    registerBuiltinRenderers();
 }
 /**
  * Register an AssetMatcher.

package/dist/frontmatter.js

@@ -18,7 +18,7 @@ export function parseFrontmatter(raw) {
     let currentKey = null;
     let nested = null;
     for (const line of parsedBlock.frontmatter.split(/\r?\n/)) {
-        const indented = line.match(/^  (\w[\w-]*):\s*(.+)$/);
+        const indented = line.match(/^ {2}(\w[\w-]*):\s*(.+)$/);
         if (indented && currentKey && nested) {
             nested[indented[1]] = parseYamlScalar(indented[2].trim());
             continue;

package/dist/github.js

@@ -10,9 +10,7 @@ export function githubHeaders() {
     return headers;
 }
 export function asRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? value
-        : {};
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
 }
 export function asString(value) {
     return typeof value === "string" && value ? value : undefined;

package/dist/handlers/agent-handler.js

@@ -1,5 +1,6 @@
-import { parseFrontmatter, toStringOrUndefined } from "../frontmatter";
-import { isMarkdownFile, markdownCanonicalName, markdownAssetPath } from "./markdown-helpers";
+import { getRenderer } from "../file-context";
+import { showInputToRenderContext } from "./handler-bridge";
+import { isMarkdownFile, markdownAssetPath, markdownCanonicalName } from "./markdown-helpers";
 export const agentHandler = {
     typeName: "agent",
     stashDir: "agents",
@@ -7,17 +8,9 @@ export const agentHandler = {
     toCanonicalName: markdownCanonicalName,
     toAssetPath: markdownAssetPath,
     buildShowResponse(input) {
-        const parsedMd = parseFrontmatter(input.content);
-        return {
-            type: "agent",
-            name: input.name,
-            path: input.path,
-            description: toStringOrUndefined(parsedMd.data.description),
-            prompt: "Dispatching prompt must include the agent's full prompt content verbatim; summaries are non-compliant. \n\n"
-                + parsedMd.content,
-            toolPolicy: parsedMd.data.tools,
-            modelHint: parsedMd.data.model,
-        };
+        const renderer = getRenderer("agent-md");
+        const ctx = showInputToRenderContext(input, "agent-md");
+        return renderer.buildShowResponse(ctx);
     },
     defaultUsageGuide: [
         "Read the .md file and dispatch an agent using the content of the file. Use modelHint/toolPolicy when present to run the agent with compatible settings.",

package/dist/handlers/command-handler.js

@@ -1,5 +1,6 @@
-import { parseFrontmatter, toStringOrUndefined } from "../frontmatter";
-import { isMarkdownFile, markdownCanonicalName, markdownAssetPath } from "./markdown-helpers";
+import { getRenderer } from "../file-context";
+import { showInputToRenderContext } from "./handler-bridge";
+import { isMarkdownFile, markdownAssetPath, markdownCanonicalName } from "./markdown-helpers";
 export const commandHandler = {
     typeName: "command",
     stashDir: "commands",
@@ -7,19 +8,13 @@ export const commandHandler = {
     toCanonicalName: markdownCanonicalName,
     toAssetPath: markdownAssetPath,
     buildShowResponse(input) {
-        const parsedMd = parseFrontmatter(input.content);
-        return {
-            type: "command",
-            name: input.name,
-            path: input.path,
-            description: toStringOrUndefined(parsedMd.data.description),
-            template: parsedMd.content,
-            modelHint: parsedMd.data.model,
-            agent: toStringOrUndefined(parsedMd.data.agent),
-        };
+        const renderer = getRenderer("command-md");
+        const ctx = showInputToRenderContext(input, "command-md");
+        return renderer.buildShowResponse(ctx);
     },
     defaultUsageGuide: [
-        "Read the .md file, fill placeholders, and run it in the current repo context.",
+        "Read the .md file, fill $ARGUMENTS placeholders, and run it in the current repo context.",
         "Use `akm show <openRef>` to retrieve the command template body.",
+        "When `agent` is specified, dispatch the command to that agent.",
     ],
 };

package/dist/handlers/handler-bridge.js

@@ -0,0 +1,51 @@
+/**
+ * Bridge utility that converts legacy ShowInput into a RenderContext,
+ * allowing handlers to delegate their buildShowResponse to renderers.
+ */
+import path from "node:path";
+import { toPosix } from "../common";
+/**
+ * Convert a legacy ShowInput into a RenderContext suitable for passing
+ * to an AssetRenderer's buildShowResponse method.
+ *
+ * This avoids hitting the filesystem since ShowInput already carries
+ * the file content.
+ */
+export function showInputToRenderContext(input, rendererName) {
+    const absPath = path.resolve(input.path);
+    const stashDirs = input.stashDirs ?? [];
+    // Derive a stash root from stashDirs if possible
+    const stashRoot = stashDirs.find((d) => absPath.startsWith(path.resolve(d) + path.sep)) ?? stashDirs[0] ?? path.dirname(absPath);
+    const relPath = toPosix(path.relative(stashRoot, absPath));
+    const ext = path.extname(absPath).toLowerCase();
+    const fileName = path.basename(absPath);
+    const parentDirAbs = path.dirname(absPath);
+    const parentDir = path.basename(parentDirAbs);
+    const relDir = toPosix(path.dirname(relPath));
+    const ancestorDirs = relDir === "." ? [] : relDir.split("/").filter((seg) => seg.length > 0);
+    // Cache the content from input (no filesystem read needed)
+    const cachedContent = input.content;
+    const matchResult = {
+        type: rendererName.split("-")[0], // e.g. "tool" from "tool-script"
+        specificity: 10,
+        renderer: rendererName,
+        meta: { name: input.name, view: input.view },
+    };
+    return {
+        absPath,
+        relPath,
+        ext,
+        fileName,
+        parentDir,
+        parentDirAbs,
+        ancestorDirs,
+        stashRoot,
+        content: () => cachedContent,
+        frontmatter: () => null, // Renderers parse frontmatter from content() themselves
+        stat() {
+            throw new Error("stat() not available in handler bridge context");
+        },
+        matchResult,
+        stashDirs,
+    };
+}

package/dist/handlers/index.js

@@ -1,17 +1,19 @@
 import { registerAssetType } from "../asset-type-handler";
-import { toolHandler } from "./tool-handler";
-import { skillHandler } from "./skill-handler";
-import { commandHandler } from "./command-handler";
 import { agentHandler } from "./agent-handler";
+import { commandHandler } from "./command-handler";
 import { knowledgeHandler } from "./knowledge-handler";
 import { scriptHandler } from "./script-handler";
+import { skillHandler } from "./skill-handler";
+import { toolHandler } from "./tool-handler";
 /**
  * Register all built-in asset type handlers.
- * This must be called (imported) before any handler lookups.
+ * Called once from ensureHandlersRegistered in asset-type-handler.ts.
  */
-registerAssetType(toolHandler);
-registerAssetType(skillHandler);
-registerAssetType(commandHandler);
-registerAssetType(agentHandler);
-registerAssetType(knowledgeHandler);
-registerAssetType(scriptHandler);
+export function registerBuiltinHandlers() {
+    registerAssetType(toolHandler);
+    registerAssetType(skillHandler);
+    registerAssetType(commandHandler);
+    registerAssetType(agentHandler);
+    registerAssetType(knowledgeHandler);
+    registerAssetType(scriptHandler);
+}

package/dist/handlers/knowledge-handler.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
-import { parseMarkdownToc, extractSection, extractLineRange, extractFrontmatterOnly, formatToc } from "../markdown";
-import { isMarkdownFile, markdownCanonicalName, markdownAssetPath } from "./markdown-helpers";
+import { getRenderer } from "../file-context";
+import { parseMarkdownToc } from "../markdown";
+import { showInputToRenderContext } from "./handler-bridge";
+import { isMarkdownFile, markdownAssetPath, markdownCanonicalName } from "./markdown-helpers";
 export const knowledgeHandler = {
     typeName: "knowledge",
     stashDir: "knowledge",
@@ -8,35 +10,9 @@ export const knowledgeHandler = {
     toCanonicalName: markdownCanonicalName,
     toAssetPath: markdownAssetPath,
     buildShowResponse(input) {
-        const v = input.view ?? { mode: "full" };
-        switch (v.mode) {
-            case "toc": {
-                const toc = parseMarkdownToc(input.content);
-                return { type: "knowledge", name: input.name, path: input.path, content: formatToc(toc) };
-            }
-            case "frontmatter": {
-                const fm = extractFrontmatterOnly(input.content);
-                return { type: "knowledge", name: input.name, path: input.path, content: fm ?? "(no frontmatter)" };
-            }
-            case "section": {
-                const section = extractSection(input.content, v.heading);
-                if (!section) {
-                    return {
-                        type: "knowledge",
-                        name: input.name,
-                        path: input.path,
-                        content: `Section "${v.heading}" not found in ${input.name}. Try --view toc to discover available headings.`,
-                    };
-                }
-                return { type: "knowledge", name: input.name, path: input.path, content: section.content };
-            }
-            case "lines": {
-                return { type: "knowledge", name: input.name, path: input.path, content: extractLineRange(input.content, v.start, v.end) };
-            }
-            default: {
-                return { type: "knowledge", name: input.name, path: input.path, content: input.content };
-            }
-        }
+        const renderer = getRenderer("knowledge-md");
+        const ctx = showInputToRenderContext(input, "knowledge-md");
+        return renderer.buildShowResponse(ctx);
     },
     defaultUsageGuide: [
         "Use `akm show <openRef>` to read the document; start with `--view toc` for large files.",

package/dist/handlers/script-handler.js

@@ -1,10 +1,9 @@
 import path from "node:path";
-import { SCRIPT_EXTENSIONS, SCRIPT_EXTENSIONS_BROAD } from "../asset-spec";
-import { hasErrnoCode, toPosix } from "../common";
-import { buildToolInfo } from "../tool-runner";
+import { SCRIPT_EXTENSIONS_BROAD } from "../asset-spec";
+import { toPosix } from "../common";
+import { getRenderer } from "../file-context";
 import { extractDescriptionFromComments } from "../metadata";
-/** Extensions that buildToolInfo can handle (tool-runner supported) */
-const RUNNABLE_EXTENSIONS = SCRIPT_EXTENSIONS;
+import { showInputToRenderContext } from "./handler-bridge";
 export const scriptHandler = {
     typeName: "script",
     stashDir: "scripts",
@@ -18,48 +17,13 @@ export const scriptHandler = {
         return path.join(typeRoot, name);
     },
     buildShowResponse(input) {
-        const ext = path.extname(input.path).toLowerCase();
-        // For extensions supported by tool-runner, show runCmd
-        if (RUNNABLE_EXTENSIONS.has(ext)) {
-            const stashDirs = input.stashDirs ?? [];
-            const assetStashDir = stashDirs.find((d) => path.resolve(input.path).startsWith(path.resolve(d) + path.sep)) ?? stashDirs[0];
-            if (assetStashDir) {
-                try {
-                    const toolInfo = buildToolInfo(assetStashDir, input.path);
-                    return {
-                        type: "script",
-                        name: input.name,
-                        path: input.path,
-                        runCmd: toolInfo.runCmd,
-                        kind: toolInfo.kind,
-                    };
-                }
-                catch {
-                    // Fall through to content display
-                }
-            }
-        }
-        // For other extensions or when buildToolInfo fails, show file content
-        return {
-            type: "script",
-            name: input.name,
-            path: input.path,
-            content: input.content,
-        };
+        const renderer = getRenderer("script-source");
+        const ctx = showInputToRenderContext(input, "script-source");
+        return renderer.buildShowResponse(ctx);
     },
     enrichSearchHit(hit, stashDir) {
-        const ext = path.extname(hit.path).toLowerCase();
-        if (!RUNNABLE_EXTENSIONS.has(ext))
-            return;
-        try {
-            const toolInfo = buildToolInfo(stashDir, hit.path);
-            hit.runCmd = toolInfo.runCmd;
-            hit.kind = toolInfo.kind;
-        }
-        catch (error) {
-            if (!hasErrnoCode(error, "ENOENT"))
-                throw error;
-        }
+        const renderer = getRenderer("script-source");
+        renderer.enrichSearchHit(hit, stashDir);
     },
     defaultUsageGuide: [
         "Use the hit's runCmd for execution when available, or run the script directly with the appropriate interpreter.",

package/dist/handlers/skill-handler.js

@@ -1,5 +1,7 @@
 import path from "node:path";
 import { toPosix } from "../common";
+import { getRenderer } from "../file-context";
+import { showInputToRenderContext } from "./handler-bridge";
 export const skillHandler = {
     typeName: "skill",
     stashDir: "skills",
@@ -16,12 +18,9 @@ export const skillHandler = {
         return path.join(typeRoot, name, "SKILL.md");
     },
     buildShowResponse(input) {
-        return {
-            type: "skill",
-            name: input.name,
-            path: input.path,
-            content: input.content,
-        };
+        const renderer = getRenderer("skill-md");
+        const ctx = showInputToRenderContext(input, "skill-md");
+        return renderer.buildShowResponse(ctx);
     },
     defaultUsageGuide: [
         "Read and apply the skill instructions as written, then adapt examples to your current repo state and task.",

package/dist/handlers/tool-handler.js

@@ -1,8 +1,9 @@
 import path from "node:path";
 import { SCRIPT_EXTENSIONS } from "../asset-spec";
-import { hasErrnoCode, toPosix } from "../common";
-import { buildToolInfo } from "../tool-runner";
+import { toPosix } from "../common";
+import { getRenderer } from "../file-context";
 import { extractDescriptionFromComments } from "../metadata";
+import { showInputToRenderContext } from "./handler-bridge";
 export const toolHandler = {
     typeName: "tool",
     stashDir: "tools",
@@ -16,30 +17,13 @@ export const toolHandler = {
         return path.join(typeRoot, name);
     },
     buildShowResponse(input) {
-        const stashDirs = input.stashDirs ?? [];
-        const assetStashDir = stashDirs.find((d) => path.resolve(input.path).startsWith(path.resolve(d) + path.sep)) ?? stashDirs[0];
-        if (!assetStashDir) {
-            return { type: "tool", name: input.name, path: input.path, content: input.content };
-        }
-        const toolInfo = buildToolInfo(assetStashDir, input.path);
-        return {
-            type: "tool",
-            name: input.name,
-            path: input.path,
-            runCmd: toolInfo.runCmd,
-            kind: toolInfo.kind,
-        };
+        const renderer = getRenderer("tool-script");
+        const ctx = showInputToRenderContext(input, "tool-script");
+        return renderer.buildShowResponse(ctx);
     },
     enrichSearchHit(hit, stashDir) {
-        try {
-            const toolInfo = buildToolInfo(stashDir, hit.path);
-            hit.runCmd = toolInfo.runCmd;
-            hit.kind = toolInfo.kind;
-        }
-        catch (error) {
-            if (!hasErrnoCode(error, "ENOENT"))
-                throw error;
-        }
+        const renderer = getRenderer("tool-script");
+        renderer.enrichSearchHit(hit, stashDir);
     },
     defaultUsageGuide: [
         "Use the hit's runCmd for execution so runtime and working directory stay correct.",