pi-switchback 2026.10.14 → 2026.10.16

package/index.ts

@@ -44,11 +44,23 @@ import { createModelPicker } from "./src/model-picker.ts";
 import { groupLocalEndpoints, registerLocalClassifier } from "./src/local-classifier.ts";
 import { piThinkingSupport } from "./src/thinking-support.ts";
 import { SWITCHBACK_THINKING_LEVELS } from "switchback-core/thinking.ts";
-import { getPinnedModel, isBlocked, readBlockedMap, readPinMap, setPinnedModel } from "switchback-core/state.ts";
+import {
+	clearDisabled,
+	disableModel,
+	disabledFilePath,
+	enableModel,
+	getPinnedModel,
+	isBlocked,
+	isDisabled,
+	readBlockedMap,
+	readDisabledMap,
+	readPinMap,
+	setPinnedModel,
+} from "switchback-core/state.ts";
 import { annotateCrash, hashSample, isValidAnnotationClass, readCrashMap, shortHash } from "switchback-core/crashes.ts";
 import type {
 	ErrorClass,
-	JevConfig,
+	DecisionModelConfig,
 	ModelId,
 	ResolvedSwitchbackConfig,
 	ResolvedSwitchbackFileConfig,
@@ -66,7 +78,7 @@ export default function (pi: ExtensionAPI) {
 	// SWITCHBACK_DEBUG environment variable for quick toggling without a config edit.
 	const debug = debugFlag(process.env["SWITCHBACK_DEBUG"]) ?? initial.config.debug ?? false;
 
-	// A classifier that names its own endpoint (jev.baseUrl) is registered here, so
+	// A classifier that names its own endpoint (decisionModel.baseUrl) is registered here, so
 	// switchback can classify through a local System One server (e.g. Ollama
 	// v0.35+) without a pi provider for it. No-op for catalog classifiers. Every
 	// direct endpoint is registered **once**, carrying all the classifier models
@@ -75,8 +87,10 @@ export default function (pi: ExtensionAPI) {
 	// `findOfType`. Decision models count even when no virtual model references
 	// them, so an endpoint stays registered while a model list is being edited.
 	for (const endpoint of groupLocalEndpoints([
-		...modelConfigs.flatMap((modelConfig) => (modelConfig.jev === undefined ? [] : [modelConfig.jev])),
-		...(initial.config.decisionModels ?? []),
+		...modelConfigs.flatMap((modelConfig) =>
+			modelConfig.decisionModel === undefined ? [] : [modelConfig.decisionModel],
+		),
+		...Object.values(initial.config.decisionModels ?? {}),
 	])) {
 		registerLocalClassifier(pi, endpoint);
 	}
@@ -127,6 +141,7 @@ export default function (pi: ExtensionAPI) {
 				const result = await decide(request.reason, request, modelConfig, ctx.modelRegistry, {
 					now,
 					blocked,
+					disabled: readDisabledMap(),
 					support: piThinkingSupport(ctx.modelRegistry),
 					notify,
 					debug,
@@ -184,7 +199,7 @@ export default function (pi: ExtensionAPI) {
 						failedId: `${message.provider}/${message.model}`,
 						errorMessage,
 						stopReason: message.stopReason,
-						jev: modelConfig.jev,
+						decisionModel: modelConfig.decisionModel,
 						registry: ctx.modelRegistry,
 						now,
 						blocked: readBlockedMap(now),
@@ -199,14 +214,16 @@ export default function (pi: ExtensionAPI) {
 	}
 
 	// `/switchback` — single overview: config source, debug, per-model pin +
-	// fallbacks (effective / greyed + blocks + reset), active blocks.
+	// fallbacks (effective / greyed + blocks + manual disables + reset), active
+	// blocks, and the models the user disabled by hand.
 	pi.registerCommand("switchback", {
-		description: "Show switchback config: source, debug, per-model pin, fallbacks (effective/greyed/blocks)",
+		description: "Show switchback config: source, debug, pin, fallbacks (effective/greyed/blocks/disabled)",
 		handler: async (_args, ctx) => {
 			const now = Date.now();
 			const reloaded = safeLoadForCommand(pi, secrets);
 			const config = reloaded.config;
 			const blocked = readBlockedMap(now);
+			const disabled = readDisabledMap();
 			const pinMap = readPinMap();
 			const lines: string[] = [];
 			lines.push(`switchback config: ${reloaded.source}${debug ? "  [debug on]" : ""}`);
@@ -223,10 +240,14 @@ export default function (pi: ExtensionAPI) {
 				for (const entry of resolved.entries) {
 					if (entry.availability === "effective") {
 						const isBlockedNow = isBlocked(entry.id, now, blocked);
-						const blockNote = isBlockedNow
-							? `  [blocked, resets in ${Math.ceil((blocked[entry.id]! - now) / 60_000)} min]`
-							: "";
-						lines.push(`  ✓ ${entry.id}${blockNote}`);
+						const isDisabledNow = isDisabled(entry.id, disabled);
+						const notes: string[] = [];
+						if (isDisabledNow) notes.push("disabled by hand");
+						if (isBlockedNow)
+							notes.push(`blocked, resets in ${Math.ceil((blocked[entry.id]! - now) / 60_000)} min`);
+						lines.push(
+							`  ${isDisabledNow ? "⊘" : "✓"} ${entry.id}${notes.length === 0 ? "" : `  [${notes.join("; ")}]`}`,
+						);
 					} else {
 						lines.push(`  ✗ ${entry.id}  [${entry.availability}: ${entry.reason ?? ""}]`);
 					}
@@ -241,14 +262,121 @@ export default function (pi: ExtensionAPI) {
 			} else {
 				lines.push("active blocks: (none)");
 			}
+			const disabledIds = Object.keys(disabled).sort();
+			if (disabledIds.length > 0) {
+				lines.push(`disabled by hand (${disabledIds.length}) - ${disabledFilePath()}:`);
+				for (const id of disabledIds) lines.push(`  ${id}`);
+				lines.push("  (/switchback-enable <provider/model|all> restores)");
+			} else {
+				lines.push("disabled by hand: (none)");
+			}
 			await ctx.ui.notify(lines.join("\n"), "info");
 		},
 	});
 
-	// `/switchback-config` — interactive editor for the switchback.yaml layers:
+	// `/switchback-disable` - keep a configured fallback out of every chain until
+	// it is enabled again. The list lives in the state dir (`disabled.json`), not
+	// in switchback.yaml, so regenerating the config cannot silently re-enable a
+	// model the user turned off.
+	pi.registerCommand("switchback-disable", {
+		description: "Keep a model out of every chain until re-enabled: /switchback-disable <provider/model>",
+		getArgumentCompletions: (argumentPrefix) => {
+			const known = configuredFallbacks(safeLoadForCommand(pi, secrets).config);
+			return known
+				.filter((id) => id.toLowerCase().startsWith(argumentPrefix.toLowerCase()))
+				.map((id) => ({ value: id, label: id, description: "configured fallback" }));
+		},
+		handler: async (args, ctx) => {
+			const target = args.trim();
+			const addresses = configuredFallbacks(safeLoadForCommand(pi, secrets).config);
+			if (target.length === 0) {
+				await ctx.ui.notify(
+					`switchback-disable: name a model address\nconfigured fallbacks:\n${
+						addresses.length === 0 ? "  (none)" : addresses.map((id) => `  ${id}`).join("\n")
+					}`,
+					"info",
+				);
+				return;
+			}
+			const address = matchAddress(addresses, target);
+			if (address === undefined) {
+				await ctx.ui.notify(
+					`switchback: ${JSON.stringify(target)} is not a configured fallback; known addresses: ${
+						addresses.length === 0 ? "(none)" : addresses.join(", ")
+					}`,
+					"warning",
+				);
+				return;
+			}
+			const changed = disableModel(address);
+			await ctx.ui.notify(
+				changed
+					? `switchback: disabled ${address} (${disabledFilePath()}) - /switchback-enable ${address} restores it`
+					: `switchback: ${address} was already disabled`,
+				"info",
+			);
+		},
+	});
+
+	// `/switchback-enable` - undo a manual disable, one model or all of them.
+	pi.registerCommand("switchback-enable", {
+		description: "Re-enable a manually disabled model: /switchback-enable <provider/model|all>",
+		getArgumentCompletions: (argumentPrefix) => {
+			const prefix = argumentPrefix.toLowerCase();
+			const disabledIds = Object.keys(readDisabledMap()).sort();
+			return ["all", ...disabledIds]
+				.filter((id) => id.toLowerCase().startsWith(prefix))
+				.map((id) => ({
+					value: id,
+					label: id,
+					description: id === "all" ? "re-enable every disabled model" : "disabled by hand",
+				}));
+		},
+		handler: async (args, ctx) => {
+			const target = args.trim();
+			const disabled = readDisabledMap();
+			const disabledIds = Object.keys(disabled).sort();
+			if (target.length === 0) {
+				await ctx.ui.notify(
+					`switchback-enable: name a model address or "all"\ndisabled by hand:\n${
+						disabledIds.length === 0 ? "  (none)" : disabledIds.map((id) => `  ${id}`).join("\n")
+					}`,
+					"info",
+				);
+				return;
+			}
+			if (target.toLowerCase() === "all") {
+				const count = clearDisabled();
+				await ctx.ui.notify(
+					count === 0
+						? "switchback: no models were disabled"
+						: `switchback: re-enabled ${count} disabled model(s)`,
+					"info",
+				);
+				return;
+			}
+			const address =
+				matchAddress(disabledIds, target) ??
+				matchAddress(configuredFallbacks(safeLoadForCommand(pi, secrets).config), target);
+			if (address === undefined) {
+				await ctx.ui.notify(
+					`switchback: ${JSON.stringify(target)} is not a configured fallback and was not disabled`,
+					"warning",
+				);
+				return;
+			}
+			const changed = enableModel(address);
+			await ctx.ui.notify(
+				changed ? `switchback: re-enabled ${address}` : `switchback: ${address} was not disabled`,
+				"info",
+			);
+		},
+	});
+
+	// `/switchback-config` - interactive editor for the switchback.yaml layers:
 	// virtual models, fallback order, decision models, encrypted API-key secrets
 	// and the debug flag. Each action is validated through the loader's single
-	// gate (validateFileConfig + resolveJevConfig) and saved immediately, so the
+	// gate (`validateFileConfig`) and saved immediately, so the
 	// file on disk always holds the last good config; a failed action reverts.
 	pi.registerCommand("switchback-config", {
 		description: "Interactively configure virtual models, fallbacks, decision models, API keys and debug",
@@ -266,7 +394,7 @@ export default function (pi: ExtensionAPI) {
 							}
 						: {}),
 					classifierProviders: classifierProvidersFrom(ctx.modelRegistry),
-					probeClassifier: (jev: JevConfig) => probeClassifierConfig(ctx, jev),
+					probeClassifier: (decisionModel: DecisionModelConfig) => probeClassifierConfig(ctx, decisionModel),
 				},
 				secrets,
 			);
@@ -527,23 +655,23 @@ function classifierProvidersFrom(registry: ExtensionContext["modelRegistry"]) {
  * through switchback's own transport (the registered provider only appears after
  * a restart), a catalog classifier through pi's registry.
  */
-async function probeClassifierConfig(ctx: ExtensionContext, jev: JevConfig): Promise<ProbeResult> {
-	if (jev.baseUrl !== undefined) {
+async function probeClassifierConfig(ctx: ExtensionContext, decisionModel: DecisionModelConfig): Promise<ProbeResult> {
+	if (decisionModel.baseUrl !== undefined) {
 		return probeLocalClassifier({
-			baseUrl: jev.baseUrl,
-			apiKey: jev.apiKey ?? jev.provider,
-			provider: jev.provider,
-			id: jev.id,
+			baseUrl: decisionModel.baseUrl,
+			apiKey: decisionModel.apiKey ?? decisionModel.provider,
+			provider: decisionModel.provider,
+			id: decisionModel.id,
 		});
 	}
-	const handle = ctx.modelRegistry.findOfType("classifier", jev.provider, jev.id);
+	const handle = ctx.modelRegistry.findOfType("classifier", decisionModel.provider, decisionModel.id);
 	if (handle === undefined) {
 		return {
 			ok: false,
 			answers: {},
 			missing: ["choice", "score", "noul"],
 			ms: 0,
-			error: `pi has no classifier "${jev.provider}/${jev.id}" in its catalog`,
+			error: `pi has no classifier "${decisionModel.provider}/${decisionModel.id}" in its catalog`,
 		};
 	}
 	const started = Date.now();
@@ -612,6 +740,22 @@ function parseCount(args: string, fallback: number): number | undefined {
 	return n;
 }
 
+// Every configured fallback address across a config file, first-seen order and
+// deduplicated: the vocabulary the disable/enable commands accept.
+function configuredFallbacks(config: ResolvedSwitchbackFileConfig): ModelId[] {
+	const seen = new Set<ModelId>();
+	for (const model of config.models) for (const id of model.fallbacks) seen.add(id);
+	return [...seen];
+}
+
+// Commands are typed by hand, so address matching ignores case (the unblock
+// command works the same way). Returns the canonical configured spelling.
+function matchAddress(addresses: readonly ModelId[], argument: string): ModelId | undefined {
+	const wanted = argument.trim().toUpperCase();
+	if (wanted.length === 0) return undefined;
+	return addresses.find((id) => id.toUpperCase() === wanted);
+}
+
 interface ParsedAnnotateArgs {
 	hash: string;
 	class: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-switchback",
-	"version": "2026.10.14",
+	"version": "2026.10.16",
 	"type": "module",
 	"description": "Quota-aware graceful model fallback for pi via the native pi.registerVirtualModel() API.",
 	"license": "MIT",

package/src/dialogue-classifier.ts

@@ -1,7 +1,13 @@
 /**
- * The decision-model half of the `/switchback-config` dialogue: choosing a
- * classifier for a virtual model, and the wizard that creates, edits, renames,
- * tests and deletes reusable `decisionModels` entries.
+ * The decision-model half of the `/switchback-config` dialogue: naming the
+ * decision model a virtual model uses, and the wizard that creates, edits,
+ * renames, tests and deletes `decisionModels` entries.
+ *
+ * A decision model is addressed as `provider/model-id` - the same shape as a
+ * fallback. The address alone is enough when the host can resolve it from its
+ * classifier catalog; a `decisionModels` entry at the same address adds the
+ * connection details (`baseUrl`, `apiKey`) that make a direct SystemOne endpoint
+ * reachable from any host.
  *
  * Split out of `src/dialogue.ts` because it is the larger half and grew
  * independently: it is the only part that needs the provider catalog, the live
@@ -26,20 +32,18 @@ import {
 	type DecisionModelInput,
 	type DecisionModelPatch,
 } from "switchback-core/config-editor.ts";
-import { LOCAL_CLASSIFIER_APIS } from "switchback-core/config.ts";
 import {
 	classifierBaseUrlNote,
-	defaultDecisionModelName,
 	directEndpointWouldClobber,
 	type ClassifierProviderOption,
 } from "switchback-core/classifier-catalog.ts";
 import { discoverOllamaModels } from "switchback-core/classifier-discovery.ts";
 import { formatProbeReport } from "switchback-core/classifier-probe.ts";
 import {
-	describeJev,
+	describeDecisionModel,
 	errorMessage,
 	findModel,
-	promptNameLast,
+	promptAddressLast,
 	promptOptional,
 	promptRequired,
 	readConfigOrReport,
@@ -50,7 +54,7 @@ import {
 	type DialogueContext,
 	type DialogueSession,
 } from "./dialogue-ui.ts";
-import type { DecisionModelEntry, JevConfig } from "switchback-core/types.ts";
+import type { DecisionModelConfig, DecisionModelEntry } from "switchback-core/types.ts";
 
 export async function decisionModelPicker(
 	ctx: DialogueContext,
@@ -58,7 +62,6 @@ export async function decisionModelPicker(
 	virtualId: string,
 ): Promise<void> {
 	const noneOption = "(none - report and cycle)";
-	const inlineOption = "(inline - configure directly)...";
 	const newOption = "New decision model...";
 	const backOption = "Back";
 	for (;;) {
@@ -66,28 +69,20 @@ export async function decisionModelPicker(
 		if (config === undefined) return;
 		const model = findModel(config, virtualId);
 		if (model === undefined) return;
-		const dmLabels = (config.decisionModels ?? []).map((d) => `${d.name} - ${d.provider}/${d.id}`);
+		const entries = Object.entries(config.decisionModels ?? {});
+		const labels = entries.map(([address, entry]) => describeEntry(address, entry));
 		const choice = await ctx.ui.select(
-			screenTitle(session.loaded, `decision model for ${virtualId}\ncurrently: ${describeJev(model.jev)}`),
-			[noneOption, ...dmLabels, inlineOption, newOption, backOption],
+			screenTitle(
+				session.loaded,
+				`decision model for ${virtualId}\ncurrently: ${describeDecisionModel(model.decisionModel)}`,
+			),
+			[noneOption, ...labels, newOption, backOption],
 		);
 		if (choice === undefined || choice === backOption) return;
 		if (choice === noneOption) {
 			setDecisionModel(session.loaded, virtualId, null);
 			if (await saveOrRevert(ctx, session)) {
-				ctx.ui.notify(`${virtualId}: classifier cleared (reports and cycles)`, "info");
-				return;
-			}
-			continue;
-		}
-		if (choice === inlineOption) {
-			const existing = model.jev !== undefined && !("decisionModel" in model.jev) ? model.jev : undefined;
-			const inline = await collectJevFields(ctx, session, existing, virtualId);
-			if (inline === undefined) continue;
-			setDecisionModel(session.loaded, virtualId, inline);
-			if (await saveOrRevert(ctx, session)) {
-				ctx.ui.notify(`${virtualId}: inline classifier set`, "info");
-				await offerClassifierTest(ctx, session, jevFromInput(inline));
+				ctx.ui.notify(`${virtualId}: decision model cleared (reports and cycles)`, "info");
 				return;
 			}
 			continue;
@@ -95,20 +90,21 @@ export async function decisionModelPicker(
 		if (choice === newOption) {
 			const created = await decisionModelWizard(ctx, session);
 			if (created === undefined) continue;
-			setDecisionModel(session.loaded, virtualId, { decisionModel: created.name });
+			setDecisionModel(session.loaded, virtualId, created.address);
 			if (await saveOrRevert(ctx, session)) {
-				ctx.ui.notify(`${virtualId}: decision model "${created.name}" created and set`, "info");
+				ctx.ui.notify(`${virtualId}: decision model ${created.address} created and set`, "info");
+				await offerClassifierTest(ctx, session, entryForInput(created), created.address);
 				return;
 			}
 			continue;
 		}
-		const name =
-			dmLabels.indexOf(choice) >= 0 ? (config.decisionModels ?? [])[dmLabels.indexOf(choice)]?.name : undefined;
-		const entry = name !== undefined ? (config.decisionModels ?? []).find((d) => d.name === name) : undefined;
-		if (entry === undefined) continue;
-		setDecisionModel(session.loaded, virtualId, { decisionModel: entry.name });
+		const index = labels.indexOf(choice);
+		const picked = index >= 0 ? entries[index] : undefined;
+		if (picked === undefined) continue;
+		setDecisionModel(session.loaded, virtualId, picked[0]);
 		if (await saveOrRevert(ctx, session)) {
-			ctx.ui.notify(`${virtualId}: decision model "${entry.name}" set`, "info");
+			ctx.ui.notify(`${virtualId}: decision model ${picked[0]} set`, "info");
+			await offerClassifierTest(ctx, session, picked[1], picked[0]);
 			return;
 		}
 	}
@@ -120,10 +116,10 @@ export async function decisionModelsMenu(ctx: DialogueContext, session: Dialogue
 	for (;;) {
 		const config = readConfigOrReport(ctx, session.loaded);
 		if (config === undefined) return;
-		const entries = config.decisionModels ?? [];
-		const labels = entries.map((d) => `${d.name} - ${d.provider}/${d.id}`);
+		const entries = Object.entries(config.decisionModels ?? {});
+		const labels = entries.map(([address, entry]) => describeEntry(address, entry));
 		const choice = await ctx.ui.select(
-			screenTitle(session.loaded, "decision models (reusable classifier configs)"),
+			screenTitle(session.loaded, "decision models (address-keyed classifier connection details)"),
 			[...labels, addOption, backOption],
 		);
 		if (choice === undefined || choice === backOption) return;
@@ -131,113 +127,107 @@ export async function decisionModelsMenu(ctx: DialogueContext, session: Dialogue
 			await decisionModelWizard(ctx, session);
 			continue;
 		}
-		const name = labels.indexOf(choice) >= 0 ? entries[labels.indexOf(choice)]?.name : undefined;
-		const entry = name !== undefined ? entries.find((d) => d.name === name) : undefined;
-		if (entry !== undefined) await decisionModelEntryMenu(ctx, session, entry);
+		const index = labels.indexOf(choice);
+		const picked = index >= 0 ? entries[index] : undefined;
+		if (picked !== undefined) await decisionModelEntryMenu(ctx, session, picked[0]);
 	}
 }
 
-async function decisionModelEntryMenu(
-	ctx: DialogueContext,
-	session: DialogueSession,
-	entry: DecisionModelEntry,
-): Promise<void> {
-	const renameOption = "Rename (updates references)";
-	const editOption = "Edit fields";
+async function decisionModelEntryMenu(ctx: DialogueContext, session: DialogueSession, address: string): Promise<void> {
+	const renameOption = "Rename address (updates references)";
+	const editOption = "Edit connection (baseUrl, apiKey)";
 	const testOption = "Test classifier (choice, score, noul)";
 	const deleteOption = "Delete";
 	const backOption = "Back";
 	for (;;) {
 		const config = readConfigOrReport(ctx, session.loaded);
 		if (config === undefined) return;
-		const current = (config.decisionModels ?? []).find((d) => d.name === entry.name);
+		const current = (config.decisionModels ?? {})[address];
 		if (current === undefined) return; // deleted elsewhere in this session
-		const choice = await ctx.ui.select(
-			screenTitle(session.loaded, `${current.name} - ${current.provider}/${current.id}`),
-			[
-				renameOption,
-				editOption,
-				...(ctx.probeClassifier !== undefined ? [testOption] : []),
-				deleteOption,
-				backOption,
-			],
-		);
+		const choice = await ctx.ui.select(screenTitle(session.loaded, describeEntry(address, current)), [
+			renameOption,
+			editOption,
+			...(ctx.probeClassifier !== undefined ? [testOption] : []),
+			deleteOption,
+			backOption,
+		]);
 		if (choice === undefined || choice === backOption) return;
 		if (choice === testOption) {
-			await runClassifierTest(ctx, session, {
-				provider: current.provider,
-				id: current.id,
-				...(current.baseUrl !== undefined ? { baseUrl: current.baseUrl } : {}),
-				...(current.api !== undefined ? { api: current.api } : {}),
-				...(current.apiKey !== undefined ? { apiKey: current.apiKey } : {}),
-			});
+			await runClassifierTest(ctx, session, current, address);
 			continue;
 		}
 		if (choice === renameOption) {
-			const newName = await promptRequired(
+			const newAddress = await promptRequired(
 				ctx,
-				screenTitle(session.loaded, `rename decision model "${current.name}"`),
-				current.name,
+				screenTitle(session.loaded, `rename decision model ${address} (provider/model-id)`),
+				address,
 			);
-			if (newName === undefined || newName === current.name) continue;
-			renameDecisionModel(session.loaded, current.name, newName);
+			if (newAddress === undefined || newAddress === address) continue;
+			if (!newAddress.includes("/")) {
+				ctx.ui.notify(`an address is "provider/model-id" - "${newAddress}" has no provider`, "warning");
+				continue;
+			}
+			if (Object.hasOwn(config.decisionModels ?? {}, newAddress)) {
+				ctx.ui.notify(`a decision model at "${newAddress}" already exists`, "warning");
+				continue;
+			}
+			renameDecisionModel(session.loaded, address, newAddress);
 			if (await saveOrRevert(ctx, session)) {
-				entry.name = newName;
-				ctx.ui.notify(`renamed to "${newName}"; references updated`, "info");
+				address = newAddress;
+				ctx.ui.notify(`renamed to ${newAddress}; references updated`, "info");
 			}
 			continue;
 		}
 		if (choice === editOption) {
-			const patch = await collectJevPatch(ctx, session, current);
+			const patch = await collectConnection(ctx, session, address, current);
 			if (patch === undefined) continue;
-			updateDecisionModel(session.loaded, current.name, patch);
+			updateDecisionModel(session.loaded, address, patch);
 			if (await saveOrRevert(ctx, session)) {
-				ctx.ui.notify(`decision model "${current.name}" updated`, "info");
+				ctx.ui.notify(`decision model ${address} updated`, "info");
 			}
 			continue;
 		}
 		if (choice === deleteOption) {
-			const refs = countDecisionModelReferences(session.loaded, current.name);
+			const refs = countDecisionModelReferences(session.loaded, address);
 			if (refs > 0) {
 				ctx.ui.notify(
-					`"${current.name}" is still referenced by ${refs} model(s) - set their decision model first`,
+					`${address} is still named by ${refs} model(s) - set their decision model first`,
 					"warning",
 				);
 				continue;
 			}
 			const confirmed = await ctx.ui.confirm(
-				screenTitle(session.loaded, `delete decision model "${current.name}"`),
-				`Delete "${current.name}" (${current.provider}/${current.id}) from ${session.loaded.path}?`,
+				screenTitle(session.loaded, `delete decision model ${address}`),
+				`Delete ${address} from ${session.loaded.path}? Chains that name it fall back to catalog resolution.`,
 			);
 			if (!confirmed) continue;
-			removeDecisionModel(session.loaded, current.name);
+			removeDecisionModel(session.loaded, address);
 			if (await saveOrRevert(ctx, session)) {
-				ctx.ui.notify(`deleted "${current.name}"`, "info");
+				ctx.ui.notify(`deleted ${address}`, "info");
 				return;
 			}
 		}
 	}
 }
 
-/** Collect a brand-new decision model entry. The order is provider → baseUrl →
- * model id → apiKey → name (last, prefilled). The user can Tab + Enter through
- * the whole flow when accepting the defaults; the only prompt that requires a
- * real decision is the apiKey action (new secret, keep existing, or none).
+/**
+ * Collect a brand-new decision model entry. The order is provider -> baseUrl ->
+ * model id -> apiKey -> address (last, prefilled). The address is the map key,
+ * so it is asked after the connection details it describes.
  */
 async function decisionModelWizard(
 	ctx: DialogueContext,
 	session: DialogueSession,
 ): Promise<DecisionModelInput | undefined> {
-	// Tolerant read: on a fresh layer there is no config yet and no name to clash with;
-	// addDecisionModel + the save gate still own the uniqueness rule.
+	// Tolerant read: on a fresh layer there is no config yet and no address to clash with.
 	const config = tryReadConfig(session.loaded);
-	const knownNames = (config?.decisionModels ?? []).map((d) => d.name);
+	const knownAddresses = Object.keys(config?.decisionModels ?? {});
 
 	// 1. Provider
 	const option = await chooseClassifierProvider(ctx, session, undefined);
 	if (option === undefined) return undefined;
 
-	// 2. baseUrl (always prefilled for both catalog and local; "-" clears it)
+	// 2. baseUrl ("-" keeps catalog resolution; a URL declares a direct endpoint)
 	const baseUrl = await chooseBaseUrl(ctx, session, option, undefined);
 	if (baseUrl === undefined) return undefined;
 
@@ -245,61 +235,31 @@ async function decisionModelWizard(
 	const id = await chooseClassifierModel(ctx, session, option, undefined, baseUrl ?? option.baseUrl);
 	if (id === undefined) return undefined;
 
-	// apiKey / api / baseUrl are loader-coupled: apiKey and api both require a
-	// baseUrl, so a cleared baseUrl means none of those fields apply. Skip the
-	// apiKey step entirely when the user typed "-".
-	let apiKeyResult: ApiKeyAction = { kind: "none" };
+	// 4. apiKey: only a direct endpoint carries one (the loader requires it there).
+	let pendingKey: ApiKeyAction = { kind: "local" };
 	if (baseUrl !== null) {
-		// 4. apiKey action: collect the user's choice (none / pick existing / new
-		//    secret value) but defer the secret-store write until we know the
-		//    final decision-model name - the store entry is derived from the
-		//    name so a single secret can be re-keyed under the new name.
-		apiKeyResult = await apiKeyAction(ctx, session, undefined, option.provider);
-		if (apiKeyResult.kind === "cancel") return undefined;
-	}
-
-	// 5. Name (LAST, prefilled). Only the catalog providers need an apiKey at
-	//    all - a local Ollama / llama-server ignores it; a local server also
-	//    needs one as a non-empty transport requirement, but the wizard sets
-	//    it for them when the user picks "no api key" or skips the step.
-	const rest: Partial<DecisionModelInput> = {};
-	if (baseUrl !== null && baseUrl !== undefined) rest.baseUrl = baseUrl;
-	if (baseUrl !== null && baseUrl !== undefined) {
-		const api = option.api ?? LOCAL_CLASSIFIER_APIS[0];
-		if (api !== undefined) rest.api = api;
-	}
-	if (apiKeyResult.kind === "secret") {
-		// Defer the secret-store commit until the name is known so the store
-		// entry follows the decision-model name (`secret:<name>-key`); we pass
-		// apiKeyResult.value into the new logic further below.
+		pendingKey = await apiKeyAction(ctx, session, undefined, `${option.provider}/${id}`);
+		if (pendingKey.kind === "cancel") return undefined;
 	}
-	// For local endpoints the transport defaults to a non-empty bearer token
-	// (`local-classifier.ts` falls back to the provider id), so an apiKey in
-	// the config is optional. For catalog providers the user must either
-	// supply a secret or accept "no api key" - the wizard does not write a
-	// literal token to disk in either path.
 
-	const suggestedName = defaultDecisionModelName(option.provider, id);
-	const name = await promptNameLast(ctx, session.loaded, suggestedName, knownNames);
-	if (name === undefined) return undefined;
+	// 5. Address (LAST, prefilled). The secret-store entry is derived from the
+	//    address, so it is committed only after the address is known.
+	const address = await promptAddressLast(ctx, session.loaded, `${option.provider}/${id}`, knownAddresses);
+	if (address === undefined) return undefined;
 
-	// Commit the apiKey value (if any) under the now-known name, then build the
-	// DecisionModelInput. Deferring the write keeps the secret name aligned with
-	// the decision-model name regardless of whether the user kept the suggested
-	// default or typed their own.
-	let finalRest: Partial<DecisionModelInput> = rest;
-	if (apiKeyResult.kind === "secret") {
-		const secretName = secretNameFor(name);
-		try {
-			session.secrets.set(secretName, apiKeyResult.value);
-		} catch (error) {
-			ctx.ui.notify(`secret store refused the value: ${errorMessage(error)}`, "error");
-			return undefined;
-		}
-		finalRest = { ...rest, apiKeySecretName: secretName };
+	let apiKeySecretName: string | undefined;
+	if (pendingKey.kind === "new") {
+		apiKeySecretName = commitSecret(ctx, session, address, pendingKey.value);
+		if (apiKeySecretName === undefined) return undefined;
+	} else if (pendingKey.kind === "existing") {
+		apiKeySecretName = pendingKey.name;
 	}
 
-	const input: DecisionModelInput = { name, provider: option.provider, id, ...finalRest };
+	const input: DecisionModelInput = {
+		address,
+		...(baseUrl !== null ? { baseUrl } : {}),
+		...(apiKeySecretName !== undefined ? { apiKeySecretName } : {}),
+	};
 	try {
 		addDecisionModel(session.loaded, input);
 	} catch (error) {
@@ -307,23 +267,47 @@ async function decisionModelWizard(
 		return undefined;
 	}
 	if (await saveOrRevert(ctx, session)) {
-		ctx.ui.notify(`decision model "${name}" added`, "info");
-		await offerClassifierTest(ctx, session, jevFromInput({ provider: option.provider, id, rest: finalRest }));
+		ctx.ui.notify(`decision model ${address} added`, "info");
+		await offerClassifierTest(ctx, session, entryForInput(input), address);
 		return input;
 	}
 	return undefined;
 }
 
-/** The inline classifier config a wizard result describes (used for the capability test). */
-function jevFromInput(fields: { provider: string; id: string; rest?: Partial<DecisionModelInput> }): JevConfig {
-	const rest = fields.rest ?? {};
-	return {
-		provider: fields.provider,
-		id: fields.id,
-		...(rest.baseUrl !== undefined ? { baseUrl: rest.baseUrl } : {}),
-		...(rest.api !== undefined ? { api: rest.api } : {}),
-		...(rest.apiKeySecretName !== undefined ? { apiKey: `secret:${rest.apiKeySecretName}` } : {}),
-	};
+/**
+ * Edit an existing entry's connection details. The address (provider/model id)
+ * is the map key and is changed through the rename action instead, so this only
+ * collects `baseUrl` and `apiKey`.
+ */
+async function collectConnection(
+	ctx: DialogueContext,
+	session: DialogueSession,
+	address: string,
+	current: DecisionModelEntry,
+): Promise<DecisionModelPatch | undefined> {
+	const baseUrl = await promptOptional(
+		ctx,
+		screenTitle(session.loaded, `baseUrl for ${address} - a direct SystemOne endpoint ("-" clears it, Esc keeps)`),
+		current.baseUrl,
+	);
+	if (baseUrl === undefined) return undefined;
+	const patch: DecisionModelPatch = {};
+	if (baseUrl === null) {
+		// updateDecisionModel clears apiKey with baseUrl (the loader rule: it requires baseUrl).
+		patch.baseUrl = null;
+		return patch;
+	}
+	if (baseUrl !== current.baseUrl) patch.baseUrl = baseUrl;
+	const key = await apiKeyAction(ctx, session, current.apiKey, address);
+	if (key.kind === "cancel") return undefined;
+	if (key.kind === "local") patch.apiKeySecretName = null;
+	else if (key.kind === "existing") patch.apiKeySecretName = key.name;
+	else if (key.kind === "new") {
+		const committedName = commitSecret(ctx, session, address, key.value);
+		if (committedName === undefined) return undefined;
+		patch.apiKeySecretName = committedName;
+	}
+	return patch;
 }
 
 /**
@@ -382,22 +366,13 @@ async function chooseClassifierProvider(
 
 /**
  * An endpoint the user names themselves: pi has no catalog entry for it, so
- * switchback registers the classifier from the config (`baseUrl` present). No
- * base URL or wire API is invented here - the wizard asks for both.
+ * switchback registers the classifier from the config (`baseUrl` present).
  */
 function declaredEndpoint(provider: string): ClassifierProviderOption {
 	return { provider, label: provider, displayName: provider, models: [], local: true, chatModels: 0 };
 }
 
-/** Choose the classifier model id from the provider's known classifiers, or type one.
- *
- * The picker offers what pi's catalog knows for this provider. When the catalog
- * knows nothing and the endpoint is reachable, the wizard asks the server
- * itself (Ollama's `/api/tags`, filtered by the `decision` capability) so a
- * freshly pointed endpoint does not have to wait for a routing failure to reveal
- * a wrong model id. Provider-agnostic on purpose: the trigger is "the catalog
- * cannot help here", not a hardcoded provider name.
- */
+/** Choose the classifier model id from the provider's known classifiers, or type one. */
 async function chooseClassifierModel(
 	ctx: DialogueContext,
 	session: DialogueSession,
@@ -492,64 +467,93 @@ async function chooseBaseUrl(
 /**
  * Send the capability prompt and report the verdict. See `packages/core/src/classifier-probe.ts`.
  */
-async function runClassifierTest(ctx: DialogueContext, session: DialogueSession, jev: JevConfig): Promise<void> {
+async function runClassifierTest(
+	ctx: DialogueContext,
+	session: DialogueSession,
+	entry: DecisionModelEntry,
+	address: string,
+): Promise<void> {
 	if (ctx.probeClassifier === undefined) return;
-	const label = `${jev.provider}/${jev.id}${jev.baseUrl !== undefined ? ` at ${jev.baseUrl}` : ""}`;
-	const result = await ctx.probeClassifier(resolveSecretRef(jev, session));
+	const resolved = probeConfig(address, entry, session);
+	if (resolved === undefined) {
+		ctx.ui.notify(`${address}: the address has no "/" - cannot probe it`, "warning");
+		return;
+	}
+	const label = `${resolved.provider}/${resolved.id}${
+		resolved.baseUrl !== undefined ? ` at ${resolved.baseUrl}` : ""
+	}`;
+	const result = await ctx.probeClassifier(resolved);
 	ctx.ui.notify(formatProbeReport({ label, result }), result.ok ? "info" : "warning");
 }
 
 /**
- * Offer the one-shot capability test after a classifier config was written.
+ * Offer the one-shot capability test after a decision model was written.
  *
  * Most SystemOne endpoints publish no model list, so the model id is guessed;
  * this is where a wrong guess (or a model without the `decision` capability)
  * surfaces, instead of at the first real routing failure.
  */
-async function offerClassifierTest(ctx: DialogueContext, session: DialogueSession, jev: JevConfig): Promise<void> {
+async function offerClassifierTest(
+	ctx: DialogueContext,
+	session: DialogueSession,
+	entry: DecisionModelEntry,
+	address: string,
+): Promise<void> {
 	if (ctx.probeClassifier === undefined) return;
 	const confirmed = await ctx.ui.confirm(
-		screenTitle(session.loaded, `test ${jev.provider}/${jev.id} now?`),
+		screenTitle(session.loaded, `test ${address} now?`),
 		"Sends one SystemOne prompt that exercises choice, score and noul, so a wrong model id or endpoint shows up immediately.",
 	);
 	if (!confirmed) return;
-	await runClassifierTest(ctx, session, jev);
+	await runClassifierTest(ctx, session, entry, address);
 }
 
-/** Classifier fields for a NEW inline config / decision model. Undefined = user backed out. */
-async function collectJevFields(
-	ctx: DialogueContext,
+function describeEntry(address: string, entry: DecisionModelEntry): string {
+	return entry.baseUrl === undefined
+		? `${address} - resolved from the classifier catalog`
+		: `${address} - direct: ${entry.baseUrl}`;
+}
+
+function splitAddress(address: string): { provider: string; id: string } | undefined {
+	const slash = address.indexOf("/");
+	if (slash <= 0 || slash === address.length - 1) return undefined;
+	return { provider: address.slice(0, slash), id: address.slice(slash + 1) };
+}
+
+/** The entry a wizard result describes, for the capability test. */
+function entryForInput(input: DecisionModelInput): DecisionModelEntry {
+	if (input.baseUrl === undefined) return {};
+	return {
+		baseUrl: input.baseUrl,
+		apiKey: input.apiKeySecretName === undefined ? "local" : `secret:${input.apiKeySecretName}`,
+	};
+}
+
+/** Resolve an entry into the probe's shape, pulling a `secret:` value from the store. */
+function probeConfig(
+	address: string,
+	entry: DecisionModelEntry,
 	session: DialogueSession,
-	existing: JevConfig | undefined,
-	hint?: string,
-): Promise<{ provider: string; id: string; rest?: Partial<DecisionModelInput> } | undefined> {
-	const option = await chooseClassifierProvider(ctx, session, existing?.provider);
-	if (option === undefined) return undefined;
-	const baseUrl = await chooseBaseUrl(ctx, session, option, existing?.baseUrl);
-	if (baseUrl === undefined) return undefined;
-	const id = await chooseClassifierModel(ctx, session, option, existing?.id, baseUrl ?? option.baseUrl);
-	if (id === undefined) return undefined;
-	if (baseUrl === null) return { provider: option.provider, id };
-	// `api` is aligned with the endpoint instead of asked: a direct endpoint speaks
-	// exactly one wire API (switchback's own SystemOne transport), so the old
-	// "(none)" choice offered an option that does not exist.
-	const api = option.api ?? LOCAL_CLASSIFIER_APIS[0];
-	const rest: Partial<DecisionModelInput> = { baseUrl, ...(api !== undefined ? { api } : {}) };
-	const key = await apiKeyAction(ctx, session, existing?.apiKey, hint ?? option.provider);
-	if (key.kind === "cancel") return undefined;
-	if (key.kind === "secret") {
-		const committedName = commitSecret(ctx, session, hint ?? option.provider, key.value);
-		if (committedName === undefined) return undefined;
-		rest.apiKeySecretName = committedName;
+): DecisionModelConfig | undefined {
+	const parts = splitAddress(address);
+	if (parts === undefined) return undefined;
+	let apiKey = entry.apiKey;
+	if (apiKey !== undefined && apiKey.startsWith("secret:")) {
+		const stored = session.secrets.get(apiKey.slice("secret:".length));
+		if (stored !== undefined) apiKey = stored;
 	}
-	return { provider: option.provider, id, rest };
+	return {
+		provider: parts.provider,
+		id: parts.id,
+		...(entry.baseUrl !== undefined ? { baseUrl: entry.baseUrl } : {}),
+		...(apiKey !== undefined ? { apiKey } : {}),
+	};
 }
 
 /**
- * Commit a secret value to the store under a name derived from `hint`. Returns
- * the chosen name on success, undefined on failure (the wizard treats undefined
- * as user cancellation). The hint should be the decision-model name when one
- * exists, or the provider id for inline jev.
+ * Commit a secret value to the store under a name derived from the address.
+ * Returns the chosen name on success, undefined on failure (the wizard treats
+ * undefined as user cancellation).
  */
 function commitSecret(ctx: DialogueContext, session: DialogueSession, hint: string, value: string): string | undefined {
 	const name = secretNameFor(hint);
@@ -562,64 +566,19 @@ function commitSecret(ctx: DialogueContext, session: DialogueSession, hint: stri
 	}
 }
 
-/** Patch fields for an EXISTING decision model. Undefined = user backed out. */
-async function collectJevPatch(
-	ctx: DialogueContext,
-	session: DialogueSession,
-	current: DecisionModelEntry,
-): Promise<DecisionModelPatch | undefined> {
-	const option = await chooseClassifierProvider(ctx, session, current.provider);
-	if (option === undefined) return undefined;
-	const patch: DecisionModelPatch = {};
-	if (option.provider !== current.provider) patch.provider = option.provider;
-	const baseUrl = await chooseBaseUrl(ctx, session, option, current.baseUrl);
-	if (baseUrl === undefined) return undefined;
-	const id = await chooseClassifierModel(ctx, session, option, current.id, baseUrl ?? option.baseUrl);
-	if (id === undefined) return undefined;
-	if (id !== current.id) patch.id = id;
-	if (baseUrl === null) {
-		// updateDecisionModel clears api/apiKey with baseUrl (loader rule: they require it).
-		patch.baseUrl = null;
-		return patch;
-	}
-	patch.baseUrl = baseUrl;
-	// Keep the entry's own api, or set the endpoint's for a newly added one.
-	if (current.api === undefined) {
-		const api = option.api ?? LOCAL_CLASSIFIER_APIS[0];
-		if (api !== undefined) patch.api = api;
-	}
-	const key = await apiKeyAction(ctx, session, current.apiKey, current.name);
-	if (key.kind === "cancel") return undefined;
-	if (key.kind === "none") patch.apiKeySecretName = null;
-	else if (key.kind === "secret") {
-		const committedName = commitSecret(ctx, session, current.name, key.value);
-		if (committedName === undefined) return undefined;
-		patch.apiKeySecretName = committedName;
-	}
-	return patch;
-}
-/** Resolve a `secret:<name>` reference for use (the probe needs the real token). */
-function resolveSecretRef(jev: JevConfig, session: DialogueSession): JevConfig {
-	const apiKey = jev.apiKey;
-	if (apiKey === undefined || !apiKey.startsWith("secret:")) return jev;
-	const stored = session.secrets.get(apiKey.slice("secret:".length));
-	return stored === undefined ? jev : { ...jev, apiKey: stored };
-}
-
 /**
  * What the user decided about the API key.
  *
- * `keep` leaves the field untouched (an existing key stays), `none` means "no
- * key" (a new entry gets none, an existing one loses it), `secret` names the
- * store entry to reference, and `cancel` abandons the whole step. Collapsing
- * these into one nullable string made "no key" indistinguishable from "back
- * out", which turned a valid choice into an aborted wizard.
+ * `keep` leaves the field untouched (an existing key stays), `local` means "no
+ * secret - a local endpoint ignores the bearer token", `new` carries a value to
+ * store under a derived name, `existing` names a stored secret to reference,
+ * and `cancel` abandons the whole step.
  */
 type ApiKeyAction =
 	| { kind: "keep" }
-	| { kind: "none" }
-	/** Value picked up; the wizard commits it under a name it derives later. */
-	| { kind: "secret"; value: string }
+	| { kind: "local" }
+	| { kind: "new"; value: string }
+	| { kind: "existing"; name: string }
 	| { kind: "cancel" };
 
 /**
@@ -635,20 +594,20 @@ async function apiKeyAction(
 	current: string | undefined,
 	hint: string,
 ): Promise<ApiKeyAction> {
-	const hasCurrent = current !== undefined;
+	const hasCurrent = current !== undefined && current !== "local";
 	const keepOption = hasCurrent
 		? `Keep current (${current.startsWith("secret:") ? current : "value set by hand"})`
-		: "(no API key)";
+		: "(no API key - local endpoint)";
 	const existingOption = "Use existing secret...";
 	const newOption = "New secret...";
-	const removeOption = "Remove API key";
+	const removeOption = "No secret (local endpoint)";
 	const choice = await ctx.ui.select(
 		screenTitle(session.loaded, "API key - stored encrypted; the config only carries secret:<name>"),
 		hasCurrent ? [keepOption, existingOption, newOption, removeOption] : [keepOption, existingOption, newOption],
 	);
 	if (choice === undefined) return { kind: "cancel" };
-	if (choice === keepOption) return hasCurrent ? { kind: "keep" } : { kind: "none" };
-	if (choice === removeOption) return { kind: "none" };
+	if (choice === keepOption) return hasCurrent ? { kind: "keep" } : { kind: "local" };
+	if (choice === removeOption) return { kind: "local" };
 	if (choice === existingOption) {
 		const names = session.secrets.list();
 		if (names.length === 0) {
@@ -656,7 +615,7 @@ async function apiKeyAction(
 			return { kind: "cancel" };
 		}
 		const name = await ctx.ui.select(screenTitle(session.loaded, "reference which stored secret?"), [...names]);
-		return name === undefined ? { kind: "cancel" } : { kind: "secret", value: name };
+		return name === undefined ? { kind: "cancel" } : { kind: "existing", name };
 	}
 	if (choice !== newOption) return { kind: "cancel" }; // an option this flow does not know: back out
 	const value = await promptRequired(
@@ -668,5 +627,5 @@ async function apiKeyAction(
 		"secret value",
 	);
 	if (value === undefined) return { kind: "cancel" };
-	return { kind: "secret", value };
+	return { kind: "new", value };
 }

package/src/dialogue-ui.ts

@@ -12,8 +12,8 @@
  *    reverts exactly the failed action, and a model lookup,
  *  - every prompt (required, name-last, optional) in one place, so the wording
  *    of "a value is required" or "empty clears, Esc keeps" is defined once,
- *  - the two pure formatters that render a classifier for a menu
- *    (`describeJev`) or name its secret entry (`secretNameFor`).
+ *  - the two pure formatters that render a decision model for a menu
+ *    (`describeDecisionModel`) or name its secret entry (`secretNameFor`).
  *
  * It is a module of its own so the two halves can both depend on it without
  * importing each other.
@@ -25,7 +25,12 @@ import { loadLayer, readLayerConfig, saveLayer, type LoadedLayer } from "switchb
 import type { ClassifierProviderOption } from "switchback-core/classifier-catalog.ts";
 import type { ProbeResult } from "switchback-core/classifier-probe.ts";
 import type { SecretStore } from "./secrets.ts";
-import type { JevConfig, JevRef, SwitchbackConfig, SwitchbackFileConfig } from "switchback-core/types.ts";
+import type {
+	DecisionModelConfig,
+	DecisionModelId,
+	SwitchbackConfig,
+	SwitchbackFileConfig,
+} from "switchback-core/types.ts";
 
 /** The dialog surface the dialogue needs (a subset of pi's `ctx.ui`). */
 export interface DialogueUi {
@@ -56,19 +61,17 @@ export interface DialogueContext {
 	 * decision model. Supplied by the command handler, which has the model registry
 	 * and switchback's transport; absent means the test is not offered.
 	 */
-	probeClassifier?: (jev: JevConfig) => Promise<ProbeResult>;
+	probeClassifier?: (decisionModel: DecisionModelConfig) => Promise<ProbeResult>;
 }
 
 export interface DialogueSession {
 	loaded: LoadedLayer;
 	secrets: SecretStore;
 }
-/** Describe a model's classifier for menus: reference, inline, or none. */
-export function describeJev(jev: JevRef | undefined): string {
-	if (jev === undefined) return "(none - report and cycle)";
-	if ("decisionModel" in jev) return `decision model "${jev.decisionModel}"`;
-	const direct = jev.baseUrl !== undefined ? ` (direct: ${jev.baseUrl})` : "";
-	return `${jev.provider}/${jev.id}${direct}`;
+/** Describe a model's decision model for menus: its address, or none. */
+export function describeDecisionModel(decisionModel: DecisionModelId | undefined): string {
+	if (decisionModel === undefined) return "(none - report and cycle)";
+	return `decision model ${decisionModel}`;
 }
 export function errorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
@@ -145,29 +148,34 @@ export async function promptRequired(
 	}
 }
 /**
- * Name-last step of the decision-model wizard: the input arrives prefilled with
- * a derived default, empty input keeps the default, Esc aborts. A name already
- * in use is rejected with a warning and the prompt loops.
+ * Address-last step of the decision-model wizard: the input arrives prefilled
+ * with a derived `provider/model-id`, empty input keeps the default, Esc aborts.
+ * An address already in use, or one without a `/`, is rejected with a warning
+ * and the prompt loops.
  */
-export async function promptNameLast(
+export async function promptAddressLast(
 	ctx: DialogueContext,
 	loaded: LoadedLayer,
-	suggestedName: string,
-	knownNames: readonly string[],
+	suggestedAddress: string,
+	knownAddresses: readonly string[],
 ): Promise<string | undefined> {
 	for (;;) {
 		const value = await ctx.ui.input(
-			screenTitle(loaded, `new decision model - name (Enter keeps "${suggestedName}")`),
-			suggestedName,
+			screenTitle(loaded, `new decision model - address (Enter keeps "${suggestedAddress}")`),
+			suggestedAddress,
 		);
 		if (value === undefined) return undefined;
 		const trimmed = value.trim();
-		const name = trimmed.length === 0 ? suggestedName : trimmed;
-		if (knownNames.includes(name)) {
-			ctx.ui.notify(`a decision model named "${name}" already exists`, "warning");
+		const address = trimmed.length === 0 ? suggestedAddress : trimmed;
+		if (!address.includes("/")) {
+			ctx.ui.notify(`an address is "provider/model-id" - "${address}" has no provider`, "warning");
 			continue;
 		}
-		return name;
+		if (knownAddresses.includes(address)) {
+			ctx.ui.notify(`a decision model at "${address}" already exists`, "warning");
+			continue;
+		}
+		return address;
 	}
 }
 
@@ -188,7 +196,7 @@ export function findModel(config: SwitchbackFileConfig, id: string): SwitchbackC
 }
 /**
  * Secret names are an internal detail of the encrypted store, so the dialogue
- * derives one instead of asking: `ollama-key`, `local-jev-key`, and so on. A
+ * derives one instead of asking: `ollama-key`, `local-decisionModel-key`, and so on. A
  * second key for the same entry simply replaces the stored value under that name.
  */
 export function secretNameFor(hint: string): string {

package/src/dialogue.ts

@@ -51,7 +51,7 @@ import {
 } from "switchback-core/config-editor.ts";
 import { createSecretStore, type SecretStore } from "./secrets.ts";
 import {
-	describeJev,
+	describeDecisionModel,
 	errorMessage,
 	findModel,
 	promptRequired,
@@ -186,7 +186,7 @@ async function mainMenu(ctx: DialogueContext, session: DialogueSession): Promise
 		const options: string[] = config.models.map((m) => `${m.id} - ${m.name}`);
 		const addOption = "Add virtual model...";
 		const debugOption = `Toggle debug (currently ${config.debug === true ? "on" : "off"})`;
-		const dmOption = `Decision models (${config.decisionModels?.length ?? 0})...`;
+		const dmOption = `Decision models (${Object.keys(config.decisionModels ?? {}).length})...`;
 		const switchOption = "Switch layer...";
 		const doneOption = "Done";
 		options.push(addOption, debugOption, dmOption, switchOption, doneOption);
@@ -231,7 +231,8 @@ async function virtualModelMenu(
 	const renameIdOption = "Rename model id (pi restart required)";
 	const renameNameOption = "Change display name";
 	const editFallbacks = (n: number): string => `Edit fallbacks (${n})`;
-	const decisionOption = (config: SwitchbackConfig): string => `Decision model: ${describeJev(config.jev)}`;
+	const decisionOption = (config: SwitchbackConfig): string =>
+		`Decision model: ${describeDecisionModel(config.decisionModel)}`;
 	const removeOption = "Remove model";
 	const backOption = "Back";
 	for (;;) {

package/src/index.ts

@@ -10,7 +10,7 @@
 export * from "switchback-core";
 export { buildRoute, ConfigInvalidError } from "./build-route.ts";
 export { runDialogue, layerOptionLabel } from "./dialogue.ts";
-export { describeJev } from "./dialogue-ui.ts";
+export { describeDecisionModel } from "./dialogue-ui.ts";
 export { createModelPicker, buildModelItems, MODEL_PICKER_MAX_VISIBLE } from "./model-picker.ts";
 export type { ModelPickerSource, PickerColor, PickerKeybindings, PickerTheme, PickerTui } from "./model-picker.ts";
 export type { DialogueContext, DialogueUi } from "./dialogue-ui.ts";

package/src/local-classifier.ts

@@ -8,8 +8,8 @@
  * one (its schema has no classifier model type). So switchback declares the
  * endpoint itself, from its own config.
  *
- * `jev.baseUrl` in `switchback.yaml` is the switch. When present, switchback
- * registers `jev.provider` with the classifier model(s) for that endpoint and
+ * `decisionModel.baseUrl` in `switchback.yaml` is the switch. When present, switchback
+ * registers `decisionModel.provider` with the classifier model(s) for that endpoint and
  * its own System One transport (packages/core/src/systemone.ts), so the normal
  * `ctx.modelRegistry.classify()` path - block map, Tier 2b annotation cache,
  * reset scoring - works unchanged.
@@ -39,7 +39,7 @@
 import type { ClassifierApi, ClassifierModel } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { SYSTEM_ONE_API, systemOneClassifier } from "switchback-core/systemone.ts";
-import type { JevConfig } from "switchback-core/types.ts";
+import type { DecisionModelConfig } from "switchback-core/types.ts";
 
 /** The only System One wire protocol switchback drives directly today. */
 export const LOCAL_CLASSIFIER_API = SYSTEM_ONE_API;
@@ -52,8 +52,8 @@ export const LOCAL_CLASSIFIER_API = SYSTEM_ONE_API;
 const LOCAL_CLASSIFIER_CONTEXT_WINDOW = 32_768;
 
 /** True when the classifier block names its own endpoint instead of a pi catalog entry. */
-export function isLocalClassifier(jev: JevConfig | undefined): boolean {
-	return jev?.baseUrl !== undefined;
+export function isLocalClassifier(decisionModel: DecisionModelConfig | undefined): boolean {
+	return decisionModel?.baseUrl !== undefined;
 }
 
 /** One direct endpoint and every classifier model that lives on it. */
@@ -68,7 +68,7 @@ export interface LocalClassifierEndpoint {
 	 */
 	apiKey: string;
 	/** Distinct classifier models to register under this provider. */
-	models: readonly JevConfig[];
+	models: readonly DecisionModelConfig[];
 }
 
 /**
@@ -80,14 +80,21 @@ export interface LocalClassifierEndpoint {
  * model id collapses to one entry - the same classifier is often named by
  * several virtual models, and by a `decisionModels` entry as well.
  */
-export function groupLocalEndpoints(jevs: readonly JevConfig[]): LocalClassifierEndpoint[] {
-	const byEndpoint = new Map<string, { provider: string; baseUrl: string; apiKey?: string; models: JevConfig[] }>();
-	for (const jev of jevs) {
-		if (jev.baseUrl === undefined) continue;
-		const key = `${jev.provider}|${jev.baseUrl}`;
-		const group = byEndpoint.get(key) ?? { provider: jev.provider, baseUrl: jev.baseUrl, models: [] };
-		if (group.apiKey === undefined && jev.apiKey !== undefined) group.apiKey = jev.apiKey;
-		if (!group.models.some((model) => model.id === jev.id)) group.models.push(jev);
+export function groupLocalEndpoints(jevs: readonly DecisionModelConfig[]): LocalClassifierEndpoint[] {
+	const byEndpoint = new Map<
+		string,
+		{ provider: string; baseUrl: string; apiKey?: string; models: DecisionModelConfig[] }
+	>();
+	for (const decisionModel of jevs) {
+		if (decisionModel.baseUrl === undefined) continue;
+		const key = `${decisionModel.provider}|${decisionModel.baseUrl}`;
+		const group = byEndpoint.get(key) ?? {
+			provider: decisionModel.provider,
+			baseUrl: decisionModel.baseUrl,
+			models: [],
+		};
+		if (group.apiKey === undefined && decisionModel.apiKey !== undefined) group.apiKey = decisionModel.apiKey;
+		if (!group.models.some((model) => model.id === decisionModel.id)) group.models.push(decisionModel);
 		byEndpoint.set(key, group);
 	}
 	return [...byEndpoint.values()].map((group) => ({
@@ -105,10 +112,10 @@ export function groupLocalEndpoints(jevs: readonly JevConfig[]): LocalClassifier
  */
 export function registerLocalClassifier(pi: ExtensionAPI, endpoint: LocalClassifierEndpoint): void {
 	const { provider, baseUrl, apiKey } = endpoint;
-	const models: ClassifierModel<ClassifierApi>[] = endpoint.models.map((jev) => ({
+	const models: ClassifierModel<ClassifierApi>[] = endpoint.models.map((decisionModel) => ({
 		type: "classifier",
-		id: jev.id,
-		name: `${jev.id} (switchback local classifier)`,
+		id: decisionModel.id,
+		name: `${decisionModel.id} (switchback local classifier)`,
 		api: LOCAL_CLASSIFIER_API,
 		provider,
 		baseUrl,