akm-cli 0.10.261013-beta → 0.10.261014-beta

package/dist/setup/detect.js

@@ -10,99 +10,14 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { runManagedSubprocess } from "../core/subprocess.js";
-import { defaultWhich } from "../integrations/agent/detect.js";
-import { getBuiltinAgentProfile, OPENCODE_SDK_SERVER_BIN } from "../integrations/agent/profiles.js";
-import { AGENT_DISPATCH_HARNESSES, SESSION_LOG_HARNESSES } from "../integrations/harnesses/index.js";
-import { detectOpencodeMajor, resolveOpencodeBin } from "../integrations/harnesses/opencode/version.js";
-import { detectHarnessConfigs } from "./harness-config-import.js";
+import { defaultWhich, detectAgentCliProfiles } from "../integrations/agent/detect.js";
+import { HARNESS_CONFIG_PLATFORMS, SESSION_LOG_HARNESSES } from "../integrations/harnesses/index.js";
+import { listEndpointModels } from "../llm/model-list.js";
 let detectOverrides;
 /** TEST-ONLY. Swap the network/host probes; pass undefined to restore. */
 export function _setDetectForTests(fakes) {
     detectOverrides = fakes;
 }
-// ── Ollama Detection ────────────────────────────────────────────────────────
-const OLLAMA_BASE = "http://localhost:11434";
-/**
- * Detect if Ollama is running and list available models.
- *
- * Tries the HTTP API first (`/api/tags`), then falls back to `ollama list`
- * via subprocess. Returns available models sorted alphabetically.
- */
-export async function detectOllama() {
-    if (detectOverrides?.detectOllama)
-        return detectOverrides.detectOllama();
-    const result = { available: false, models: [], endpoint: OLLAMA_BASE };
-    // Try HTTP API first
-    try {
-        const response = await fetch(`${OLLAMA_BASE}/api/tags`, {
-            signal: AbortSignal.timeout(3000),
-        });
-        if (response.ok) {
-            const data = (await response.json());
-            if (Array.isArray(data.models)) {
-                result.models = data.models
-                    .map((m) => (typeof m.name === "string" ? m.name.replace(/:latest$/, "") : ""))
-                    .filter(Boolean)
-                    .sort();
-                result.available = true;
-                return result;
-            }
-        }
-    }
-    catch {
-        // HTTP failed — try CLI fallback
-    }
-    // CLI fallback — bounded (10 s) so a wedged `ollama` can't hang detection.
-    try {
-        const { stdout: text, exitCode } = await runManagedSubprocess(["ollama", "list"], {
-            capture: true,
-            timeoutMs: 10_000,
-        });
-        if (exitCode === 0 && text.trim()) {
-            const lines = text.trim().split("\n").slice(1); // skip header
-            result.models = lines
-                .map((line) => {
-                const name = line.split(/\s+/)[0]?.replace(/:latest$/, "");
-                return name || "";
-            })
-                .filter(Boolean)
-                .sort();
-            result.available = true;
-        }
-    }
-    catch {
-        // Ollama not installed or not in PATH
-    }
-    return result;
-}
-const LMSTUDIO_BASE = "http://localhost:1234";
-/**
- * Detect if LM Studio is running and list available models.
- * Probes the OpenAI-compatible /v1/models endpoint.
- */
-export async function detectLMStudio() {
-    const result = { available: false, models: [], endpoint: LMSTUDIO_BASE };
-    try {
-        const response = await fetch(`${LMSTUDIO_BASE}/v1/models`, {
-            signal: AbortSignal.timeout(2000),
-        });
-        if (response.ok) {
-            const data = (await response.json());
-            if (Array.isArray(data.data)) {
-                result.models = data.data
-                    .map((m) => (typeof m.id === "string" ? m.id : ""))
-                    .filter(Boolean)
-                    .sort();
-                result.available = true;
-            }
-        }
-    }
-    catch {
-        // LM Studio not running or not accessible
-    }
-    return result;
-}
 // ── Agent Platform Detection ────────────────────────────────────────────────
 /**
  * Setup stash-source candidates, derived from the unified harness registry
@@ -115,7 +30,7 @@ export async function detectLMStudio() {
  * "detection trap" (sessions never reached the improve pipeline).
  *
  * The registry is now the single source of which harnesses are real stash
- * sources: a candidate must (a) have `capabilities.sessionLogs === true` AND
+ * sources: a candidate must (a) register a `sessionLogProvider` AND
  * (b) declare a `setupDetectionDir`. `SESSION_LOG_HARNESSES` already filters by
  * (a), so dropping the four dead options is automatic — they aren't even in the
  * registry. Adding a new session-log harness with a detection dir makes it
@@ -145,71 +60,12 @@ export function detectAgentPlatforms() {
         path: path.join(home, p.relPath),
     }));
 }
-/**
- * Map of env var NAME → { provider, kind }. The key NAMES are the only thing
- * this module ever inspects from `process.env`; values are never touched.
- */
-const PROVIDER_ENV_VARS = [
-    { name: "ANTHROPIC_API_KEY", provider: "anthropic", kind: "apiKey" },
-    { name: "OPENAI_API_KEY", provider: "openai", kind: "apiKey" },
-    { name: "GEMINI_API_KEY", provider: "gemini", kind: "apiKey" },
-    { name: "GOOGLE_API_KEY", provider: "gemini", kind: "apiKey" },
-    { name: "GROQ_API_KEY", provider: "groq", kind: "apiKey" },
-    { name: "OLLAMA_HOST", provider: "ollama", kind: "endpoint" },
-    { name: "OLLAMA_BASE_URL", provider: "ollama", kind: "endpoint" },
-    { name: "LM_STUDIO_BASE_URL", provider: "lmstudio", kind: "endpoint" },
-    { name: "LM_STUDIO_API_BASE", provider: "lmstudio", kind: "endpoint" },
-    { name: "LMSTUDIO_BASE_URL", provider: "lmstudio", kind: "endpoint" },
-    { name: "LMSTUDIO_API_BASE", provider: "lmstudio", kind: "endpoint" },
-    { name: "AKM_LLM_API_KEY", provider: "akm-llm", kind: "apiKey" },
-    { name: "AKM_LLM_ENDPOINT", provider: "akm-llm", kind: "endpoint" },
-    { name: "AKM_LLM_BASE_URL", provider: "akm-llm", kind: "endpoint" },
-];
-/**
- * Scan `process.env` for the presence of known provider configuration env var
- * NAMES and return inferred providers.
- *
- * Pure function — no network, no filesystem. It reads only whether each known
- * key is *defined and non-empty*; it never reads, returns, or logs the value.
- *
- * @param envSource  Env to inspect. Defaults to `process.env`. Tests inject a
- *                   fake env so a real API key is never required.
- * @returns Inferred providers, each carrying the env var NAME only.
- */
-export function scanProviderEnvVars(envSource = process.env) {
-    const results = [];
-    for (const entry of PROVIDER_ENV_VARS) {
-        const value = envSource[entry.name];
-        const present = typeof value === "string" && value.trim().length > 0;
-        if (!present)
-            continue;
-        results.push({ provider: entry.provider, envVar: entry.name, kind: entry.kind });
-    }
-    return results;
-}
-/** Default endpoints probed in addition to any harness-config base URLs. */
+/** Local servers that usually speak the OpenAI-compatible API. */
 const DEFAULT_LOCAL_ENDPOINTS = [
     { baseUrl: "http://localhost:11434", label: "Ollama" },
     { baseUrl: "http://localhost:1234", label: "LM Studio" },
     { baseUrl: "http://localhost:8080", label: "Local (8080)" },
 ];
