akm-cli 0.8.1 → 0.9.0-beta.0

package/dist/setup/setup.js

@@ -13,20 +13,31 @@ import fs from "node:fs";
 import os from "node:os";
 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 { ConfigError } from "../core/errors";
-import { assertSafeStashDir, getConfigPath, getDefaultStashDir, isTransientStashPath } from "../core/paths";
-import { warn } from "../core/warn";
-import { closeDatabase, isVecAvailable, openDatabase } from "../indexer/db";
-import { akmIndex } from "../indexer/indexer";
-import { clearSemanticStatus, deriveSemanticProviderFingerprint, writeSemanticStatus, } from "../indexer/semantic-status";
-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 { createSetupContext, runSetupSteps } from "./steps";
+import { akmInit } from "../commands/sources/init.js";
+import { detectServerDefault, isCiEnvironment, registerDefaultTasks } from "../commands/tasks/default-tasks.js";
+import { akmTasksAdd, akmTasksList, akmTasksSetEnabled, akmTasksSync } from "../commands/tasks/tasks.js";
+import { isHttpUrl } from "../core/common.js";
+import { DEFAULT_CONFIG, getDefaultLlmConfig, getEffectiveRegistries, loadUserConfig, saveConfig, } from "../core/config/config.js";
+import { backupExistingConfig } from "../core/config/config-io.js";
+import { ConfigError, UsageError } from "../core/errors.js";
+import { assertSafeStashDir, getConfigPath, getDefaultStashDir, isTransientStashPath } from "../core/paths.js";
+import { warn } from "../core/warn.js";
+import { closeDatabase, isVecAvailable, openDatabase } from "../indexer/db/db.js";
+import { akmIndex } from "../indexer/indexer.js";
+import { clearSemanticStatus, deriveSemanticProviderFingerprint, writeSemanticStatus, } from "../indexer/search/semantic-status.js";
+import { detectAgentCliProfiles, pickDefaultAgentProfile } from "../integrations/agent/index.js";
+import { defaultProfileName, v1ProfilePlatform } from "../integrations/harnesses/index.js";
+import { probeLlmCapabilities } from "../llm/client.js";
+import { checkEmbeddingAvailability, DEFAULT_LOCAL_MODEL, isTransformersAvailable } from "../llm/embedder.js";
+import { getDirname, spawn } from "../runtime.js";
+import { saveGitStash } from "../sources/providers/git.js";
+import { backendNameForPlatform } from "../tasks/backends/index.js";
+import { listEmbeddedTasks } from "../tasks/embedded.js";
+import { parseSchedule } from "../tasks/schedule.js";
+import { detectAgentPlatforms, detectEnvironment, detectLMStudio, detectOllama, renderDetectionSummary, } from "./detect.js";
+import { detectHarnessConfigs } from "./harness-config-import.js";
+import { loadSetupStashes } from "./registry-stash-loader.js";
+import { createSetupContext, runSetupSteps } from "./steps.js";
 // ── Setup sandbox guard ─────────────────────────────────────────────────────
 /**
  * Refuse to persist an explicit `--dir /tmp/...` stashDir to the user's
@@ -132,11 +143,28 @@ function applyLegacyAgent(config, agent) {
     }
     const v2Profiles = { ...(config.profiles?.agent ?? {}) };
     for (const [name, profile] of Object.entries(agent.profiles ?? {})) {
-        const platform = profile.sdkMode
-            ? "opencode-sdk"
-            : name.toLowerCase().includes("claude")
-                ? "claude"
-                : "opencode";
+        // #566: resolve the platform via the harness registry instead of the old
+        // `name.includes("claude") ? "claude" : "opencode"` heuristic, which
+        // silently mapped Cursor/Copilot/any new harness to "opencode". An explicit
+        // sdkMode flag still wins; otherwise we ask the registry. A name the
+        // registry does not recognize is surfaced (warn) rather than silently
+        // misclassified, then kept as a best-effort "opencode" profile so the user
+        // does not lose a profile they explicitly configured.
+        let platform;
+        if (profile.sdkMode) {
+            platform = "opencode-sdk";
+        }
+        else {
+            const resolved = v1ProfilePlatform(name);
+            if (resolved) {
+                platform = resolved;
+            }
+            else {
+                warn(`[akm setup] Agent profile "${name}" did not match any known harness; ` +
+                    `defaulting its platform to "opencode". Set its platform explicitly in config if this is wrong.`);
+                platform = "opencode";
+            }
+        }
         v2Profiles[name] = {
             platform,
             ...(profile.bin ? { bin: profile.bin } : {}),
@@ -149,22 +177,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;
@@ -398,8 +411,8 @@ async function prepareSemanticSearchAssets(config) {
             const spin = p.spinner();
             spin.start("Installing @huggingface/transformers...");
             try {
-                const pkgRoot = path.resolve(import.meta.dir, "../..");
-                const proc = Bun.spawn(["bun", "add", "@huggingface/transformers"], {
+                const pkgRoot = path.resolve(getDirname(import.meta.url), "../..");
+                const proc = spawn(["bun", "add", "@huggingface/transformers"], {
                     cwd: pkgRoot,
                     stdout: "pipe",
                     stderr: "pipe",
@@ -622,12 +635,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 +658,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 +682,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 +717,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 +786,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 +909,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 +1009,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 +1029,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 +1084,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 +1101,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 +1114,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 +1135,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 +1176,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 +1191,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 +1304,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 +1349,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 +1370,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 = {
@@ -1326,6 +1489,165 @@ export function stepAgentCliDetection(current, detectFn = detectAgentCliProfiles
     return { agent, detections };
 }
 // ── Main Wizard ─────────────────────────────────────────────────────────────
+/**
+ * Normalise a task id the same way `akm tasks` does (strip a trailing `.yml`
+ * / `.md` suffix, trim) so the wizard can match embedded template ids against
+ * the ids reported by `akmTasksList()`.
+ */
+function normaliseTaskIdForMatch(raw) {
+    return raw.trim().replace(/\.(yml|md)$/, "");
+}
+/**
+ * Interactive-only setup step: enable/disable embedded core tasks.
+ *
+ * Presents a multi-select of the bundled core task templates pre-checked
+ * against the user's currently-enabled tasks. On confirm:
+ *   - newly-checked & absent  → copy template (with edited schedule) into the
+ *     primary stash via `akmTasksAdd`, then `akmTasksSync`, then `akm sync`
+ *     (a no-op for non-git stashes).
+ *   - newly-checked & present-but-disabled → `akmTasksSetEnabled(id, true)`.
+ *   - previously-enabled & now unchecked    → `akmTasksSetEnabled(id, false)`
+ *     (keeps the stash file, removes the scheduler entry).
+ *   - unchanged → no action.
+ *
+ * Exported for testing. Not registered as `nonInteractive`, so `akm init` /
+ * `--yes` never reach it.
+ *
+ * The task primitives + git-sync helper are injected via `deps` (defaulting
+ * to the real implementations) so tests can supply fakes without
+ * `mock.module`-ing the shared `commands/tasks` / `sources/providers/git`
+ * modules — which would leak into unrelated test files (Bun's `mock.module`
+ * is process-global and not reverted by `mock.restore()`).
+ */
+/**
+ * Setup sub-step (issue #552): idempotently register the default improve task
+ * set. Asks a single "Is this a server install?" question (defaulting per
+ * platform) to decide whether the nightly sweep is enabled, then delegates to
+ * {@link registerDefaultTasks}, which is CI-aware and never duplicates an
+ * existing task. Skipped entirely under CI (the registration helper short-
+ * circuits, and we never even prompt).
+ *
+ * Exported for testing.
+ */
+export async function stepDefaultImproveTasks(register = registerDefaultTasks) {
+    // CI: register nothing and don't prompt.
+    if (isCiEnvironment()) {
+        p.log.info("CI detected — skipping default improve task registration.");
+        return;
+    }
+    const platformDefault = detectServerDefault();
+    const serverInstall = await prompt(() => p.confirm({
+        message: "Is this a server install? (enables the nightly quality sweep at 2am)",
+        initialValue: platformDefault,
+    }));
+    const result = await register({ serverInstall: serverInstall === true });
+    if (result.skipped)
+        return;
+    const total = result.created.length + result.existing.length;
+    p.log.success(`Default improve tasks registered (${result.created.length} new, ${result.existing.length} already present, ${total} total).`);
+}
+const DEFAULT_SCHEDULED_TASKS_DEPS = {
+    list: akmTasksList,
+    add: akmTasksAdd,
+    setEnabled: akmTasksSetEnabled,
+    sync: akmTasksSync,
+    gitSync: saveGitStash,
+};
+export async function stepScheduledTasks(deps = DEFAULT_SCHEDULED_TASKS_DEPS) {
+    const embedded = listEmbeddedTasks();
+    if (embedded.length === 0)
+        return;
+    // Snapshot current state so we can diff against the user's selection.
+    let installed = [];
+    try {
+        installed = (await deps.list()).tasks;
+    }
+    catch {
+        // A missing/empty tasks dir is fine — treat as nothing installed.
+        installed = [];
+    }
+    const byId = new Map();
+    for (const t of installed)
+        byId.set(normaliseTaskIdForMatch(t.id), t);
+    // Pre-check tasks that are installed AND enabled.
+    const preChecked = embedded.filter((e) => byId.get(e.id)?.enabled === true).map((e) => e.id);
+    const stateLabel = (e) => {
+        const cur = byId.get(e.id);
+        if (!cur)
+            return "not installed";
+        return cur.enabled ? "enabled" : "disabled";
+    };
+    const selected = await prompt(() => p.multiselect({
+        message: "Enable scheduled core tasks? (space to toggle, enter to confirm)",
+        required: false,
+        initialValues: preChecked,
+        options: embedded.map((e) => ({
+            value: e.id,
+            label: e.label,
+            hint: `${e.description} — ${e.schedule} [${stateLabel(e)}]`,
+        })),
+    }));
+    const selectedSet = new Set(selected);
+    // Resolve per-task schedule edits for newly-checked, not-yet-installed tasks.
+    const scheduleFor = new Map();
+    for (const e of embedded) {
+        const cur = byId.get(e.id);
+        if (selectedSet.has(e.id) && !cur) {
+            const edited = await prompt(() => p.text({
+                message: `Schedule for ${e.label}?`,
+                initialValue: e.schedule,
+                validate(value) {
+                    const candidate = (value ?? "").trim() || e.schedule;
+                    try {
+                        parseSchedule(candidate, backendNameForPlatform());
+                    }
+                    catch (err) {
+                        return err instanceof Error ? err.message : "Invalid schedule.";
+                    }
+                    return undefined;
+                },
+            }));
+            const sched = (edited ?? "").trim() || e.schedule;
+            scheduleFor.set(e.id, sched);
+        }
+    }
+    let syncNeeded = false;
+    for (const e of embedded) {
+        const cur = byId.get(e.id);
+        const checked = selectedSet.has(e.id);
+        if (checked && !cur) {
+            // New task: copy template into the primary stash + install scheduler entry.
+            const schedule = scheduleFor.get(e.id) ?? e.schedule;
+            await deps.add({
+                id: e.id,
+                schedule,
+                command: e.command,
+                description: e.description,
+            });
+            syncNeeded = true;
+        }
+        else if (checked && cur && !cur.enabled) {
+            // Present but disabled → re-enable.
+            await deps.setEnabled(e.id, true);
+        }
+        else if (!checked && cur?.enabled) {
+            // Previously enabled, now unchecked → disable (keep the stash file).
+            await deps.setEnabled(e.id, false);
+        }
+        // No state change → no action.
+    }
+    if (syncNeeded) {
+        // Reconcile scheduler entries with on-disk YAML, then commit the new file
+        // to git (a no-op for non-git stashes).
+        await deps.sync();
+        try {
+            deps.gitSync(undefined, "akm setup: enable scheduled tasks");
+        }
+        catch {
+            // Non-fatal — the task is installed regardless of git sync outcome.
+        }
+    }
+}
 /**
  * Build the canonical list of `SetupStep`s for the interactive wizard.
  * Exposed (and exported) so tests and `akm init` can compose subsets.
@@ -1340,6 +1662,10 @@ 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. Reuse the
+    // aggregate detection's harness configs when available so we detect once.
+    const harnessConfigs = options.detection?.harnessConfigs ?? detectHarnessConfigs();
     const steps = [
         {
             id: "stash-dir",
@@ -1361,9 +1687,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 +1701,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));
             },
         },
@@ -1438,6 +1765,16 @@ export function buildSetupSteps(options) {
                 ctx.apply({ output });
             },
         },
+        {
+            id: "scheduled-tasks",
+            label: "Scheduled Tasks",
+            // Interactive-only: `akm init` / `--yes` skip this step so headless
+            // runs never enable a scheduled task (see issue #512).
+            async run() {
+                await stepDefaultImproveTasks();
+                await stepScheduledTasks();
+            },
+        },
     ];
     return { steps, outcome };
 }
@@ -1462,11 +1799,28 @@ export async function runSetupWizard(opts) {
         p.log.warn("No network connectivity detected. Skipping Ollama detection and remote embedding checks.\n" +
             "Local-only setup will continue. Re-run `akm setup` when online for full configuration.");
     }
+    // Aggregate environment detection — run once before any prompt and surface
+    // a summary so the user sees what was auto-detected. NAMES only, never
+    // API key values.
+    const detection = await detectEnvironment({ existingStashDir: current.stashDir });
+    p.note(renderDetectionSummary(detection), "Detected environment");
+    // Interactive entry point for `--reset-recommended`: offer to apply the
+    // opinionated, detection-derived defaults and skip the step-by-step wizard.
+    const useRecommended = await prompt(() => p.confirm({
+        message: "Apply recommended defaults from the detected environment (merged into your existing config)?",
+        initialValue: false,
+    }));
+    if (useRecommended) {
+        const result = await runResetRecommended({ dir: opts?.dir, noInit: opts?.noInit });
+        p.outro(`Recommended configuration saved to ${result.configPath}`);
+        return;
+    }
     const ctx = createSetupContext(current, { nonInteractive: false });
     const { steps, outcome } = buildSetupSteps({
         online,
         semanticSearchOutcome: { mode: current.semanticSearchMode, prepareAssets: false },
         preferredStashDir: resolvedStashDir,
+        detection,
     });
     // Wrap each step with a `p.log.step()` header so the wizard UI is
     // unchanged. The canonical `runSetupSteps()` runner is used directly by
@@ -1521,6 +1875,8 @@ export async function runSetupWizard(opts) {
     if (!shouldSave)
         bail();
     // Save config
+    const cfgPath1 = getConfigPath();
+    backupAndAnnounce(cfgPath1);
     saveConfig(newConfig);
     if (semanticSearchMode.mode === "off") {
         clearSemanticStatus();
@@ -1604,6 +1960,20 @@ export async function runSetupWizard(opts) {
     p.outro(`Configuration saved to ${configPath}`);
 }
 // ── Non-interactive / scripting entry points ─────────────────────────────────
+/**
+ * Back up an existing config file and print the real, timestamped backup
+ * location (not a generic display string). On a fresh install where there is
+ * nothing to back up, print a "nothing to back up" notice instead.
+ */
+function backupAndAnnounce(configPath) {
+    const result = backupExistingConfig(configPath);
+    if (result) {
+        p.log.info(`Config backed up to ${result.timestamped}`);
+    }
+    else {
+        p.log.info("No existing config to back up.");
+    }
+}
 /**
  * Run setup in non-interactive mode, applying all defaults.
  * Safe to call from CI or scripts. Idempotent — re-running produces the same result.
@@ -1629,14 +1999,41 @@ export async function runSetupWithDefaults(opts) {
     // Ensure stashDir is set
     if (!ctx.config.stashDir)
         ctx.apply({ stashDir });
+    // Aggregate environment detection — apply detected values directly.
+    const env = await detectEnvironment({ existingStashDir: ctx.config.stashDir });
+    // Apply a detected LLM (live local server) when the config has none yet.
+    if (!getDefaultLlmConfig(ctx.config)) {
+        const liveLocal = env.localServers.find((s) => s.available && s.defaultModel);
+        if (liveLocal?.defaultModel) {
+            const llm = {
+                provider: "local",
+                endpoint: `${liveLocal.baseUrl.replace(/\/$/, "")}/v1`,
+                model: liveLocal.defaultModel,
+            };
+            // A required field being unresolvable must fail loudly rather than write
+            // a broken config (--yes acceptance criterion).
+            if (!llm.endpoint?.trim() || !llm.model?.trim()) {
+                throw new UsageError("Detected a local LLM server but could not resolve a required field (endpoint/model). Re-run `akm setup` interactively.", "MISSING_REQUIRED_ARGUMENT");
+            }
+            ctx.apply(applyLegacyLlm(ctx.config, llm));
+        }
+    }
     // Auto-detect agent CLI if not already configured
     if (!ctx.config.defaults?.agent) {
-        const detected = detectAgentCliProfiles(undefined);
-        const defaultProfile = pickDefaultAgentProfile(detected, undefined);
+        let defaultProfile;
+        if (env.harness !== "none") {
+            defaultProfile = env.harness;
+        }
+        else {
+            const detected = detectAgentCliProfiles(undefined);
+            defaultProfile = pickDefaultAgentProfile(detected, undefined);
+        }
         if (defaultProfile) {
             ctx.apply(applyLegacyAgent(ctx.config, { default: defaultProfile }));
         }
     }
+    const cfgPath2 = getConfigPath();
+    backupAndAnnounce(cfgPath2);
     saveConfig(ctx.config);
     return {
         configPath: getConfigPath(),
@@ -1647,6 +2044,147 @@ export async function runSetupWithDefaults(opts) {
         ripgrep: initResult?.ripgrep,
     };
 }
+/**
+ * Recursively merge `incoming` into `base`: plain objects merge key-by-key,
+ * while arrays and scalars replace wholesale. A partial input therefore only
+ * updates the keys it carries and never drops sibling subkeys (e.g. a file
+ * containing `{ output: { format: "text" } }` leaves `output.detail` intact).
+ *
+ * `base` is treated as immutable — a fresh object graph is returned.
+ */
+function deepMergeConfig(base, incoming) {
+    if (!isPlainObject(incoming))
+        return incoming;
+    const baseObj = isPlainObject(base) ? base : {};
+    const out = { ...baseObj };
+    for (const [key, value] of Object.entries(incoming)) {
+        if (value === undefined)
+            continue;
+        if (isPlainObject(value) && isPlainObject(baseObj[key])) {
+            out[key] = deepMergeConfig(baseObj[key], value);
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+/** True for non-null, non-array plain objects. */
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Run ONLY environment detection and return the typed result. Performs no
+ * config writes and shows no prompts. Backs `akm setup --detect-only`.
+ *
+ * SAFETY: The returned object carries env var NAMES only — never any API key
+ * value.
+ */
+export async function runDetectOnly() {
+    const current = loadUserConfig();
+    return detectEnvironment({ existingStashDir: current.stashDir });
+}
+/**
+ * Derive opinionated defaults from a detection result.
+ *
+ * - Best harness → agent default (when a profile maps to it).
+ * - Fastest live local model, else the first detected cloud key's provider.
+ * - `nomic-embed-text` embeddings when a local LLM is live.
+ * - improve task `0 2 * * *`, index task `0 4 * * *`.
+ *
+ * Returns a partial `AkmConfig`-shaped object plus a legacy `llm` block, ready
+ * to merge. Never includes an API key value.
+ */
+export function deriveRecommendedConfig(env) {
+    const result = {};
+    // Best harness → agent default. #566: derive the default profile name from
+    // the harness registry instead of a hardcoded if-chain, so a newly added
+    // dispatch-capable harness gets a usable headless default (its canonical id)
+    // automatically. "none" / unknown ids resolve to undefined (no default).
+    const agentDefault = defaultProfileName(env.harness);
+    if (agentDefault)
+        result.agentDefault = agentDefault;
+    // LLM: prefer a live local server, else a detected cloud provider key.
+    const liveLocal = env.localServers.find((s) => s.available && s.defaultModel);
+    if (liveLocal?.defaultModel) {
+        result.llm = {
+            provider: "local",
+            endpoint: `${liveLocal.baseUrl.replace(/\/$/, "")}/v1`,
+            model: liveLocal.defaultModel,
+        };
+        // Local LLM live → use a local embedding model.
+        result.embedding = { provider: "ollama", model: "nomic-embed-text", endpoint: `${liveLocal.baseUrl}/v1` };
+    }
+    else {
+        // Map a detected cloud API-key provider to an llm endpoint. NAMES only —
+        // the value lives in the env var the user already set; we never read it.
+        const cloud = env.providers.find((pr) => pr.kind === "apiKey");
+        if (cloud) {
+            const endpoint = cloudEndpointForProvider(cloud.provider);
+            const model = cloudDefaultModelForProvider(cloud.provider);
+            if (endpoint && model) {
+                result.llm = { provider: cloud.provider, endpoint, model };
+            }
+        }
+    }
+    result.taskSchedules = { improve: "0 2 * * *", index: "0 4 * * *" };
+    return result;
+}
+function cloudEndpointForProvider(provider) {
+    switch (provider) {
+        case "anthropic":
+            return "https://api.anthropic.com/v1";
+        case "openai":
+            return "https://api.openai.com/v1";
+        case "gemini":
+            return "https://generativelanguage.googleapis.com/v1beta/openai";
+        case "groq":
+            return "https://api.groq.com/openai/v1";
+        default:
+            return undefined;
+    }
+}
+function cloudDefaultModelForProvider(provider) {
+    switch (provider) {
+        case "anthropic":
+            return "claude-sonnet-4-5";
+        case "openai":
+            return "gpt-4o-mini";
+        case "gemini":
+            return "gemini-1.5-flash";
+        case "groq":
+            return "llama-3.3-70b-versatile";
+        default:
+            return undefined;
+    }
+}
+/**
+ * `akm setup --reset-recommended`: merge opinionated, detection-derived
+ * defaults into the existing config WITHOUT removing pre-existing custom keys.
+ * Uses the same merge path as {@link runSetupFromConfig} so custom keys survive
+ * (follows #511 semantics).
+ */
+export async function runResetRecommended(opts) {
+    const current = loadUserConfig();
+    const env = await detectEnvironment({ existingStashDir: current.stashDir });
+    const recommended = deriveRecommendedConfig(env);
+    const incoming = {};
+    if (recommended.llm)
+        incoming.llm = recommended.llm;
+    if (recommended.embedding)
+        incoming.embedding = recommended.embedding;
+    if (recommended.agentDefault)
+        incoming.agent = { default: recommended.agentDefault };
+    if (recommended.taskSchedules) {
+        incoming.setup = { taskSchedules: recommended.taskSchedules };
+    }
+    return runSetupFromConfig({
+        configJson: JSON.stringify(incoming),
+        dir: opts.dir,
+        noInit: opts.noInit,
+        probe: opts.probe,
+    });
+}
 /**
  * Apply a JSON config blob non-interactively, merging it with the current config.
  * Validates required sub-fields and strips unknown/restricted keys.
@@ -1669,6 +2207,7 @@ export async function runSetupFromConfig(opts) {
         "output",
         "profiles",
         "defaults",
+        "setup",
     ]);
     for (const key of Object.keys(incoming)) {
         if (!ALLOWED_KEYS.has(key)) {
@@ -1700,12 +2239,16 @@ export async function runSetupFromConfig(opts) {
     assertSetupSandbox(stashDir, stashDirExplicit);
     applyStashIsolationToEnv(stashDir, stashDirExplicit);
     let merged = { ...current, stashDir };
-    // Apply non-llm/agent keys directly.
-    const mergedRec = merged;
+    // Deep-merge non-llm/agent keys: nested objects merge key-by-key so a
+    // partial `--file` only updates the keys it carries and never drops sibling
+    // subkeys (e.g. output.detail survives an output.format-only file). Arrays
+    // and scalars replace wholesale.
     for (const key of Object.keys(incoming)) {
         if (key === "llm" || key === "agent")
             continue;
-        mergedRec[key] = incoming[key];
+        const incomingVal = incoming[key];
+        const mergedRec = merged;
+        mergedRec[key] = deepMergeConfig(mergedRec[key], incomingVal);
     }
     // Translate legacy llm/agent inputs into the new shape.
     if (incoming.llm) {
@@ -1714,6 +2257,29 @@ export async function runSetupFromConfig(opts) {
     if (incoming.agent) {
         merged = { ...merged, ...applyLegacyAgent(merged, incoming.agent) };
     }
+    // With `--yes`, fill keys still missing after the merge with non-interactive
+    // defaults. Steps start from `merged` and their nonInteractive path only
+    // populates absent values, so nothing the file or existing config supplied
+    // is overwritten.
+    if (opts.applyDefaults) {
+        const ctx = createSetupContext(merged, { nonInteractive: true });
+        const { steps } = buildSetupSteps({
+            online: false,
+            semanticSearchOutcome: { mode: merged.semanticSearchMode, prepareAssets: false },
+            preferredStashDir: stashDir,
+        });
+        await runSetupSteps(steps, ctx);
+        if (!ctx.config.stashDir)
+            ctx.apply({ stashDir });
+        if (!ctx.config.defaults?.agent) {
+            const detected = detectAgentCliProfiles(undefined);
+            const defaultProfile = pickDefaultAgentProfile(detected, undefined);
+            if (defaultProfile) {
+                ctx.apply(applyLegacyAgent(ctx.config, { default: defaultProfile }));
+            }
+        }
+        merged = ctx.config;
+    }
     // Bootstrap directory structure
     let initResult;
     if (!opts.noInit) {
@@ -1738,6 +2304,8 @@ export async function runSetupFromConfig(opts) {
             // Non-fatal: probe failure is informational only
         }
     }
+    const cfgPath3 = getConfigPath();
+    backupAndAnnounce(cfgPath3);
     saveConfig(merged);
     return {
         configPath: getConfigPath(),