akm-cli 0.8.1 → 0.8.2

package/dist/setup/setup.js

@@ -15,7 +15,8 @@ import path from "node:path";
 import * as p from "@clack/prompts";
 import { akmInit } from "../commands/init";
 import { isHttpUrl } from "../core/common";
-import { DEFAULT_CONFIG, getDefaultLlmConfig, loadUserConfig, saveConfig } from "../core/config";
+import { DEFAULT_CONFIG, getDefaultLlmConfig, getEffectiveRegistries, loadUserConfig, saveConfig, } from "../core/config";
+import { backupExistingConfig } from "../core/config-io";
 import { ConfigError } from "../core/errors";
 import { assertSafeStashDir, getConfigPath, getDefaultStashDir, isTransientStashPath } from "../core/paths";
 import { warn } from "../core/warn";
@@ -25,7 +26,9 @@ import { clearSemanticStatus, deriveSemanticProviderFingerprint, writeSemanticSt
 import { detectAgentCliProfiles, pickDefaultAgentProfile } from "../integrations/agent";
 import { probeLlmCapabilities } from "../llm/client";
 import { checkEmbeddingAvailability, DEFAULT_LOCAL_MODEL, isTransformersAvailable } from "../llm/embedder";
-import { detectAgentPlatforms, detectOllama } from "./detect";
+import { detectAgentPlatforms, detectLMStudio, detectOllama } from "./detect";
+import { detectHarnessConfigs } from "./harness-config-import";
+import { loadSetupStashes } from "./registry-stash-loader";
 import { createSetupContext, runSetupSteps } from "./steps";
 // ── Setup sandbox guard ─────────────────────────────────────────────────────
 /**
@@ -149,22 +152,7 @@ function applyLegacyAgent(config, agent) {
         defaults: { ...(config.defaults ?? {}), agent: agent.default },
     };
 }
-/**
- * Recommended GitHub repositories shown during setup.
- */
-const RECOMMENDED_GITHUB_REPOS = [
-    {
-        url: "https://github.com/itlackey/akm-stash",
-        name: "itlackey/akm-stash",
-        hint: "official onboarding stash",
-        defaultSelected: true,
-    },
-    {
-        url: "https://github.com/andrewyng/context-hub",
-        name: "andrewyng/context-hub",
-        hint: "optional community prompt and context stash",
-    },
-];
+// ── Constants ───────────────────────────────────────────────────────────────
 // Approximate first-download sizes used in the setup note.
 // LOCAL_MODEL_APPROX_SIZE_MB tracks the default local model (DEFAULT_LOCAL_MODEL).
 const LOCAL_MODEL_APPROX_SIZE_MB = 130;
@@ -622,12 +610,21 @@ const LLM_PRESETS = [
  *
  * @internal Exported for testing only.
  */
-export async function stepLlm(current, ollamaEndpoint, ollamaChatModels) {
-    const options = LLM_PRESETS.map((preset) => ({
-        value: preset.value,
-        label: preset.label,
-        hint: preset.hint,
+export async function stepLlm(current, ollamaEndpoint, ollamaChatModels, lmStudio, harnessConfigs) {
+    // Build "Import from <Harness>" options and prepend them before LLM_PRESETS
+    const harnessOptions = (harnessConfigs ?? []).map((h) => ({
+        value: `harness:${h.harnessName}`,
+        label: `Import from ${h.harnessName}`,
+        hint: [h.provider, h.model].filter(Boolean).join(" / ") || "detected",
     }));
+    const options = [
+        ...harnessOptions,
+        ...LLM_PRESETS.map((preset) => ({
+            value: preset.value,
+            label: preset.label,
+            hint: preset.hint,
+        })),
+    ];
     const ollamaAvailable = Boolean(ollamaEndpoint && ollamaChatModels && ollamaChatModels.length > 0);
     if (ollamaAvailable) {
         options.push({
@@ -636,6 +633,10 @@ export async function stepLlm(current, ollamaEndpoint, ollamaChatModels) {
             hint: ollamaChatModels?.[0] ?? "local",
         });
     }
+    const lmStudioHint = lmStudio?.available
+        ? `${lmStudio.models.length} model${lmStudio.models.length === 1 ? "" : "s"} detected`
+        : "http://localhost:1234";
+    options.push({ value: "lmstudio", label: "LM Studio / local server", hint: lmStudioHint });
     options.push({ value: "custom", label: "Custom OpenAI-compatible endpoint" });
     options.push({ value: "none", label: "Skip LLM", hint: "no metadata enhancement during indexing" });
     const currentLlm = getCurrentLlm(current);
@@ -656,6 +657,26 @@ export async function stepLlm(current, ollamaEndpoint, ollamaChatModels) {
         return cloneLlmConfig(currentLlm);
     if (choice === "none")
         return undefined;
+    // Handle "Import from <Harness>" choices
+    if (typeof choice === "string" && choice.startsWith("harness:")) {
+        const harness = (harnessConfigs ?? []).find((h) => `harness:${h.harnessName}` === choice);
+        if (!harness)
+            return undefined;
+        // Show a summary before accepting
+        p.log.info(`Importing LLM config from ${harness.harnessName}: ` +
+            [harness.provider, harness.model, harness.baseUrl].filter(Boolean).join(", "));
+        const llmConfig = {
+            endpoint: harness.baseUrl ?? "",
+            model: harness.model ?? "",
+            temperature: 0.3,
+            maxTokens: 1024,
+        };
+        if (harness.provider)
+            llmConfig.provider = harness.provider;
+        if (harness.baseUrl)
+            llmConfig.endpoint = harness.baseUrl;
+        return llmConfig;
+    }
     let llm;
     if (choice === "ollama") {
         const modelChoice = await prompt(() => p.select({
@@ -671,10 +692,66 @@ export async function stepLlm(current, ollamaEndpoint, ollamaChatModels) {
             maxTokens: 1024,
         };
     }
+    else if (choice === "lmstudio") {
+        const currentLmsLlm = currentLlm?.provider === "lmstudio" ? currentLlm : undefined;
+        const defaultEndpoint = currentLmsLlm?.endpoint ??
+            (lmStudio?.endpoint ? `${lmStudio.endpoint}/v1/chat/completions` : "http://localhost:1234/v1/chat/completions");
+        const endpoint = await prompt(() => p.text({
+            message: "Endpoint URL:",
+            placeholder: defaultEndpoint,
+            defaultValue: defaultEndpoint,
+            validate: (v) => {
+                if (!v?.trim())
+                    return "Endpoint cannot be empty";
+                if (!v.startsWith("http://") && !v.startsWith("https://"))
+                    return "Must start with http:// or https://";
+            },
+        }));
+        let model;
+        const lmsModels = lmStudio?.available && lmStudio.models.length > 0 ? lmStudio.models : [];
+        if (lmsModels.length > 0) {
+            const modelChoice = await prompt(() => p.select({
+                message: "Model name:",
+                options: [
+                    ...lmsModels.map((m) => ({ value: m, label: m })),
+                    { value: "__manual__", label: "Enter manually..." },
+                ],
+                initialValue: currentLmsLlm?.model && lmsModels.includes(currentLmsLlm.model) ? currentLmsLlm.model : lmsModels[0],
+            }));
+            if (modelChoice === "__manual__") {
+                model = await prompt(() => p.text({
+                    message: "Model name:",
+                    placeholder: currentLmsLlm?.model ?? "local-model",
+                    ...(currentLmsLlm?.model ? { defaultValue: currentLmsLlm.model } : {}),
+                    validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+                }));
+            }
+            else {
+                model = modelChoice;
+            }
+        }
+        else {
+            model = await prompt(() => p.text({
+                message: "Model name:",
+                placeholder: currentLmsLlm?.model ?? "local-model",
+                ...(currentLmsLlm?.model ? { defaultValue: currentLmsLlm.model } : {}),
+                validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+            }));
+        }
+        llm = {
+            provider: "lmstudio",
+            endpoint: endpoint.trim(),
+            model: model.trim(),
+            temperature: 0.3,
+            maxTokens: 1024,
+        };
+    }
     else if (choice === "custom") {
+        const currentCustomLlm = currentLlm?.provider === "custom" ? currentLlm : undefined;
         const endpoint = await prompt(() => p.text({
             message: "OpenAI-compatible chat completions endpoint:",
-            placeholder: "https://your-host/v1/chat/completions",
+            placeholder: currentCustomLlm?.endpoint ?? "https://your-host/v1/chat/completions",
+            ...(currentCustomLlm?.endpoint ? { defaultValue: currentCustomLlm.endpoint } : {}),
             validate: (v) => {
                 if (!v?.trim())
                     return "Endpoint cannot be empty";
@@ -684,7 +761,8 @@ export async function stepLlm(current, ollamaEndpoint, ollamaChatModels) {
         }));
         const model = await prompt(() => p.text({
             message: "Model name:",
-            placeholder: "gpt-4o-mini",
+            placeholder: currentCustomLlm?.model ?? "gpt-4o-mini",
+            ...(currentCustomLlm?.model ? { defaultValue: currentCustomLlm.model } : {}),
             validate: (v) => {
                 if (!v?.trim())
                     return "Model name cannot be empty";
@@ -806,41 +884,47 @@ export async function stepAddSources(current, options) {
     if ((current.installed?.length ?? 0) > 0) {
         p.note(renderInstalledSourceList(current.installed ?? []), "Installed managed stashes (preserved)");
     }
-    // ── Recommended GitHub repos ───────────────────────────────────────────
-    // Skip the prompt entirely when there are no recommendations to show.
-    // The infrastructure is retained for a future registry-driven version.
-    if (RECOMMENDED_GITHUB_REPOS.length > 0) {
+    // ── Registry-driven stash recommendations ─────────────────────────────
+    // Fetch available stashes from the official registry (cached, stale-ok).
+    // Falls back to the bundled list when the registry is unreachable.
+    const registryUrl = getEffectiveRegistries(current)[0]?.url ??
+        "https://raw.githubusercontent.com/itlackey/akm-registry/main/index.json";
+    const availableStashes = await loadSetupStashes(registryUrl);
+    if (availableStashes.length > 0) {
         const existingUrls = new Set(sources.map((s) => s.url));
-        const repoOptions = RECOMMENDED_GITHUB_REPOS.map((r) => ({
-            value: r.url,
-            label: r.name,
-            hint: existingUrls.has(r.url) ? `${r.hint} (already added)` : r.hint,
+        const stashOptions = availableStashes.map((s) => ({
+            value: s.url,
+            label: s.name,
+            hint: existingUrls.has(s.url) ? `${s.description} (already added)` : s.description || s.source,
         }));
+        // Pre-check: already-installed stashes OR default-selected on fresh install
         const initialValues = sources.length > 0
-            ? repoOptions.filter((o) => existingUrls.has(o.value)).map((o) => o.value)
-            : RECOMMENDED_GITHUB_REPOS.filter((r) => r.defaultSelected).map((r) => r.url);
-        const selectedRepos = await prompt(() => p.multiselect({
-            message: "Recommended GitHub repositories — toggle to add or remove:",
-            options: repoOptions,
+            ? stashOptions.filter((o) => existingUrls.has(o.value)).map((o) => o.value)
+            : availableStashes.filter((s) => s.defaultSelected).map((s) => s.url);
+        const selectedUrls = await prompt(() => p.multiselect({
+            message: availableStashes[0]?.source === "registry"
+                ? "Available stashes from the AKM registry — toggle to add or remove:"
+                : "Recommended stash sources — toggle to add or remove:",
+            options: stashOptions,
             initialValues,
             required: false,
         }));
-        // Add newly selected repos
-        for (const url of selectedRepos) {
+        // Add newly selected stashes
+        for (const url of selectedUrls) {
             if (!existingUrls.has(url)) {
-                const rec = RECOMMENDED_GITHUB_REPOS.find((r) => r.url === url);
-                sources.push({ type: "git", url, name: rec?.name });
+                const entry = availableStashes.find((s) => s.url === url);
+                sources.push({ type: "git", url, name: entry?.name });
                 existingUrls.add(url);
             }
         }
-        // Remove deselected repos that were previously configured
-        for (const rec of RECOMMENDED_GITHUB_REPOS) {
-            if (existingUrls.has(rec.url) && !selectedRepos.includes(rec.url)) {
-                const idx = sources.findIndex((s) => s.url === rec.url);
+        // Remove deselected stashes that were previously configured
+        for (const entry of availableStashes) {
+            if (existingUrls.has(entry.url) && !selectedUrls.includes(entry.url)) {
+                const idx = sources.findIndex((s) => s.url === entry.url);
                 if (idx !== -1) {
                     sources.splice(idx, 1);
-                    existingUrls.delete(rec.url);
-                    p.log.info(`Removed ${rec.name}.`);
+                    existingUrls.delete(entry.url);
+                    p.log.info(`Removed ${entry.name}.`);
                 }
             }
         }
@@ -900,11 +984,17 @@ export async function stepSmallModelConnection(current) {
         "  • akm remember --enrich (memory compression)",
         "  • akm curate --rerank   (search reranking)",
     ].join("\n"));
-    // Probe for Ollama in the background while showing the note.
+    // Probe for Ollama and LM Studio in the background while showing the note.
     const spin = p.spinner();
     spin.start("Detecting local services...");
-    const ollama = await detectOllama();
-    spin.stop(ollama.available ? `Ollama detected at ${ollama.endpoint}` : "No local services detected");
+    const [ollama, lmStudio] = await Promise.all([detectOllama(), detectLMStudio()]);
+    const detectedServices = [
+        ollama.available ? `Ollama at ${ollama.endpoint}` : null,
+        lmStudio.available ? `LM Studio at ${lmStudio.endpoint}` : null,
+    ]
+        .filter(Boolean)
+        .join(", ");
+    spin.stop(detectedServices ? `Detected: ${detectedServices}` : "No local services detected");
     const ollamaEndpoint = ollama.available ? ollama.endpoint : undefined;
     const providerOptions = [];
     if (ollama.available) {
@@ -914,7 +1004,10 @@ export async function stepSmallModelConnection(current) {
             hint: `detected at ${ollama.endpoint}`,
         });
     }
-    providerOptions.push({ value: "openai", label: "OpenAI", hint: "requires AKM_LLM_API_KEY" }, { value: "lmstudio", label: "LM Studio / local server", hint: "http://localhost:1234" }, { value: "custom", label: "Custom OpenAI-compatible endpoint" }, { value: "skip", label: "Skip — disable enrichment features" });
+    const lmStudioHint = lmStudio.available
+        ? `${lmStudio.models.length} model${lmStudio.models.length === 1 ? "" : "s"} detected`
+        : "http://localhost:1234";
+    providerOptions.push({ value: "openai", label: "OpenAI", hint: "requires AKM_LLM_API_KEY" }, { value: "lmstudio", label: "LM Studio / local server", hint: lmStudioHint }, { value: "custom", label: "Custom OpenAI-compatible endpoint" }, { value: "skip", label: "Skip — disable enrichment features" });
     const currentLlmSmall = getCurrentLlm(current);
     if (currentLlmSmall) {
         providerOptions.push({
@@ -966,10 +1059,11 @@ export async function stepSmallModelConnection(current) {
             }
         }
         else {
+            const currentOllamaModel = currentLlmSmall?.provider === "ollama" ? (currentLlmSmall.model ?? "llama3.2") : "llama3.2";
             model = await prompt(() => p.text({
                 message: "Model name (e.g. llama3.2):",
-                placeholder: "llama3.2",
-                defaultValue: "llama3.2",
+                placeholder: currentOllamaModel,
+                defaultValue: currentOllamaModel,
                 validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
             }));
         }
@@ -982,10 +1076,11 @@ export async function stepSmallModelConnection(current) {
         };
     }
     else if (providerChoice === "openai") {
+        const currentOpenAiModel = currentLlmSmall?.provider === "openai" ? (currentLlmSmall.model ?? "gpt-4o-mini") : "gpt-4o-mini";
         const model = await prompt(() => p.text({
             message: "Model name:",
-            placeholder: "gpt-4o-mini",
-            defaultValue: "gpt-4o-mini",
+            placeholder: currentOpenAiModel,
+            defaultValue: currentOpenAiModel,
             validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
         }));
         if (!process.env.AKM_LLM_API_KEY) {
@@ -994,16 +1089,20 @@ export async function stepSmallModelConnection(current) {
         llm = {
             provider: "openai",
             endpoint: "https://api.openai.com/v1/chat/completions",
-            model: model.trim() || "gpt-4o-mini",
+            model: model.trim() || currentOpenAiModel,
             temperature: 0.3,
             maxTokens: 1024,
         };
     }
     else if (providerChoice === "lmstudio") {
+        const currentLmsEndpoint = currentLlmSmall?.provider === "lmstudio"
+            ? (currentLlmSmall.endpoint ?? `${lmStudio.endpoint}/v1/chat/completions`)
+            : `${lmStudio.endpoint}/v1/chat/completions`;
+        const currentLmsModel = currentLlmSmall?.provider === "lmstudio" ? currentLlmSmall.model : undefined;
         const endpoint = await prompt(() => p.text({
             message: "Endpoint URL:",
-            placeholder: "http://localhost:1234/v1/chat/completions",
-            defaultValue: "http://localhost:1234/v1/chat/completions",
+            placeholder: currentLmsEndpoint,
+            defaultValue: currentLmsEndpoint,
             validate: (v) => {
                 if (!v?.trim())
                     return "Endpoint cannot be empty";
@@ -1011,11 +1110,37 @@ export async function stepSmallModelConnection(current) {
                     return "Must start with http:// or https://";
             },
         }));
-        const model = await prompt(() => p.text({
-            message: "Model name:",
-            placeholder: "local-model",
-            validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
-        }));
+        let model;
+        const lmsModels = lmStudio.available && lmStudio.models.length > 0 ? lmStudio.models : [];
+        if (lmsModels.length > 0) {
+            const modelChoice = await prompt(() => p.select({
+                message: "Model name:",
+                options: [
+                    ...lmsModels.map((m) => ({ value: m, label: m })),
+                    { value: "__manual__", label: "Enter manually..." },
+                ],
+                initialValue: currentLmsModel && lmsModels.includes(currentLmsModel) ? currentLmsModel : lmsModels[0],
+            }));
+            if (modelChoice === "__manual__") {
+                model = await prompt(() => p.text({
+                    message: "Model name:",
+                    placeholder: currentLmsModel ?? "local-model",
+                    ...(currentLmsModel ? { defaultValue: currentLmsModel } : {}),
+                    validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+                }));
+            }
+            else {
+                model = modelChoice;
+            }
+        }
+        else {
+            model = await prompt(() => p.text({
+                message: "Model name:",
+                placeholder: currentLmsModel ?? "local-model",
+                ...(currentLmsModel ? { defaultValue: currentLmsModel } : {}),
+                validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+            }));
+        }
         llm = {
             provider: "lmstudio",
             endpoint: endpoint.trim(),
@@ -1026,9 +1151,12 @@ export async function stepSmallModelConnection(current) {
     }
     else {
         // custom
+        const currentCustomEndpoint = currentLlmSmall?.provider === "custom" ? currentLlmSmall.endpoint : undefined;
+        const currentCustomModel = currentLlmSmall?.provider === "custom" ? currentLlmSmall.model : undefined;
         const endpoint = await prompt(() => p.text({
             message: "OpenAI-compatible chat completions endpoint:",
-            placeholder: "https://your-host/v1/chat/completions",
+            placeholder: currentCustomEndpoint ?? "https://your-host/v1/chat/completions",
+            ...(currentCustomEndpoint ? { defaultValue: currentCustomEndpoint } : {}),
             validate: (v) => {
                 if (!v?.trim())
                     return "Endpoint cannot be empty";
@@ -1038,7 +1166,8 @@ export async function stepSmallModelConnection(current) {
         }));
         const model = await prompt(() => p.text({
             message: "Model name:",
-            placeholder: "gpt-4o-mini",
+            placeholder: currentCustomModel ?? "gpt-4o-mini",
+            ...(currentCustomModel ? { defaultValue: currentCustomModel } : {}),
             validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
         }));
         const apiKeyInput = await promptOrBack(() => p.text({
@@ -1150,12 +1279,15 @@ export async function stepAgentConnection(current, smallModel) {
         else {
             const baseEndpoint = smallModel.llm.endpoint.replace("/v1/chat/completions", "");
             p.log.info(`Endpoint: ${baseEndpoint} (from Step 1)`);
+            const profileName = smallModel.llm.provider ?? "default";
+            // Pre-populate from existing agent profile for this provider, if any.
+            const existingAgentModel = currentAgentBlock?.profiles?.[profileName]?.model ?? smallModel.llm.model ?? undefined;
             const agentModel = await prompt(() => p.text({
                 message: "Model to use for agent tasks (same model is fine, larger models work better):",
-                placeholder: "qwen2.5-coder:32b",
+                placeholder: existingAgentModel ?? "qwen2.5-coder:32b",
+                ...(existingAgentModel ? { defaultValue: existingAgentModel } : {}),
                 validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
             }));
-            const profileName = smallModel.llm.provider ?? "default";
             return {
                 ...(currentAgentBlock ?? {}),
                 profiles: {
@@ -1192,9 +1324,14 @@ export async function stepAgentConnection(current, smallModel) {
         };
     }
     // "new-connection" (also fall-through from "same-provider" when Step 1 was skipped)
+    // Pre-populate from current "custom" agent profile if available.
+    const currentCustomAgentProfile = currentAgentBlock?.profiles?.custom;
+    const currentNewEndpoint = currentCustomAgentProfile?.endpoint ?? undefined;
+    const currentNewModel = currentCustomAgentProfile?.model ?? undefined;
     const newEndpoint = await prompt(() => p.text({
         message: "OpenAI-compatible chat completions endpoint:",
-        placeholder: "https://your-host/v1/chat/completions",
+        placeholder: currentNewEndpoint ?? "https://your-host/v1/chat/completions",
+        ...(currentNewEndpoint ? { defaultValue: currentNewEndpoint } : {}),
         validate: (v) => {
             if (!v?.trim())
                 return "Endpoint cannot be empty";
@@ -1208,7 +1345,8 @@ export async function stepAgentConnection(current, smallModel) {
     }));
     const newModel = await prompt(() => p.text({
         message: "Model name (larger is better, e.g. gpt-4o):",
-        placeholder: "gpt-4o",
+        placeholder: currentNewModel ?? "gpt-4o",
+        ...(currentNewModel ? { defaultValue: currentNewModel } : {}),
         validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
     }));
     const customProfile = {
@@ -1340,6 +1478,9 @@ export function buildSetupSteps(options) {
     // to the LLM step. Mutable by design — `stepLlm` needs them.
     let ollamaEndpoint;
     let ollamaChatModels;
+    let lmStudioResult;
+    // Harness configs detected once and shared with the LLM step.
+    const harnessConfigs = detectHarnessConfigs();
     const steps = [
         {
             id: "stash-dir",
@@ -1361,9 +1502,10 @@ export function buildSetupSteps(options) {
                     ctx.apply({ embedding: ctx.config.embedding });
                     return;
                 }
-                const result = await stepOllama(ctx.config);
+                const [result, lmStudio] = await Promise.all([stepOllama(ctx.config), detectLMStudio()]);
                 ollamaEndpoint = result.ollamaEndpoint;
                 ollamaChatModels = result.ollamaChatModels;
+                lmStudioResult = lmStudio;
                 ctx.apply({ embedding: result.embedding });
             },
         },
@@ -1374,7 +1516,7 @@ export function buildSetupSteps(options) {
                 if (!options.online) {
                     return;
                 }
-                const llm = await stepLlm(ctx.config, ollamaEndpoint, ollamaChatModels);
+                const llm = await stepLlm(ctx.config, ollamaEndpoint, ollamaChatModels, lmStudioResult, harnessConfigs);
                 ctx.apply(applyLegacyLlm(ctx.config, llm));
             },
         },
@@ -1521,6 +1663,11 @@ export async function runSetupWizard(opts) {
     if (!shouldSave)
         bail();
     // Save config
+    const cfgPath1 = getConfigPath();
+    if (fs.existsSync(cfgPath1)) {
+        backupExistingConfig(cfgPath1);
+        p.log.info(`Config backed up to ~/.cache/akm/config-backups/`);
+    }
     saveConfig(newConfig);
     if (semanticSearchMode.mode === "off") {
         clearSemanticStatus();
@@ -1637,6 +1784,11 @@ export async function runSetupWithDefaults(opts) {
             ctx.apply(applyLegacyAgent(ctx.config, { default: defaultProfile }));
         }
     }
+    const cfgPath2 = getConfigPath();
+    if (fs.existsSync(cfgPath2)) {
+        backupExistingConfig(cfgPath2);
+        p.log.info(`Config backed up to ~/.cache/akm/config-backups/`);
+    }
     saveConfig(ctx.config);
     return {
         configPath: getConfigPath(),
@@ -1738,6 +1890,11 @@ export async function runSetupFromConfig(opts) {
             // Non-fatal: probe failure is informational only
         }
     }
+    const cfgPath3 = getConfigPath();
+    if (fs.existsSync(cfgPath3)) {
+        backupExistingConfig(cfgPath3);
+        p.log.info(`Config backed up to ~/.cache/akm/config-backups/`);
+    }
     saveConfig(merged);
     return {
         configPath: getConfigPath(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "type": "module",
   "description": "akm (Agent Knowledge Management) — A package manager for AI agent skills, commands, tools, and knowledge. Works with Claude Code, OpenCode, Cursor, and any AI coding assistant.",
   "keywords": [