-/**
- * Pick a sensible default model from a list via a name heuristic.
- *
- * Preference order: an explicit "instruct" variant, then the longest name
- * (a rough proxy for the larger / more-capable variant), then the first.
- * Returns `undefined` for an empty list.
- */
-export function pickDefaultModel(models) {
-    const cleaned = models.filter((m) => typeof m === "string" && m.trim().length > 0);
-    if (cleaned.length === 0)
-        return undefined;
-    const instruct = cleaned.filter((m) => /instruct/i.test(m));
-    const pool = instruct.length > 0 ? instruct : cleaned;
-    // Prefer the longest name as a proxy for the larger/most-specific variant,
-    // breaking ties by sort order for determinism.
-    return [...pool].sort((a, b) => b.length - a.length || a.localeCompare(b))[0];
-}
 /**
  * Probe a single OpenAI-compatible `/v1/models` endpoint.
  *
@@ -217,48 +73,19 @@ export function pickDefaultModel(models) {
  * `available: false` result rather than throwing.
  */
 export async function probeLocalEndpoint(baseUrl, label, timeoutMs = 2000) {
-    const result = { baseUrl, label, available: false, models: [] };
-    const url = `${baseUrl.replace(/\/$/, "")}/v1/models`;
-    try {
-        const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
-        if (response.ok) {
-            const data = (await response.json());
-            if (Array.isArray(data.data)) {
-                result.models = data.data
-                    .map((m) => (typeof m.id === "string" ? m.id : ""))
-                    .filter(Boolean)
-                    .sort();
-                result.available = true;
-                result.defaultModel = pickDefaultModel(result.models);
-            }
-        }
-    }
-    catch {
-        // Endpoint down/unreachable — leave available=false.
-    }
-    return result;
+    const listed = await listEndpointModels({ endpoint: `${baseUrl.replace(/\/$/, "")}/v1` }, timeoutMs);
+    return listed.ok
+        ? { baseUrl, label, available: true, models: [...listed.models].sort() }
+        : { baseUrl, label, available: false, models: [] };
 }
 /**
- * Probe the default local endpoints (Ollama 11434, LM Studio 1234, generic
- * 8080) plus any base URLs found in imported harness configs.
+ * Probe the default local endpoints (Ollama 11434, LM Studio 1234, generic 8080).
  *
  * Never throws: every endpoint being down yields a list of unavailable
  * results, not an error.
- *
- * @param harnessBaseUrls  Extra base URLs to probe (e.g. from harness configs).
  */
