akm-cli 0.7.1 → 0.7.3

package/dist/llm/client.js

@@ -51,8 +51,9 @@ export async function chatCompletion(config, messages, options) {
             messages,
             temperature: options?.temperature ?? config.temperature ?? 0.3,
             max_tokens: options?.maxTokens ?? config.maxTokens ?? 512,
+            ...config.extraParams,
         }),
-    });
+    }, 30_000, options?.signal);
     if (!response.ok) {
         const rawBody = await response.text().catch(() => "");
         const safeBody = redactErrorBody(rawBody);
@@ -65,6 +66,7 @@ export async function chatCompletion(config, messages, options) {
 export function stripJsonFences(raw) {
     return raw
         .trim()
+        .replace(/<think>[\s\S]*?<\/think>/gi, "")
         .replace(/^```(?:json)?\s*\n?/i, "")
         .replace(/\n?```\s*$/i, "")
         .trim();
@@ -78,6 +80,64 @@ export function parseJsonResponse(raw) {
         return undefined;
     }
 }
+/**
+ * Best-effort recovery for providers that wrap JSON in extra prose or fenced
+ * blocks. Extracts the first balanced top-level object/array and parses it.
+ */
+export function parseEmbeddedJsonResponse(raw) {
+    const direct = parseJsonResponse(raw);
+    if (direct !== undefined)
+        return direct;
+    const text = stripJsonFences(raw);
+    let arrayFallback;
+    for (let start = 0; start < text.length; start++) {
+        const opener = text[start];
+        if (opener !== "{" && opener !== "[")
+            continue;
+        const closer = opener === "{" ? "}" : "]";
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        for (let i = start; i < text.length; i++) {
+            const ch = text[i];
+            if (inString) {
+                if (escaped) {
+                    escaped = false;
+                }
+                else if (ch === "\\") {
+                    escaped = true;
+                }
+                else if (ch === '"') {
+                    inString = false;
+                }
+                continue;
+            }
+            if (ch === '"') {
+                inString = true;
+                continue;
+            }
+            if (ch === opener)
+                depth += 1;
+            if (ch === closer) {
+                depth -= 1;
+                if (depth === 0) {
+                    try {
+                        const parsed = JSON.parse(text.slice(start, i + 1));
+                        if (!Array.isArray(parsed)) {
+                            return parsed;
+                        }
+                        arrayFallback ??= parsed;
+                        break;
+                    }
+                    catch {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return arrayFallback;
+}
 // ── Availability check ──────────────────────────────────────────────────────
 /**
  * Check if the LLM endpoint is reachable.

package/dist/llm/embedder.js

@@ -47,14 +47,14 @@ export function resetLocalEmbedder() {
  * Results are cached in an LRU cache (max ~100 entries) keyed by query text
  * and embedding config. Repeated identical queries return the cached vector.
  */
-export async function embed(text, embeddingConfig) {
+export async function embed(text, embeddingConfig, signal) {
     const key = embedCacheKey(text, embeddingConfig);
     const cached = getCachedEmbedding(key);
     if (cached)
         return cached;
     const result = embeddingConfig && hasRemoteEndpoint(embeddingConfig)
-        ? await new RemoteEmbedder(embeddingConfig).embed(text)
-        : await localEmbedder.embedWithModel(text, embeddingConfig?.localModel);
+        ? await new RemoteEmbedder(embeddingConfig).embed(text, signal)
+        : await localEmbedder.embed(text, signal);
     setCachedEmbedding(key, result);
     return result;
 }
@@ -63,16 +63,19 @@ export async function embed(text, embeddingConfig) {
  * Uses the OpenAI-compatible batch API for remote endpoints (batches of 100).
  * Falls back to sequential embedding for the local transformer pipeline.
  */
-export async function embedBatch(texts, embeddingConfig) {
+export async function embedBatch(texts, embeddingConfig, signal) {
     if (texts.length === 0)
         return [];
     if (embeddingConfig && hasRemoteEndpoint(embeddingConfig)) {
-        return new RemoteEmbedder(embeddingConfig).embedBatch(texts);
+        return new RemoteEmbedder(embeddingConfig).embedBatch(texts, signal);
     }
     // Local transformer: process sequentially (pipeline handles one at a time)
     const localModel = embeddingConfig?.localModel;
     const results = [];
     for (const text of texts) {
+        if (signal?.aborted) {
+            throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
+        }
         results.push(await localEmbedder.embedWithModel(text, localModel));
     }
     return results;

package/dist/llm/embedders/local.js

@@ -42,14 +42,20 @@ export class LocalEmbedder {
         this.pipelinePromise = undefined;
         this.pipelineModelName = undefined;
     }
-    async embed(text) {
+    async embed(text, signal) {
+        if (signal?.aborted) {
+            throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
+        }
         return this.embedWithModel(text, this.defaultModel);
     }
-    async embedBatch(texts) {
+    async embedBatch(texts, signal) {
         if (texts.length === 0)
             return [];
         const results = [];
         for (const text of texts) {
+            if (signal?.aborted) {
+                throw signal.reason instanceof Error ? signal.reason : new Error("embedding interrupted");
+            }
             results.push(await this.embedWithModel(text, this.defaultModel));
         }
         return results;

package/dist/llm/embedders/remote.js

@@ -15,7 +15,7 @@ export class RemoteEmbedder {
     constructor(config) {
         this.config = config;
     }
-    async embed(text) {
+    async embed(text, signal) {
         const headers = this.buildHeaders();
         const body = {
             input: text,
@@ -32,6 +32,7 @@ export class RemoteEmbedder {
             method: "POST",
             headers,
             body: JSON.stringify(body),
+            signal,
         });
         if (!response.ok) {
             const errBody = await response.text().catch(() => "");
@@ -43,7 +44,7 @@ export class RemoteEmbedder {
         }
         return l2Normalize(json.data[0].embedding);
     }
-    async embedBatch(texts) {
+    async embedBatch(texts, signal) {
         if (texts.length === 0)
             return [];
         const results = [];
@@ -66,6 +67,7 @@ export class RemoteEmbedder {
                 method: "POST",
                 headers,
                 body: JSON.stringify(body),
+                signal,
             });
             if (!response.ok) {
                 const respBody = await response.text().catch(() => "");

package/dist/llm/graph-extract.js

@@ -19,7 +19,7 @@
  */
 import { toErrorMessage } from "../core/common";
 import { warn } from "../core/warn";
-import { chatCompletion, parseJsonResponse } from "./client";
+import { chatCompletion, parseEmbeddedJsonResponse } from "./client";
 /** Hard cap on body chars sent to the model. */
 const MAX_BODY_CHARS = 4000;
 /** Hard cap on entities returned per asset — guards against runaway LLM output. */
@@ -49,7 +49,7 @@ Asset body:
  * JSON, empty response). Errors are logged via `warn()` but never thrown — a
  * failed extraction for one asset must not abort the rest of the index pass.
  */
-export async function extractGraphFromBody(llmConfig, body) {
+export async function extractGraphFromBody(llmConfig, body, signal) {
     const empty = { entities: [], relations: [] };
     const trimmedBody = body.trim();
     if (!trimmedBody)
@@ -61,14 +61,14 @@ export async function extractGraphFromBody(llmConfig, body) {
             chatCompletion(llmConfig, [
                 { role: "system", content: SYSTEM_PROMPT },
                 { role: "user", content: userPrompt },
-            ], { maxTokens: 1024, temperature: 0.1 }),
+            ], { maxTokens: 1024, temperature: 0.1, signal }),
             new Promise((_, reject) => {
                 timeoutHandle = setTimeout(() => reject(new Error("graph extraction timed out")), LLM_TIMEOUT_MS);
             }),
         ]);
         if (!raw)
             return empty;
-        const parsed = parseJsonResponse(raw);
+        const parsed = parseEmbeddedJsonResponse(raw);
         if (!parsed) {
             warn("graph extraction: invalid JSON response from LLM; skipping asset.");
             return empty;

package/dist/llm/memory-infer.js

@@ -1,11 +1,11 @@
 /**
  * LLM helper for the `akm index` memory-inference pass (#201).
  *
- * Splits a single memory body into a list of atomic facts. The pass itself
- * (in `src/indexer/memory-inference.ts`) is responsible for deciding which
- * memories are pending, persisting the resulting atomic memories with the
- * correct frontmatter (`inferred: true`, `source: <parent-ref>`), and
- * marking the parent as processed for idempotency.
+ * Compresses a single memory body into one higher-signal derived memory. The
+ * pass itself (in `src/indexer/memory-inference.ts`) is responsible for
+ * deciding which memories are pending, persisting the derived memory with the
+ * correct frontmatter (`inferred: true`, `source: <parent-ref>`), and marking
+ * the parent as processed for idempotency.
  *
  * This module is intentionally tiny and stateless so tests can stub it via
  * `mock.module("../src/llm/memory-infer", ...)` without hitting a network.
@@ -17,38 +17,50 @@
  */
 import { toErrorMessage } from "../core/common";
 import { warn } from "../core/warn";
-import { chatCompletion, parseJsonResponse } from "./client";
+import { chatCompletion, parseEmbeddedJsonResponse } from "./client";
 /** Hard cap on body chars sent to the model — pragmatic and matches `runLlmEnrich`. */
 const MAX_BODY_CHARS = 4000;
-/** Hard cap on the number of atomic facts returned per memory. */
-const MAX_FACTS_PER_MEMORY = 16;
 /** Hard timeout for the LLM call. The index run must not hang on a misbehaving endpoint. */
 const LLM_TIMEOUT_MS = 30_000;
-const SYSTEM_PROMPT = "You split a developer memory into atomic, self-contained facts. " +
-    "Return only valid JSON. No prose, no markdown fences.";
-const USER_PROMPT_PREFIX = `Split the memory below into a JSON array of short, self-contained atomic facts.
+const SYSTEM_PROMPT = "You compress a developer memory into one high-signal derived memory for later retrieval. " +
+    "Return only valid JSON. No prose outside the JSON object. No markdown fences.";
+const USER_PROMPT_PREFIX = `Compress the memory below into one concise, information-dense derived memory.
 
 Rules:
-- Output ONLY a JSON object: {"facts": ["fact one", "fact two", ...]}.
-- Each fact is a single complete sentence, decontextualized so it stands alone.
-- Drop pleasantries, meta-commentary, and timestamps.
-- Preserve technical specifics (names, versions, identifiers) verbatim.
-- If the memory is already a single atomic fact, return it as the only entry.
-- Limit to at most ${MAX_FACTS_PER_MEMORY} facts.
+- Output ONLY a JSON object with exactly these keys: {"title": string, "description": string, "tags": string[], "searchHints": string[], "content": string}.
+- ` +
+    '"title"' +
+    ` is a short, descriptive title for the derived memory.
+- ` +
+    '"description"' +
+    ` is one sentence explaining why this derived memory matters.
+- ` +
+    '"tags"' +
+    ` contains 3-8 specific keywords.
+- ` +
+    '"searchHints"' +
+    ` contains 3-6 natural-language retrieval phrases.
+- ` +
+    '"content"' +
+    ` must be compact markdown that preserves the reusable insight, root cause, fix, constraints, and applicability conditions when present.
+- Prefer 2-4 short sections with informative headings over long prose.
+- Omit timestamps, verification-only metrics, pleasantries, and session-specific chatter unless they are essential to applying the insight later.
+- Preserve technical specifics (names, versions, identifiers, selectors, file paths, config keys) verbatim.
 
 Memory:
 `;
 /**
- * Split a single memory body into atomic facts via the configured LLM.
+ * Compress a single memory body into one derived memory via the configured LLM.
  *
- * Returns `[]` on any failure (timeout, invalid JSON, empty response). Errors
+ * Returns `undefined` on any failure (timeout, invalid JSON, empty response).
+ * Errors
  * are logged via `warn()` but never thrown — a failed split for one memory
  * must not abort the rest of the index pass.
  */
-export async function splitMemoryIntoAtomicFacts(llmConfig, body) {
+export async function compressMemoryToDerivedMemory(llmConfig, body, signal) {
     const trimmedBody = body.trim();
     if (!trimmedBody)
-        return [];
+        return undefined;
     const userPrompt = `${USER_PROMPT_PREFIX}${trimmedBody.slice(0, MAX_BODY_CHARS)}`;
     let timeoutHandle;
     try {
@@ -56,28 +68,44 @@ export async function splitMemoryIntoAtomicFacts(llmConfig, body) {
             chatCompletion(llmConfig, [
                 { role: "system", content: SYSTEM_PROMPT },
                 { role: "user", content: userPrompt },
-            ], { maxTokens: 768, temperature: 0.1 }),
+            ], { maxTokens: 768, temperature: 0.1, signal }),
             new Promise((_, reject) => {
                 timeoutHandle = setTimeout(() => reject(new Error("memory inference timed out")), LLM_TIMEOUT_MS);
             }),
         ]);
         if (!raw)
-            return [];
-        const parsed = parseJsonResponse(raw);
-        if (!parsed || !Array.isArray(parsed.facts)) {
+            return undefined;
+        const parsed = parseEmbeddedJsonResponse(raw);
+        if (!parsed) {
             warn("memory inference: invalid JSON response from LLM; skipping memory.");
-            return [];
+            return undefined;
         }
-        const facts = parsed.facts
-            .filter((f) => typeof f === "string")
-            .map((f) => f.trim())
-            .filter((f) => f.length > 0)
-            .slice(0, MAX_FACTS_PER_MEMORY);
-        return facts;
+        const title = typeof parsed.title === "string" ? parsed.title.trim() : "";
+        const description = typeof parsed.description === "string" ? parsed.description.trim() : "";
+        const content = typeof parsed.content === "string" ? parsed.content.trim() : "";
+        const tags = Array.isArray(parsed.tags)
+            ? parsed.tags
+                .filter((t) => typeof t === "string")
+                .map((t) => t.trim())
+                .filter(Boolean)
+                .slice(0, 8)
+            : [];
+        const searchHints = Array.isArray(parsed.searchHints)
+            ? parsed.searchHints
+                .filter((h) => typeof h === "string")
+                .map((h) => h.trim())
+                .filter(Boolean)
+                .slice(0, 6)
+            : [];
+        if (!title || !description || !content || tags.length === 0 || searchHints.length === 0) {
+            warn("memory inference: incomplete derived memory payload from LLM; skipping memory.");
+            return undefined;
+        }
+        return { title, description, tags, searchHints, content };
     }
     catch (err) {
         warn(`memory inference failed: ${toErrorMessage(err)}`);
-        return [];
+        return undefined;
     }
     finally {
         if (timeoutHandle !== undefined)

package/dist/llm/metadata-enhance.js

@@ -11,7 +11,7 @@ const SYSTEM_PROMPT = `You are a metadata generator for a developer asset regist
  * Use an LLM to enhance a stash entry's metadata: improve description,
  * generate searchHints, and suggest tags.
  */
-export async function enhanceMetadata(config, entry, fileContent) {
+export async function enhanceMetadata(config, entry, fileContent, signal) {
     const contextParts = [`Name: ${entry.name}`, `Type: ${entry.type}`];
     if (entry.description)
         contextParts.push(`Current description: ${entry.description}`);
@@ -33,7 +33,7 @@ Return ONLY the JSON object, no explanation.`;
     const raw = await chatCompletion(config, [
         { role: "system", content: SYSTEM_PROMPT },
         { role: "user", content: userPrompt },
-    ]);
+    ], { signal });
     const parsed = parseJsonResponse(raw);
     if (!parsed)
         return {};

package/dist/output/cli-hints.js

@@ -133,6 +133,7 @@ akm remember "Deployment needs VPN access"     # Record a memory in your stash
 akm remember --name release-retro < notes.md   # Save multiline memory from stdin
 akm import ./docs/auth-flow.md                 # Import a file as knowledge
 akm import - --name scratch-notes < notes.md   # Import stdin as a knowledge doc
+akm import https://example.com/docs/auth       # Fetch one URL and import it as knowledge
 akm workflow create ship-release               # Create a workflow asset in the stash
 akm workflow validate workflows/foo.md         # Validate a workflow file or ref; lists every error
 akm workflow next workflow:ship-release        # Start or resume the next workflow step
@@ -160,6 +161,7 @@ akm wiki show research                         # Path, description, counts, last
 akm wiki pages research                        # Page refs + descriptions (excludes schema/index/log; includes raw/)
 akm wiki search research "attention"           # Scoped search (equivalent to --type wiki --wiki research)
 akm wiki stash research ./paper.md             # Copy source into raw/<slug>.md (never overwrites)
+akm wiki stash research https://example.com/paper # Fetch one URL into raw/<slug>.md
 echo "..." | akm wiki stash research -         # stdin form
 akm wiki lint research                         # Structural checks: orphans, broken xrefs, uncited raws, stale index
 akm wiki ingest research                       # Print the ingest workflow for this wiki (no action)
@@ -285,8 +287,9 @@ akm config path --all                         # Show all config paths
 
 \`\`\`sh
 akm init                                      # Initialize working stash
-akm index                                     # Rebuild search index
-akm index --full                              # Full reindex
+akm index                                     # Rebuild search index (no LLM enrichment)
+akm index --full                              # Full reindex (no LLM enrichment)
+akm index --enrich                            # Reindex with LLM inference/enrichment passes
 akm list                                      # List all sources
 akm upgrade                                   # Upgrade akm using its install method
 akm upgrade --check                           # Check for updates

package/dist/output/renderers.js

@@ -13,7 +13,7 @@ import { hasErrnoCode } from "../core/common";
 import { parseFrontmatter, toStringOrUndefined } from "../core/frontmatter";
 import { extractFrontmatterOnly, extractLineRange, extractSection, formatToc, parseMarkdownToc, } from "../core/markdown";
 import { registerRenderer } from "../indexer/file-context";
-import { extractDescriptionFromComments, loadStashFile } from "../indexer/metadata";
+import { extractCommentMetadata, extractDescriptionFromComments } from "../indexer/metadata";
 import { buildWorkflowAction, workflowMdRenderer } from "../workflows/renderer";
 // ── Interpreter auto-detection map ───────────────────────────────────────────
 const INTERPRETER_MAP = {
@@ -49,36 +49,12 @@ const SETUP_SIGNALS = {
  * `@run <value>`, `@setup <value>`, or `@cwd <value>`.
  */
 export function extractCommentTags(filePath) {
-    let content;
-    try {
-        content = fs.readFileSync(filePath, "utf8");
-    }
-    catch {
-        return {};
-    }
-    const lines = content.split(/\r?\n/, 50);
-    const hints = {};
-    for (const line of lines) {
-        const trimmed = line.trim();
-        // Match lines starting with comment markers: //, #, /*, *, ;, --
-        if (!/^(?:\/\/|#|\/?\*|;|--)/.test(trimmed) && !trimmed.startsWith("'"))
-            continue;
-        // Strip comment prefix
-        const cleaned = trimmed
-            .replace(/^(?:\/\/|##?|\/?\*\*?\/?|;|--)\s*/, "")
-            .replace(/\*\/\s*$/, "")
-            .trim();
-        const runMatch = cleaned.match(/^@run\s+(.+)/);
-        if (runMatch)
-            hints.run = runMatch[1].trim();
-        const setupMatch = cleaned.match(/^@setup\s+(.+)/);
-        if (setupMatch)
-            hints.setup = setupMatch[1].trim();
-        const cwdMatch = cleaned.match(/^@cwd\s+(.+)/);
-        if (cwdMatch)
-            hints.cwd = cwdMatch[1].trim();
-    }
-    return hints;
+    const metadata = extractCommentMetadata(filePath);
+    return {
+        run: metadata?.run,
+        setup: metadata?.setup,
+        cwd: metadata?.cwd,
+    };
 }
 // ── Auto-detection ───────────────────────────────────────────────────────────
 /**
@@ -118,9 +94,9 @@ export function detectExecHints(filePath) {
  * 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
- * 2. Script file header comments (`@run`/`@setup`/`@cwd`) second
- * 3. Auto-detection from extension + dependency files last
+ * 1. Indexed entry metadata (`run`/`setup`/`cwd`) when supplied by the caller
+ * 2. Script file header comments (`@run`/`@setup`/`@cwd`)
+ * 3. Auto-detection from extension + dependency files
  */
 export function resolveExecHints(stashEntry, filePath) {
     const stashHints = {
@@ -152,17 +128,6 @@ function deriveName(ctx) {
     return ext ? ctx.relPath.slice(0, -ext.length) : ctx.relPath;
 }
 export { buildWorkflowAction };
-/**
- * Load the matching StashEntry for a file path from the directory's .stash.json.
- */
-function findStashEntryForFile(filePath) {
-    const dir = path.dirname(filePath);
-    const stashFile = loadStashFile(dir);
-    if (!stashFile)
-        return undefined;
-    const fileName = path.basename(filePath);
-    return stashFile.entries.find((e) => e.filename === fileName);
-}
 function extractParameters(template) {
     const parameters = [];
     if (/\$ARGUMENTS\b/i.test(template)) {
@@ -182,18 +147,26 @@ function extractParameters(template) {
     }
     return parameters.length > 0 ? parameters : undefined;
 }
+function readFrontmatterTags(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const tags = value.filter((tag) => typeof tag === "string" && tag.trim().length > 0);
+    return tags.length > 0 ? tags : undefined;
+}
 // ── 1. skill-md ──────────────────────────────────────────────────────────────
 const skillMdRenderer = {
     name: "skill-md",
     buildShowResponse(ctx) {
         const name = deriveName(ctx);
         const parsed = parseFrontmatter(ctx.content());
+        const tags = readFrontmatterTags(parsed.data.tags);
         return {
             type: "skill",
             name,
             path: ctx.absPath,
             action: "Read and follow the instructions below",
             description: toStringOrUndefined(parsed.data.description),
+            ...(tags ? { tags } : {}),
             content: parsed.content,
         };
     },
@@ -205,12 +178,14 @@ const commandMdRenderer = {
         const name = deriveName(ctx);
         const parsedMd = parseFrontmatter(ctx.content());
         const template = parsedMd.content;
+        const tags = readFrontmatterTags(parsedMd.data.tags);
         return {
             type: "command",
             name,
             path: ctx.absPath,
             action: "Fill $ARGUMENTS placeholders in the template, then dispatch",
             description: toStringOrUndefined(parsedMd.data.description),
+            ...(tags ? { tags } : {}),
             template,
             modelHint: typeof parsedMd.data.model === "string" ? parsedMd.data.model : undefined,
             agent: toStringOrUndefined(parsedMd.data.agent),
@@ -527,8 +502,7 @@ const scriptSourceRenderer = {
         const ext = path.extname(ctx.absPath).toLowerCase();
         // For extensions with a known interpreter, show exec hints
         if (INTERPRETER_MAP[ext]) {
-            const stashEntry = findStashEntryForFile(ctx.absPath);
-            const hints = resolveExecHints(stashEntry, ctx.absPath);
+            const hints = resolveExecHints(undefined, ctx.absPath);
             if (hints.run) {
                 return {
                     type: "script",
@@ -555,8 +529,7 @@ const scriptSourceRenderer = {
         if (!INTERPRETER_MAP[ext])
             return;
         try {
-            const stashEntry = findStashEntryForFile(hit.path);
-            const hints = resolveExecHints(stashEntry, hit.path);
+            const hints = resolveExecHints(undefined, hit.path);
             hit.run = hints.run;
         }
         catch (error) {

package/dist/registry/build-index.js

@@ -245,27 +245,22 @@ async function enumerateAssets(stashRoot) {
     }
     const entries = [];
     for (const [dirPath, files] of dirGroups) {
-        let stash = loadStashFile(dirPath);
-        if (stash) {
-            const covered = new Set(stash.entries.map((entry) => entry.filename).filter((value) => !!value));
-            const uncoveredFiles = files.filter((file) => !covered.has(path.basename(file)));
-            if (uncoveredFiles.length > 0) {
-                const generated = await generateMetadataFlat(stashRoot, uncoveredFiles);
-                if (generated.entries.length > 0) {
-                    stash = { entries: [...stash.entries, ...generated.entries] };
-                }
-            }
-        }
-        else {
-            const generated = await generateMetadataFlat(stashRoot, files);
-            if (generated.entries.length === 0)
-                continue;
-            stash = generated;
-        }
-        entries.push(...stash.entries.map((entry) => attachFileSize(dirPath, entry)));
+        const generated = await generateMetadataFlat(stashRoot, files);
+        const legacyOverrides = loadStashFile(dirPath, { requireFilename: true });
+        const mergedEntries = legacyOverrides
+            ? generated.entries.map((entry) => mergeLegacyEntry(entry, legacyOverrides.entries))
+            : generated.entries;
+        const stash = mergedEntries.length > 0 ? { entries: mergedEntries } : legacyOverrides;
+        if (!stash || stash.entries.length === 0)
+            continue;
+        entries.push(...stash.entries.filter((entry) => !!entry.filename).map((entry) => attachFileSize(dirPath, entry)));
     }
     return entries.sort((a, b) => `${a.type}:${a.name}`.localeCompare(`${b.type}:${b.name}`));
 }
+function mergeLegacyEntry(entry, legacyEntries) {
+    const legacy = legacyEntries.find((candidate) => candidate.filename === entry.filename);
+    return legacy ? { ...entry, ...legacy, filename: entry.filename } : entry;
+}
 function attachFileSize(dirPath, entry) {
     if (typeof entry.fileSize === "number" || !entry.filename)
         return entry;