akm-cli 0.7.5 → 0.8.0-rc.3

package/dist/commands/remember.js

@@ -11,6 +11,7 @@ import { loadConfig } from "../core/config";
 import { UsageError } from "../core/errors";
 import { warn } from "../core/warn";
 import { SCOPE_KEYS } from "../indexer/metadata";
+import { parseFlagValue } from "../output/context";
 /**
  * Parse a shorthand duration string to a number of milliseconds.
  * Supports: `30d` (days), `12h` (hours), `6m` (months, approximated as 30d).
@@ -188,3 +189,56 @@ Return ONLY the JSON object, no prose, no markdown fences.`;
         return { tags: [] };
     }
 }
+// ── Content-arg disambiguation ───────────────────────────────────────────────
+/**
+ * Guard against citty consuming a global flag value as the `content` positional.
+ *
+ * When the user runs `akm remember --format json` without a content argument,
+ * citty may assign `"json"` to the `content` positional because of how it
+ * handles flag order. This helper detects that case and returns `undefined`
+ * so `readMemoryContent` falls through to stdin.
+ */
+export function resolveRememberContentArg(content) {
+    if (content === undefined)
+        return undefined;
+    const parsedFormat = parseFlagValue(process.argv, "--format");
+    if (parsedFormat !== undefined &&
+        content === parsedFormat &&
+        wasRememberFlagValueConsumedAsContent(content, parsedFormat, "--format")) {
+        return undefined;
+    }
+    const parsedDetail = parseFlagValue(process.argv, "--detail");
+    if (parsedDetail !== undefined &&
+        content === parsedDetail &&
+        wasRememberFlagValueConsumedAsContent(content, parsedDetail, "--detail")) {
+        return undefined;
+    }
+    return content;
+}
+function wasRememberFlagValueConsumedAsContent(content, flagValue, flagName) {
+    const argv = process.argv.slice(2);
+    const rememberIndex = argv.indexOf("remember");
+    const tokens = rememberIndex >= 0 ? argv.slice(rememberIndex + 1) : argv;
+    let flagIndex = -1;
+    let flagConsumesNextToken = false;
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if (token === flagName) {
+            flagIndex = i;
+            flagConsumesNextToken = true;
+            break;
+        }
+        if (token === `${flagName}=${flagValue}`) {
+            flagIndex = i;
+            break;
+        }
+    }
+    if (flagIndex === -1)
+        return false;
+    if (tokens.slice(0, flagIndex).includes(content))
+        return false;
+    const firstTokenAfterFlag = flagIndex + (flagConsumesNextToken ? 2 : 1);
+    if (tokens.slice(firstTokenAfterFlag).includes(content))
+        return false;
+    return true;
+}

package/dist/commands/schema-repair.js