-export async function detectLocalServers(harnessBaseUrls = []) {
-    const endpoints = [...DEFAULT_LOCAL_ENDPOINTS];
-    for (const raw of harnessBaseUrls) {
-        if (typeof raw !== "string" || raw.trim().length === 0)
-            continue;
-        // Strip a trailing /v1 (and trailing slash) so we probe consistently.
-        const baseUrl = raw.replace(/\/$/, "").replace(/\/v1$/, "");
-        if (!endpoints.some((e) => e.baseUrl === baseUrl)) {
-            endpoints.push({ baseUrl, label: `Harness (${baseUrl})` });
-        }
-    }
-    return Promise.all(endpoints.map((e) => probeLocalEndpoint(e.baseUrl, e.label)));
+export async function detectLocalServers() {
+    return Promise.all(DEFAULT_LOCAL_ENDPOINTS.map((e) => probeLocalEndpoint(e.baseUrl, e.label)));
 }
 /**
  * Suggest stash directories, ranked (lower rank = higher priority).
@@ -334,86 +161,28 @@ function findGitRepoRoot(start) {
     }
 }
 /**
- * Detect the best agent harness, preferring in-process/SDK dispatch over CLI
- * subprocess dispatch:
- *   1. `opencode-sdk` — the embedded SDK, when the server binary it spawns is
- *      on PATH.
- *   2. the first dispatch-capable CLI harness whose binary is on PATH, in
- *      registry order (`opencode`, `claude`, `codex`, ...).
- *   3. none.
- *
- * The SDK import resolving is NOT evidence the SDK path can run: `@opencode-ai/sdk`
- * (OpenCode 1) and `@opencode/client` (OpenCode 2; the binary's detected major
- * selects) are hard dependencies of akm-cli itself, so `import()` always succeeds and an
- * import-only check would report `opencode-sdk` on every machine — including
- * ones where the first agentic command then dies with spawn ENOENT. The SDK
- * runner spawns `opencode serve` (see `harnesses/opencode-sdk/sdk-runner.ts`),
- * so the binary probe is what actually decides. The package cannot substitute
- * for the binary under any driver: it declares `"dependencies": {}` and its
- * own `createOpencodeServer` spawns the same `opencode serve`.
- *
- * Pure aside from the dynamic import resolution (which performs no network).
+ * The agent programs on PATH that can be enabled as a harness, in registry
+ * order. A harness is installed when its binary is found; OpenCode is detected
+ * like any other.
  */
-export async function detectHarness(whichFn = defaultWhich) {
-    // Probed once; reused below so the `opencode` CLI fallback doesn't repeat
-    // the identical full-PATH walk this just performed.
-    const opencodePath = whichFn(resolveOpencodeBin(undefined, whichFn));
-    if (opencodePath) {
-        try {
-            // The client package of the major the binary reports.
-            if (detectOpencodeMajor(opencodePath).major === 1)
-                await import("@opencode-ai/sdk");
-            else
-                await import("@opencode/client");
-            return "opencode-sdk";
-        }
-        catch {
-            // SDK genuinely unavailable (e.g. externalized in a standalone build).
-            // Fall through — the `opencode` CLI harness is probed below.
-        }
-    }
-    for (const harness of AGENT_DISPATCH_HARNESSES) {
-        // The SDK harness dispatches without a CLI profile and was decided above;
-        // an explicit skip so a future `profile` for it can't silently
-        // reintroduce it here after the import guard already rejected it.
-        if (harness.id === "opencode-sdk")
-            continue;
-        const bin = getBuiltinAgentProfile(harness.id)?.bin;
-        if (!bin)
-            continue;
-        const found = bin === OPENCODE_SDK_SERVER_BIN ? opencodePath : whichFn(bin);
-        if (found)
-            return harness.id;
-    }
-    return "none";
+export function detectInstalledHarnesses(whichFn = defaultWhich) {
+    const enableable = new Set(HARNESS_CONFIG_PLATFORMS);
+    return detectAgentCliProfiles(undefined, whichFn).flatMap((found) => found.available && found.resolvedPath && enableable.has(found.name)
+        ? [{ platform: found.name, bin: found.bin, path: found.resolvedPath }]
+        : []);
 }
 /**
  * Run the full environment-detection pipeline once and return a single typed
- * result. Orchestrates env-var scan, harness config import, harness selection,
- * local-server probes, and stash-dir suggestions.
- *
- * SAFETY: No API key VALUE is ever read, stored, logged, or returned — only
- * env var NAMES. Tolerant of every detector failing.
+ * result. Orchestrates harness detection, local-server probes, and stash-dir
+ * suggestions. Tolerant of every detector failing.
  *
  * @param opts.existingStashDir  Current config stashDir (no-op suggestion).
- * @param opts.envSource  Env to scan. Defaults to `process.env`.
  * @param opts.whichFn  Binary lookup. Tests inject a stub.
+ * @param opts.probe  Contact the local servers. False for an offline run.
  */
 export async function detectEnvironment(opts) {
-    const envSource = opts?.envSource ?? process.env;
     const whichFn = opts?.whichFn ?? defaultWhich;
-    let harnessConfigs = [];
-    try {
-        harnessConfigs = detectHarnessConfigs();
-    }
-    catch {
-        harnessConfigs = [];
-    }
-    const harnessBaseUrls = harnessConfigs.map((c) => c.baseUrl).filter((u) => typeof u === "string");
-    const [harness, localServers] = await Promise.all([
-        detectHarness(whichFn),
-        detectLocalServers(harnessBaseUrls).catch(() => []),
-    ]);
+    const localServers = opts?.probe === false ? [] : await detectLocalServers().catch(() => []);
     let agentPlatforms = [];
     try {
         agentPlatforms = detectAgentPlatforms();
@@ -422,9 +191,7 @@ export async function detectEnvironment(opts) {
         agentPlatforms = [];
     }
     return {
-        harness,
-        providers: scanProviderEnvVars(envSource),
-        harnessConfigs,
+        harnesses: detectInstalledHarnesses(whichFn),
         localServers,
         stashSuggestions: detectStashDir({
             existingStashDir: opts?.existingStashDir,
@@ -434,29 +201,17 @@ export async function detectEnvironment(opts) {
         agentPlatforms,
     };
 }
-/**
- * Render a compact, human-readable "Detected environment" summary block.
- * Contains env var NAMES only — never any value.
- */
+/** Render a compact, human-readable "Detected environment" summary block. */
 export function renderDetectionSummary(env) {
     const lines = ["Detected environment:"];
-    lines.push(`  Harness:        ${env.harness}`);
+    lines.push(`  Harnesses:      ${env.harnesses.length > 0 ? env.harnesses.map((h) => h.platform).join(", ") : "none on PATH"}`);
     const liveServers = env.localServers.filter((s) => s.available);
     if (liveServers.length > 0) {
-        lines.push(`  Local servers:  ${liveServers
-            .map((s) => `${s.label}${s.defaultModel ? ` (${s.defaultModel})` : ""}`)
-            .join(", ")}`);
+        lines.push(`  Local servers:  ${liveServers.map((s) => s.label).join(", ")}`);
     }
     else {
         lines.push("  Local servers:  none reachable");
     }
-    if (env.providers.length > 0) {
-        // NAMES only — never values.
-        lines.push(`  Provider keys:  ${env.providers.map((p) => `${p.provider}:${p.envVar}`).join(", ")}`);
-    }
-    else {
-        lines.push("  Provider keys:  none in environment");
-    }
     const topStash = env.stashSuggestions[0];
     if (topStash) {
         lines.push(`  Stash suggest:  ${topStash.path} (${topStash.reason})`);

package/dist/setup/endpoint.js

@@ -0,0 +1,36 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * The endpoint as a connection stores it: the OpenAI-compatible base URL
+ * (`…/v1`), whatever form the user typed it in.
+ */
+/** The base URL for `input`, or a thrown Error saying what is wrong with it. */
+export function normalizeEndpoint(input) {
+    let url;
+    try {
+        url = new URL(input.trim());
+    }
+    catch {
+        throw new Error("endpoint must be a complete URL such as http://localhost:11434/v1");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error("endpoint must use http or https");
+    if (url.username || url.password || url.search || url.hash)
+        throw new Error("endpoint cannot contain credentials, query, or fragment");
+    let pathname = url.pathname.replace(/\/+$/, "").replace(/\/chat\/completions$/, "");
+    if (!pathname.endsWith("/v1") && !pathname.includes("/openai"))
+        pathname += "/v1";
+    url.pathname = pathname;
+    return url.toString().replace(/\/$/, "");
+}
+/** `normalizeEndpoint` as a prompt validator: the problem, or `undefined` when the URL is fine. */
+export function endpointProblem(input) {
+    try {
+        normalizeEndpoint(input);
+        return undefined;
+    }
+    catch (err) {
+        return err instanceof Error ? err.message : String(err);
+    }
+}

package/dist/setup/semantic-assets.js

@@ -2,15 +2,16 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
- * Semantic-search asset preparation for the setup wizard. Transformers.js is
- * a normal external package dependency; setup never mutates the installed CLI.
- * This module only prepares the model.
+ * Semantic-search asset preparation for the setup wizard. The embedding
+ * runtime (onnxruntime-node) is a normal package dependency; setup never
+ * mutates the installed CLI. This module only prepares the model.
  */
 import * as p from "../cli/clack.js";
 import { isHttpUrl } from "../core/common.js";
-import { checkEmbeddingAvailability, DEFAULT_LOCAL_MODEL, isTransformersAvailable } from "../llm/embedder.js";
+import { checkEmbeddingAvailability, DEFAULT_LOCAL_MODEL } from "../llm/embedder.js";
+import { effectiveEmbedding } from "../llm/embedders/connection.js";
 // Approximate first-download size of the default local model (DEFAULT_LOCAL_MODEL), used in the setup note.
-const LOCAL_MODEL_APPROX_SIZE_MB = 130;
+const LOCAL_MODEL_APPROX_SIZE_MB = 127;
 export function isRemoteEmbeddingConfig(embedding) {
     return isHttpUrl(embedding?.endpoint);
 }
@@ -26,29 +27,22 @@ export function describeSemanticSearchAssets(embedding) {
     ];
 }
 export async function prepareSemanticSearchAssets(config) {
-    const remote = isRemoteEmbeddingConfig(config.embedding);
-    // Local embeddings require the declared Transformers dependency.
-    if (!remote) {
-        if (!isTransformersAvailable()) {
-            const message = "The @huggingface/transformers dependency is unavailable. Reinstall akm-cli, then re-run `akm setup` or `akm index --full --verbose`.";
-            p.log.warn(message);
-            return { ok: false, reason: "missing-package", message };
-        }
-    }
+    const embedding = effectiveEmbedding(config);
+    const remote = isRemoteEmbeddingConfig(embedding);
     const spin = p.spinner();
     spin.start(remote
         ? "Checking remote embedding endpoint..."
-        : `Downloading local embedding model (${config.embedding?.localModel ?? DEFAULT_LOCAL_MODEL})...`);
-    const result = await checkEmbeddingAvailability(config.embedding);
+        : `Downloading local embedding model (${embedding?.localModel ?? DEFAULT_LOCAL_MODEL})...`);
+    const result = await checkEmbeddingAvailability(embedding);
     if (!result.available) {
         spin.stop("Semantic-search assets could not be prepared.");
         if (result.reason === "remote-unreachable") {
             p.log.warn("The remote embedding endpoint is not reachable. Check your endpoint and credentials, then retry `akm index --full --verbose`.");
             return { ok: false, reason: "remote-network", message: "The remote embedding endpoint is not reachable." };
         }
-        else if (result.reason === "missing-package") {
-            p.log.warn("The @huggingface/transformers dependency is unavailable. Reinstall akm-cli, then re-run `akm setup` or `akm index --full --verbose`.");
-            return { ok: false, reason: "missing-package", message: "The local embedding runtime is unavailable." };
+        else if (result.reason === "runtime-unavailable") {
+            p.log.warn(`${result.message}\nSet \`embedding.endpoint\` to use a remote embedding service instead.`);
+            return { ok: false, reason: "runtime-unavailable", message: result.message };
         }
         else {
             p.log.warn(`The local embedding model could not be downloaded: ${result.message}\n` +

package/dist/setup/setup-flags.js

@@ -0,0 +1,77 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * The flags of `akm setup` that answer its questions, checked once before
+ * setup prompts, contacts anything or writes. A flag answers its question; a
+ * question no flag answers is asked, or, under `--yes`, takes the detected
+ * default.
+ */
+import { ENGINE_NAME_PATTERN_SOURCE } from "../core/config/engine-semantics.js";
+import { UsageError } from "../core/errors.js";
+import { HARNESS_CONFIG_PLATFORMS } from "../integrations/harnesses/index.js";
+import { normalizeEndpoint } from "./endpoint.js";
+const ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const NAME = new RegExp(ENGINE_NAME_PATTERN_SOURCE);
+function bad(flag, problem) {
+    throw new UsageError(`--${flag}: ${problem}`, "INVALID_FLAG_VALUE");
+}
+function endpointFlag(flag, value) {
+    if (value === undefined)
+        return undefined;
+    try {
+        return normalizeEndpoint(value);
+    }
+    catch (err) {
+        return bad(flag, err instanceof Error ? err.message : String(err));
+    }
+}
+function envNameFlag(flag, value) {
+    if (value === undefined)
+        return undefined;
+    if (!ENV_NAME.test(value))
+        bad(flag, "name the environment variable that holds the key, not the key itself");
+    return value;
+}
+export function parseSetupFlags(raw) {
+    const endpoint = endpointFlag("endpoint", raw.endpoint);
+    const embeddingEndpoint = endpointFlag("embedding-endpoint", raw.embeddingEndpoint);
+    const apiKeyEnv = envNameFlag("api-key-env", raw.apiKeyEnv);
+    const embeddingApiKeyEnv = envNameFlag("embedding-api-key-env", raw.embeddingApiKeyEnv);
+    if (raw.name !== undefined && !NAME.test(raw.name)) {
+        bad("name", "use lowercase kebab-case, not beginning with akm-");
+    }
+    let harness;
+    if (raw.harness !== undefined) {
+        harness = raw.harness
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+        const unknown = harness.filter((platform) => !HARNESS_CONFIG_PLATFORMS.includes(platform));
+        if (harness.length === 0 || unknown.length > 0) {
+            bad("harness", `${unknown.length > 0 ? `unknown platform ${unknown.join(", ")}; ` : ""}use a comma-separated list of ${HARNESS_CONFIG_PLATFORMS.join(", ")}`);
+        }
+    }
+    const embedding = raw.embedding?.trim();
+    if (raw.embedding !== undefined && !embedding)
+        bad("embedding", "name a model, or local, or off");
+    if (embeddingEndpoint !== undefined && (embedding === undefined || embedding === "local" || embedding === "off")) {
+        bad("embedding-endpoint", "needs --embedding <model>, the model that endpoint serves");
+    }
+    if (embeddingApiKeyEnv !== undefined && embeddingEndpoint === undefined) {
+        bad("embedding-api-key-env", "needs --embedding-endpoint; an embedding model on the connection uses its key");
+    }
+    return {
+        ...(endpoint !== undefined ? { endpoint } : {}),
+        ...(apiKeyEnv !== undefined ? { apiKeyEnv } : {}),
+        ...(raw.name !== undefined ? { name: raw.name } : {}),
+        ...(harness !== undefined ? { harness } : {}),
+        ...(embedding !== undefined ? { embedding } : {}),
+        ...(embeddingEndpoint !== undefined ? { embeddingEndpoint } : {}),
+        ...(embeddingApiKeyEnv !== undefined ? { embeddingApiKeyEnv } : {}),
+    };
+}
+/** Whether any flag answers a question. */
+export function hasSetupFlags(flags) {
+    return Object.keys(flags).length > 0;
+}