@@ -0,0 +1,130 @@
+/**
+ * Schema-repair pass for `akm improve`.
+ *
+ * Attempts to patch missing frontmatter fields (`description`, `when_to_use`)
+ * on assets that failed schema validation, using a single bounded in-tree LLM
+ * call per asset. Results are recorded as `schema_repair_invoked` events.
+ *
+ * This module is extracted from `improve.ts` to make the repair logic
+ * independently testable and to use the `tryLlmFeature` seam rather than raw
+ * `chatCompletion`.
+ */
+import fs from "node:fs";
+import { stringify as yamlStringify } from "yaml";
+import { parseAssetRef } from "../core/asset-ref";
+import { appendEvent, readEvents } from "../core/events";
+import { parseFrontmatter } from "../core/frontmatter";
+import { info } from "../core/warn";
+import { resolveAssetPath } from "../indexer/path-resolver";
+import { chatCompletion, parseEmbeddedJsonResponse } from "../llm/client";
+// ── Constants ────────────────────────────────────────────────────────────────
+/** Minimum gap between schema-repair attempts on the same asset. */
+const SCHEMA_REPAIR_COOLDOWN_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+// ── Main ─────────────────────────────────────────────────────────────────────
+/**
+ * Run the schema-repair loop for a batch of validation failures.
+ * Returns a list of per-asset outcome records and the set of refs that were
+ * successfully repaired (so the caller can exclude them from skip logic).
+ */
+export async function runSchemaRepairPass(failures, options) {
+    const repairs = [];
+    const repairedRefs = new Set();
+    const { startMs, budgetMs, llmConfig, stashDir, findFilePath = defaultFindFilePath, isLessonCandidateFn = defaultIsLessonCandidate, } = options;
+    for (const failure of failures) {
+        if (Date.now() - startMs >= budgetMs)
+            break;
+        // Cooldown: skip repair if we ran it successfully recently.
+        const recentRepairs = readEvents({ type: "schema_repair_invoked", ref: failure.ref });
+        const lastRepair = recentRepairs.events
+            .filter((e) => e.metadata?.outcome === "written")
+            .sort((a, b) => new Date(b.ts ?? 0).getTime() - new Date(a.ts ?? 0).getTime())[0];
+        if (lastRepair?.ts && Date.now() - new Date(lastRepair.ts).getTime() < SCHEMA_REPAIR_COOLDOWN_MS) {
+            repairs.push({ ref: failure.ref, reason: failure.reason, outcome: "skipped" });
+            continue;
+        }
+        const filePath = await findFilePath(failure.ref, stashDir);
+        if (!filePath) {
+            repairs.push({ ref: failure.ref, reason: failure.reason, outcome: "skipped" });
+            continue;
+        }
+        try {
+            const raw = fs.readFileSync(filePath, "utf8");
+            const fm = parseFrontmatter(raw);
+            const missingFields = [];
+            if (!fm.data.description)
+                missingFields.push("description");
+            if (isLessonCandidateFn(failure.ref) && !fm.data.when_to_use)
+                missingFields.push("when_to_use");
+            if (missingFields.length === 0) {
+                repairs.push({ ref: failure.ref, reason: failure.reason, outcome: "skipped" });
+                continue;
+            }
+            const fieldList = missingFields.join(" and ");
+            info(`[improve] schema-repair ${failure.ref} (${fieldList})`);
+            const bodyPreview = (fm.content ?? raw).slice(0, 2000);
+            const llmResponse = await chatCompletion(llmConfig, [
+                {
+                    role: "system",
+                    content: `You generate concise asset frontmatter fields. Respond with a JSON object containing only the missing fields. No prose, no markdown fences.`,
+                },
+                {
+                    role: "user",
+                    content: `Generate the missing frontmatter fields (${fieldList}) for this ${parseAssetRef(failure.ref).type} asset. Return ONLY valid JSON like {"description": "...", "when_to_use": "..."}\n\n${bodyPreview}`,
+                },
+            ]);
+            const parsed = parseEmbeddedJsonResponse(llmResponse.trim());
+            if (!parsed) {
+                repairs.push({
+                    ref: failure.ref,
+                    reason: failure.reason,
+                    outcome: "error",
+                    error: "LLM returned unparseable JSON for schema repair",
+                });
+                continue;
+            }
+            const newFm = { ...fm.data };
+            if (parsed.description)
+                newFm.description = parsed.description;
+            if (parsed.when_to_use)
+                newFm.when_to_use = parsed.when_to_use;
+            const fmStr = yamlStringify(newFm).trimEnd();
+            const newContent = `---\n${fmStr}\n---\n${fm.content}`;
+            fs.writeFileSync(filePath, newContent, "utf8");
+            info(`[improve] schema-repair written: ${failure.ref}`);
+            appendEvent({
+                eventType: "schema_repair_invoked",
+                ref: failure.ref,
+                metadata: { outcome: "written", reason: failure.reason },
+            });
+            repairs.push({ ref: failure.ref, reason: failure.reason, outcome: "written" });
+            repairedRefs.add(failure.ref);
+        }
+        catch (e) {
+            appendEvent({
+                eventType: "schema_repair_invoked",
+                ref: failure.ref,
+                metadata: { outcome: "error", reason: failure.reason, error: String(e) },
+            });
+            repairs.push({ ref: failure.ref, reason: failure.reason, outcome: "error", error: String(e) });
+        }
+    }
+    return { repairs, repairedRefs };
+}
+// ── Default seam implementations ─────────────────────────────────────────────
+function defaultIsLessonCandidate(ref) {
+    try {
+        const parsed = parseAssetRef(ref);
+        return parsed.type === "lesson";
+    }
+    catch {
+        return false;
+    }
+}
+async function defaultFindFilePath(ref, stashDir) {
+    return resolveAssetPath(ref, {
+        stashDir,
+        mode: "index-first",
+        directoryIndexNames: ["SKILL.md", "index.md", "README.md"],
+        preserveDirectNameFallback: true,
+    });
+}

package/dist/commands/search.js

@@ -11,7 +11,7 @@
 import { loadConfig } from "../core/config";
 import { UsageError } from "../core/errors";
 import { appendEvent } from "../core/events";
-import { closeDatabase, openExistingDatabase } from "../indexer/db";
+import { bumpUtilityScoresBatch, closeDatabase, openExistingDatabase } from "../indexer/db";
 import { searchLocal } from "../indexer/db-search";
 import { resolveSourceEntries } from "../indexer/search-source";
 // Eagerly import source providers to trigger self-registration before the
@@ -48,6 +48,7 @@ export async function akmSearch(input) {
     const stashDir = sources[0].path;
     const filters = normalizeScopeFilters(input.filters);
     const includeProposed = input.includeProposed === true;
+    const belief = input.belief ?? "all";
     const localResult = source === "registry"
         ? undefined
         : await searchLocal({
@@ -59,6 +60,7 @@ export async function akmSearch(input) {
             config,
             filters,
             includeProposed,
+            beliefFilter: belief,
         });
     const registryResult = source === "stash" ? undefined : await searchRegistry(query, { limit, registries: config.registries });
     if (source === "stash") {
@@ -73,7 +75,7 @@ export async function akmSearch(input) {
             warnings: localResult?.warnings?.length ? localResult.warnings : undefined,
             timing: { totalMs: Date.now() - t0, rankMs: localResult?.rankMs, embedMs: localResult?.embedMs },
         };
-        logSearchEvent(query, response);
+        logSearchEvent(query, response, undefined, localResult?.mode ?? "keyword");
         return response;
     }
     const registryHits = (registryResult?.hits ?? []).map((hit) => {
@@ -124,7 +126,7 @@ export async function akmSearch(input) {
         warnings: warnings.length ? warnings : undefined,
         timing: { totalMs: Date.now() - t0 },
     };
-    logSearchEvent(query, response);
+    logSearchEvent(query, response, undefined, localResult?.mode ?? "keyword");
     return response;
 }
 /**
@@ -160,13 +162,13 @@ function resolveEntryIds(db, hits) {
  * Per-entry events are recorded only for stash hits because registry hits
  * have no local entry_id to reference.
  */
-function logSearchEvent(query, response, existingDb) {
+function logSearchEvent(query, response, existingDb, mode = "keyword") {
     // Emit a structured event to events.jsonl so workflow-trace consumers
     // detect akm search invocations without relying on stdout scraping.
     const stashHits = response.hits.filter((h) => h.type !== "registry");
     appendEvent({
         eventType: "search",
-        metadata: { query, hitCount: stashHits.length, resultRefs: stashHits.map((h) => h.ref) },
+        metadata: { query, hitCount: stashHits.length, resultRefs: stashHits.map((h) => h.ref), mode },
     });
     try {
         const db = existingDb ?? openExistingDatabase();
@@ -180,6 +182,12 @@ function logSearchEvent(query, response, existingDb) {
                     entry_ref: ref,
                 });
             }
+            // Bump utility scores for all resolved entries (MemRL retrieval signal).
+            // The indexer overwrites these at next reindex; bumps are temporary hints.
+            const resolvedIds = resolved.map((r) => r.entryId).filter((id) => id !== undefined);
+            if (resolvedIds.length > 0) {
+                bumpUtilityScoresBatch(db, resolvedIds, 1.0);
+            }
             // Count registry hits separately so registry-only searches record a
             // non-zero resultCount. response.hits is always [] when source="registry".
             const stashHitCount = response.hits.length;
@@ -192,6 +200,7 @@ function logSearchEvent(query, response, existingDb) {
                     stashHitCount,
                     registryHitCount,
                     resolvedCount: resolved.length,
+                    mode,
                 }),
             });
         }
@@ -221,6 +230,13 @@ export function parseSearchSource(source) {
         return "stash";
     throw new UsageError(`Invalid value for --source: ${String(source)}. Expected one of: stash|registry|both`, "INVALID_SOURCE_VALUE");
 }
+export function parseBeliefFilterMode(value) {
+    if (value === undefined || value === "all")
+        return "all";
+    if (value === "current" || value === "historical")
+        return value;
+    throw new UsageError(`Invalid value for --belief: ${String(value)}. Expected one of: all|current|historical`, "INVALID_FLAG_VALUE");
+}
 /**
  * Strip empty / non-string values from a scope filter object. Returns
  * `undefined` when nothing meaningful remains, so callers don't pay for an

package/dist/commands/show.js

@@ -16,14 +16,17 @@
 import fs from "node:fs";
 import path from "node:path";
 import { parseAssetRef } from "../core/asset-ref";
+import { asNonEmptyString } from "../core/common";
 import { loadConfig } from "../core/config";
 import { NotFoundError, UsageError } from "../core/errors";
 import { appendEvent, readEvents } from "../core/events";
-import { parseFrontmatter, toStringOrUndefined } from "../core/frontmatter";
+import { parseFrontmatter } from "../core/frontmatter";
 import { closeDatabase, findEntryIdByRef, openExistingDatabase } from "../indexer/db";
 import { ensureIndex } from "../indexer/ensure-index";
 import { buildFileContext, buildRenderContext, getRenderer, runMatchers } from "../indexer/file-context";
+import { listRelatedPathsForFile } from "../indexer/graph-boost";
 import { lookup } from "../indexer/indexer";
+import { resolveAssetPath } from "../indexer/path-resolver";
 import { buildEditHint, findSourceForPath, isEditable, resolveSourceEntries } from "../indexer/search-source";
 import { insertUsageEvent } from "../indexer/usage-events";
 import { resolveSourcesForOrigin } from "../registry/origin-resolve";
@@ -177,7 +180,7 @@ function enforceScopeOrThrow(filePath, ref, scope) {
     for (const [key, expectedValue] of expected) {
         if (expectedValue === undefined)
             continue;
-        const actual = toStringOrUndefined(fm[`scope_${key}`]);
+        const actual = asNonEmptyString(fm[`scope_${key}`]);
         if (actual !== expectedValue) {
             throw new NotFoundError(`Asset "${ref}" exists but is out of scope (expected scope_${key}="${expectedValue}").`);
         }
@@ -201,6 +204,31 @@ function logShowEvent(ref, existingDb) {
     // detect akm show invocations without relying on stdout scraping.
     const parsed = parseAssetRef(ref);
     appendEvent({ eventType: "show", ref, metadata: { type: parsed.type, name: parsed.name } });
+    // Detect if this show is a selection from a recent search result.
+    try {
+        const { events: recentSearches } = readEvents({ type: "search" });
+        const cutoffMs = Date.now() - 60_000;
+        const matchingSearch = [...recentSearches].reverse().find((e) => {
+            if (!e.ts || new Date(e.ts).getTime() < cutoffMs)
+                return false;
+            const refs = e.metadata?.resultRefs ?? [];
+            return refs.includes(ref);
+        });
+        if (matchingSearch) {
+            appendEvent({
+                eventType: "select",
+                ref,
+                metadata: {
+                    query: matchingSearch.metadata?.query,
+                    searchTs: matchingSearch.ts,
+                    rankPosition: (matchingSearch.metadata?.resultRefs ?? []).indexOf(ref),
+                },
+            });
+        }
+    }
+    catch {
+        /* fire-and-forget — select is best-effort */
+    }
     try {
         const db = existingDb ?? openExistingDatabase();
         try {
@@ -219,18 +247,6 @@ function logShowEvent(ref, existingDb) {
         /* fire-and-forget */
     }
 }
-/**
- * Resolve an asset path via the FTS5 index only. Spec §6.2's primary path.
- *
- * Returns `undefined` if the index has no matching row.
- */
-async function resolvePathViaIndex(parsed) {
-    const entry = await lookup(parsed);
-    if (entry) {
-        return { assetPath: entry.filePath };
-    }
-    return undefined;
-}
 /** @internal Use akmShowUnified() for all external callers. */
 export async function showLocal(input) {
     const parsed = parseAssetRef(input.ref);
@@ -251,10 +267,11 @@ export async function showLocal(input) {
         }
     }
     if (!assetPath) {
-        const resolved = await resolvePathViaIndex(parsed);
-        if (resolved?.assetPath) {
-            assetPath = resolved.assetPath;
-        }
+        const resolvedAssetPath = await resolveAssetPath(parsed, {
+            stashDir: input.stashDir,
+            mode: "index-first",
+        });
+        assetPath = resolvedAssetPath ?? undefined;
     }
     if (!assetPath && parsed.origin && searchSources.length === 0) {
         const installCmd = `akm add ${parsed.origin}`;
@@ -293,8 +310,23 @@ export async function showLocal(input) {
         origin: source?.registryId ?? null,
         editable,
         ...(!editable ? { editHint: buildEditHint(assetPath, parsed.type, parsed.name, source?.registryId) } : {}),
+        related: (() => {
+            let db;
+            try {
+                db = openExistingDatabase();
+                const related = listRelatedPathsForFile(sourceStashDir, assetPath, 5, db);
+                return { total: related.length, hits: related };
+            }
+            catch {
+                return { total: 0, hits: [] };
+            }
+            finally {
+                if (db)
+                    closeDatabase(db);
+            }
+        })(),
     };
-    const activeRun = getActiveWorkflowRun(getCurrentWorkflowScopeKey());
+    const activeRun = await getActiveWorkflowRun(getCurrentWorkflowScopeKey());
     if (activeRun) {
         fullResponse.activeRun = activeRun;
     }
@@ -354,7 +386,7 @@ function buildSummaryResponse(full, assetPath) {
         const textContent = full.content ?? full.template ?? full.prompt;
         if (textContent && !description) {
             const parsed = parseFrontmatter(textContent);
-            description = toStringOrUndefined(parsed.data.description);
+            description = asNonEmptyString(parsed.data.description);
         }
     }
     const summary = {
@@ -371,3 +403,76 @@ function buildSummaryResponse(full, assetPath) {
     };
     return summary;
 }
+// ── argv normalisation ───────────────────────────────────────────────────────
+const SHOW_VIEW_MODES = new Set(["toc", "frontmatter", "full", "section", "lines"]);
+/**
+ * Normalize argv so positional view-mode arguments after the asset ref
+ * are rewritten into internal flags that citty can parse.
+ *
+ * Converts:
+ *   akm show knowledge:guide.md toc          → akm show knowledge:guide.md --akmView toc
+ *   akm show knowledge:guide.md section Auth → akm show knowledge:guide.md --akmView section --akmHeading Auth
+ *   akm show knowledge:guide.md lines 1 50   → akm show knowledge:guide.md --akmView lines --akmStart 1 --akmEnd 50
+ *
+ * Legacy `--view` is intentionally unsupported.
+ * Returns a new array; the input is never modified.
+ */
+export function normalizeShowArgv(argv) {
+    // argv[0]=bun argv[1]=script argv[2]=subcommand argv[3]=ref argv[4..]=rest
+    if (argv[2] !== "show")
+        return argv;
+    if (argv[3] === "proposal")
+        return argv;
+    if (argv.includes("--view") || argv.includes("--heading") || argv.includes("--start") || argv.includes("--end")) {
+        throw new UsageError('Legacy show flags are no longer supported. Use positional syntax like `akm show knowledge:guide toc` or `akm show knowledge:guide section "Auth"`.');
+    }
+    // Separate global flags from positional/show-specific args
+    const prefix = argv.slice(0, 3); // [bun, script, show]
+    const rest = argv.slice(3);
+    const globalFlags = [];
+    const showArgs = [];
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        if (arg === "--quiet" || arg === "-q" || arg === "--for-agent" || arg === "--for-agent=true") {
+            globalFlags.push(arg);
+            continue;
+        }
+        if (arg.startsWith("--format=") || arg.startsWith("--detail=")) {
+            globalFlags.push(arg);
+            continue;
+        }
+        if (arg === "--format" || arg === "--detail") {
+            globalFlags.push(arg);
+            if (rest[i + 1] !== undefined) {
+                globalFlags.push(rest[i + 1]);
+                i++;
+            }
+            continue;
+        }
+        showArgs.push(arg);
+    }
+    // showArgs[0] = ref, showArgs[1] = potential view mode, showArgs[2..] = view params
+    const ref = showArgs[0];
+    const viewMode = showArgs[1];
+    if (!ref || !viewMode || !SHOW_VIEW_MODES.has(viewMode)) {
+        return argv;
+    }
+    const result = [...prefix, ref, "--akmView", viewMode];
+    if (viewMode === "section") {
+        // Next arg is the heading name; pass empty string when missing so the
+        // show handler can produce a clear "section not found" error.
+        const heading = showArgs[2] ?? "";
+        result.push("--akmHeading", heading);
+    }
+    else if (viewMode === "lines") {
+        // Next two args are start and end
+        const start = showArgs[2];
+        const end = showArgs[3];
+        if (start)
+            result.push("--akmStart", start);
+        if (end)
+            result.push("--akmEnd", end);
+    }
+    result.push(...globalFlags);
+    return result;
+}

package/dist/commands/source-add.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { isHttpUrl, resolveStashDir } from "../core/common";
-import { loadConfig, loadUserConfig, saveConfig } from "../core/config";
+import { getSources, loadConfig, loadUserConfig, saveConfig } from "../core/config";
 import { ConfigError, UsageError } from "../core/errors";
 import { warn } from "../core/warn";
 import { akmIndex } from "../indexer/indexer";
@@ -74,7 +74,7 @@ async function addLocalSource(ref, sourcePath, stashDir, wikiName, explicitName)
     // Derive the canonical name: explicit --name wins, then wiki name, then readable path.
     const derivedName = explicitName ?? wikiName ?? toReadableId(resolvedPath);
     // Check for duplicates in sources[]
-    const sources = [...(config.sources ?? config.stashes ?? [])];
+    const sources = [...getSources(config)];
     const existing = sources.find((s) => s.type === "filesystem" && s.path && path.resolve(s.path) === resolvedPath);
     let persistedEntry;
     if (!existing) {
@@ -85,7 +85,7 @@ async function addLocalSource(ref, sourcePath, stashDir, wikiName, explicitName)
             ...(wikiName ? { wikiName } : {}),
         };
         sources.push(persistedEntry);
-        saveConfig({ ...config, sources, stashes: undefined });
+        saveConfig({ ...config, sources });
     }
     else {
         let changed = false;
@@ -99,7 +99,7 @@ async function addLocalSource(ref, sourcePath, stashDir, wikiName, explicitName)
             changed = true;
         }
         if (changed)
-            saveConfig({ ...config, sources, stashes: undefined });
+            saveConfig({ ...config, sources });
         persistedEntry = existing;
     }
     const index = await akmIndex({ stashDir });
@@ -116,7 +116,7 @@ async function addLocalSource(ref, sourcePath, stashDir, wikiName, explicitName)
             ...(persistedEntry.wikiName ? { wiki: persistedEntry.wikiName } : {}),
         },
         config: {
-            sourceCount: (updatedConfig.sources ?? updatedConfig.stashes ?? []).length,
+            sourceCount: getSources(updatedConfig).length,
             installedKitCount: updatedConfig.installed?.length ?? 0,
         },
         index: {
@@ -131,7 +131,7 @@ async function addLocalSource(ref, sourcePath, stashDir, wikiName, explicitName)
 async function addWebsiteSource(ref, stashDir, name, options, wikiName) {
     const normalizedUrl = validateWebsiteInputUrl(ref);
     const config = loadUserConfig();
-    const sources = [...(config.sources ?? config.stashes ?? [])];
+    const sources = [...getSources(config)];
     let entry = sources.find((stash) => stash.type === "website" && stash.url === normalizedUrl);
     if (!entry) {
         entry = {
@@ -142,7 +142,7 @@ async function addWebsiteSource(ref, stashDir, name, options, wikiName) {
             ...(wikiName ? { wikiName } : {}),
         };
         sources.push(entry);
-        saveConfig({ ...config, sources, stashes: undefined });
+        saveConfig({ ...config, sources });
     }
     else {
         let changed = false;
@@ -155,7 +155,7 @@ async function addWebsiteSource(ref, stashDir, name, options, wikiName) {
             changed = true;
         }
         if (changed)
-            saveConfig({ ...config, sources, stashes: undefined });
+            saveConfig({ ...config, sources });
     }
     const cachePaths = await ensureWebsiteMirror(entry, { requireStashDir: true });
     const index = await akmIndex({ stashDir });
@@ -172,7 +172,7 @@ async function addWebsiteSource(ref, stashDir, name, options, wikiName) {
             ...(entry.wikiName ? { wiki: entry.wikiName } : {}),
         },
         config: {
-            sourceCount: (updatedConfig.sources ?? updatedConfig.stashes ?? []).length,
+            sourceCount: getSources(updatedConfig).length,
             installedKitCount: updatedConfig.installed?.length ?? 0,
         },
         index: {
@@ -268,7 +268,7 @@ async function addRegistryStash(ref, stashDir, trustThisInstall, writable, wikiN
             audit,
         },
         config: {
-            sourceCount: (updatedConfig.sources ?? updatedConfig.stashes ?? []).length,
+            sourceCount: getSources(updatedConfig).length,
             installedKitCount: updatedConfig.installed?.length ?? 0,
         },
         index: {

package/dist/commands/source-manage.js

@@ -1,5 +1,6 @@
 import path from "node:path";
-import { loadConfig, loadUserConfig, saveConfig } from "../core/config";
+import { isRemoteUrl } from "../core/common";
+import { getSources, loadConfig, loadUserConfig, saveConfig } from "../core/config";
 import { ConfigError, UsageError } from "../core/errors";
 import { resolveSourceEntries } from "../indexer/search-source";
 // ── Operations ──────────────────────────────────────────────────────────────
@@ -19,14 +20,9 @@ export function addStash(opts) {
         throw new ConfigError("writable: true is only supported on filesystem and git sources", "INVALID_CONFIG_FILE");
     }
     const config = loadUserConfig();
-    const sources = [...(config.sources ?? config.stashes ?? [])];
-    const isRemoteUrl = target.startsWith("http://") ||
-        target.startsWith("https://") ||
-        target.startsWith("git@") ||
-        target.startsWith("ssh://") ||
-        target.startsWith("git://");
+    const sources = [...getSources(config)];
     let entry;
-    if (isRemoteUrl) {
+    if (isRemoteUrl(target)) {
         if (!providerType) {
             throw new UsageError("--provider is required for URL sources (e.g. --provider git --provider website)");
         }
@@ -53,7 +49,7 @@ export function addStash(opts) {
             entry.name = name;
     }
     sources.push(entry);
-    saveConfig({ ...config, sources, stashes: undefined });
+    saveConfig({ ...config, sources });
     return { sources, added: true, entry };
 }
 /**
@@ -62,16 +58,12 @@ export function addStash(opts) {
  */
 export function removeStash(target) {
     const config = loadUserConfig();
-    const sources = [...(config.sources ?? config.stashes ?? [])];
-    const isUrl = target.startsWith("http://") ||
-        target.startsWith("https://") ||
-        target.startsWith("git@") ||
-        target.startsWith("ssh://") ||
-        target.startsWith("git://");
-    const resolvedPath = !isUrl ? path.resolve(target) : undefined;
+    const sources = [...getSources(config)];
+    const isUrlTarget = isRemoteUrl(target);
+    const resolvedPath = !isUrlTarget ? path.resolve(target) : undefined;
     // Try URL match first, then path, then name (most specific → least specific)
     let idx = -1;
-    if (isUrl) {
+    if (isUrlTarget) {
         idx = sources.findIndex((s) => s.url === target);
     }
     if (idx === -1 && resolvedPath) {
@@ -84,7 +76,7 @@ export function removeStash(target) {
         return { sources, removed: false, message: "No matching source found" };
     }
     const removed = sources.splice(idx, 1)[0];
-    saveConfig({ ...config, sources, stashes: undefined });
+    saveConfig({ ...config, sources });
     return { sources, removed: true, entry: removed };
 }
 /**
@@ -93,6 +85,6 @@ export function removeStash(target) {
 export function listStashes() {
     const config = loadConfig();
     const localSources = resolveSourceEntries();
-    const sources = config.sources ?? config.stashes ?? [];
+    const sources = getSources(config);
     return { localSources, sources };
 }