proxitor 0.11.0 → 0.12.0

package/README.md

@@ -111,6 +111,16 @@ While proxitor runs, it logs cache usage from upstream so you can see whether ca
 
 Quick health poke: `curl http://localhost:8828/health`.
 
+### Tuning the cache
+
+If the cache hit looks low, three levers fix it — tune them from `proxitor config` → **💾 Caching** (or `proxitor config cache`):
+
+- **`cacheControl`** — inject `cache_control` to activate caching (Anthropic-native).
+- **`sessionId`** — inject `session_id` so the provider pins from the first request.
+- **`normalizeVolatileSystem`** — strip Claude Code's volatile `cch` hash so the prefix cache warms on non-Anthropic providers (qwen/glm/…).
+
+See the [configuration reference](./docs/configuration.md#prompt-caching) for the full detail.
+
 ## Commands
 
 | Command | Description |

package/dist/cli.mjs

@@ -4,7 +4,7 @@ import process$1, { stdin, stdout } from "node:process";
 import os, { homedir } from "node:os";
 import * as tty$1 from "node:tty";
 import tty, { ReadStream } from "node:tty";
-import { formatWithOptions, styleText } from "node:util";
+import { formatWithOptions, isDeepStrictEqual, styleText } from "node:util";
 import * as l$1 from "node:readline";
 import l__default from "node:readline";
 import { existsSync, mkdirSync, readFileSync, readdirSync, unwatchFile, watchFile, writeFileSync } from "node:fs";
@@ -16491,18 +16491,29 @@ function findConfigFile(explicitPath) {
 	if (found) return found;
 	throw new MissingConfigError(getConfigSearchPaths());
 }
-function readConfigFile(filePath) {
+function parseConfigFile(filePath) {
 	const content = readFileSync(filePath, "utf-8");
-	let raw;
 	try {
-		raw = filePath.endsWith(".json") ? JSON.parse(content) : (0, import_dist.parse)(content);
+		return filePath.endsWith(".json") ? JSON.parse(content) : (0, import_dist.parse)(content);
 	} catch (err) {
 		throw new ConfigParseError(filePath, err instanceof Error ? err : void 0);
 	}
-	const result = proxyConfigFileSchema.safeParse(raw);
+}
+function readConfigFile(filePath) {
+	const result = proxyConfigFileSchema.safeParse(parseConfigFile(filePath));
 	if (!result.success) throw new ConfigValidationError(filePath, result.error);
 	return result.data;
 }
+/**
+* Validated like readConfigFile, but schema defaults are NOT applied, so absent
+* keys stay undefined — use when "absent" must differ from "explicit default".
+*/
+function readConfigFileRaw(filePath) {
+	const raw = parseConfigFile(filePath);
+	const result = proxyConfigFileSchema.safeParse(raw);
+	if (!result.success) throw new ConfigValidationError(filePath, result.error);
+	return raw ?? {};
+}
 //#endregion
 //#region src/openrouter/cache.ts
 const CACHE_DIR = join(homedir(), ".cache", "proxitor");
@@ -17938,7 +17949,7 @@ async function askNormalizeVolatileSystem(message, current, opts) {
 	});
 	return await select({
 		message,
-		initialValue: current ?? false,
+		initialValue: current ?? (opts?.removable ? "reset" : false),
 		options
 	});
 }
@@ -17967,7 +17978,7 @@ async function askTriState(message, current, hints, opts) {
 	});
 	return await select({
 		message,
-		initialValue: current ?? "auto",
+		initialValue: current ?? (opts?.removable ? "reset" : "auto"),
 		options
 	});
 }
@@ -18003,7 +18014,7 @@ async function askCacheControlTtl(current, opts) {
 	});
 	return await select({
 		message: "Cache TTL",
-		initialValue: current ?? "5m",
+		initialValue: current ?? (opts?.removable ? "reset" : "5m"),
 		options
 	});
 }
@@ -18016,14 +18027,14 @@ function applyField(obj, key, field) {
 	else obj[key] = field.value;
 }
 async function collectSessionTriState(currentSid) {
-	const sid = await askTriState("Session ID mode", currentSid ?? "auto", SESSION_HINTS, { removable: true });
+	const sid = await askTriState("Session ID mode", currentSid, SESSION_HINTS, { removable: true });
 	if (typeof sid === "symbol") return null;
 	if (sid === "reset") return { sessionId: { remove: true } };
 	return { sessionId: { value: sid } };
 }
 /** TTL is independent of cache mode. Mode-cancel aborts; TTL-cancel keeps existing TTL. */
 async function collectCacheTriState(currentCc, currentTtl, globalTtl) {
-	const cc = await askTriState("Cache control mode", currentCc ?? "auto", CACHE_HINTS, { removable: true });
+	const cc = await askTriState("Cache control mode", currentCc, CACHE_HINTS, { removable: true });
 	if (typeof cc === "symbol") return null;
 	let cacheControl;
 	if (cc === "reset") cacheControl = { remove: true };
@@ -18318,30 +18329,116 @@ async function browseModelsCommand(client) {
 	});
 }
 //#endregion
-//#region src/commands/config/edit.ts
-function nvsHint(value) {
-	if (value === void 0) return "(inherit)";
+//#region src/commands/config/cache-control.ts
+async function cacheControlCommand(opts) {
+	const configPath = requireConfigPath(opts?.configPath);
+	const cfg = readConfigFileRaw(configPath);
+	const rawCc = cfg.cacheControl;
+	const rawTtl = cfg.cacheControlTtl;
+	const effectiveCc = rawCc ?? DEFAULTS.cacheControl;
+	log.info(`Current: cacheControl = ${rawCc === void 0 ? `(default -> ${effectiveCc})` : effectiveCc}`);
+	if (rawTtl) log.info(`Current: cacheControlTtl = ${rawTtl}`);
+	const cc = await askTriState("Cache control mode", rawCc, CACHE_HINTS, { removable: true });
+	if (typeof cc === "symbol") return;
+	const fields = {};
+	fields.cacheControl = cc === "reset" ? void 0 : cc;
+	const ttlResult = await askCacheControlTtl(rawTtl, { removable: true });
+	if (typeof ttlResult === "symbol") {
+		setGlobalConfigFields(configPath, fields);
+		log.success(`cacheControl set to ${cc === "reset" ? "(default)" : cc}`);
+		return;
+	}
+	fields.cacheControlTtl = ttlResult === "reset" ? void 0 : ttlResult;
+	setGlobalConfigFields(configPath, fields);
+	const ccLabel = cc === "reset" ? "(default)" : cc;
+	const ttlLabel = ttlResult === "reset" ? "(default)" : ttlResult;
+	log.success(`cacheControl set to ${ccLabel}, TTL = ${ttlLabel}`);
+}
+//#endregion
+//#region src/commands/config/caching-summary.ts
+/** Friendly TTL label (omit→strip, skip→passthrough). */
+function describeTtl(value) {
+	if (value === void 0) return "(default)";
+	if (value === "omit") return "strip";
+	if (value === "skip") return "passthrough";
+	return value;
+}
+/** Global NVS: distinguish absent (default-origin) from an explicit on/off. */
+function globalNvsLabel(value) {
+	if (value === void 0) return `(default -> ${DEFAULTS.normalizeVolatileSystem ? "on" : "off"})`;
 	return value ? "on" : "off";
 }
-function formatOverrideHint(override) {
-	if (!override) return "(empty)";
-	const parts = [];
-	if (override.provider) {
-		const keys = Object.keys(override.provider);
-		parts.push(`provider: ${keys.join(", ")}`);
-	}
-	if (override.sessionId) parts.push(`session: ${override.sessionId}`);
-	if (override.cacheControl) parts.push(`cache: ${override.cacheControl}`);
-	if (override.normalizeVolatileSystem !== void 0) parts.push(`normalize: ${nvsHint(override.normalizeVolatileSystem)}`);
-	if (override.headers) parts.push(`${Object.keys(override.headers).length} header(s)`);
-	return parts.join(", ") || "(empty)";
+/** Global tri-state: distinguish absent (default-origin) from an explicit mode. */
+function globalTriStateLabel(value, fallback) {
+	return value === void 0 ? `(default -> ${fallback})` : value;
 }
-function formatCacheHint(cc, ttl) {
-	let ttlLabel = ttl ?? "";
-	if (ttl === "omit") ttlLabel = "ttl strip";
-	else if (ttl === "skip") ttlLabel = "ttl passthrough";
-	return [cc, ttlLabel].filter(Boolean).join(", ") || "(inherit)";
+function nvsLabel(value, globalValue) {
+	if (value === void 0) return `(inherit -> ${globalValue ? "on" : "off"})`;
+	return value ? "on" : "off";
+}
+function perModelTtl(current, globalCfg) {
+	if (current.cacheControlTtl !== void 0) return describeTtl(current.cacheControlTtl);
+	if (globalCfg.cacheControlTtl !== void 0) return `(inherit -> ${describeTtl(globalCfg.cacheControlTtl)})`;
+	return "(inherit)";
+}
+function formatGlobalCachingSummary(cfg) {
+	const cc = globalTriStateLabel(cfg.cacheControl, DEFAULTS.cacheControl);
+	const sid = globalTriStateLabel(cfg.sessionId, DEFAULTS.sessionId);
+	const nvs = globalNvsLabel(cfg.normalizeVolatileSystem);
+	return [
+		"Three settings shape the request so cache survives.",
+		"",
+		`  cacheControl            = ${cc}    (activate cache)`,
+		`  cacheControlTtl         = ${describeTtl(cfg.cacheControlTtl)}`,
+		`  sessionId               = ${sid}    (pin provider)`,
+		`  normalizeVolatileSystem = ${nvs}     (stable prefix)`,
+		"",
+		"Anthropic -> levers 1+2 - non-Anthropic (qwen/glm) -> all 3"
+	].join("\n");
+}
+function formatPerModelCachingSummary(modelKey, current, globalCfg) {
+	const gCc = globalCfg.cacheControl ?? DEFAULTS.cacheControl;
+	const gSid = globalCfg.sessionId ?? DEFAULTS.sessionId;
+	const gNvs = globalCfg.normalizeVolatileSystem ?? DEFAULTS.normalizeVolatileSystem;
+	const cc = current.cacheControl ?? `(inherit -> ${gCc})`;
+	const ttl = perModelTtl(current, globalCfg);
+	const sid = current.sessionId ?? `(inherit -> ${gSid})`;
+	const nvs = nvsLabel(current.normalizeVolatileSystem, gNvs);
+	return [
+		`Caching for "${modelKey}"`,
+		"",
+		`  cacheControl            = ${cc}`,
+		`  cacheControlTtl         = ${ttl}`,
+		`  sessionId               = ${sid}`,
+		`  normalizeVolatileSystem = ${nvs}`
+	].join("\n");
 }
+//#endregion
+//#region src/commands/config/equality.ts
+/** Deep equality for overrides — gates no-op writes. */
+function overridesEqual(a, b) {
+	return isDeepStrictEqual(a, b);
+}
+//#endregion
+//#region src/commands/config/normalize-system.ts
+async function normalizeVolatileSystemCommand(opts) {
+	const configPath = requireConfigPath(opts?.configPath);
+	const raw = readConfigFileRaw(configPath).normalizeVolatileSystem;
+	const effective = raw ?? DEFAULTS.normalizeVolatileSystem;
+	log.info(`Current: normalizeVolatileSystem = ${raw === void 0 ? `(default -> ${effective ? "on" : "off"})` : effective}`);
+	const choice = await askNormalizeVolatileSystem("Normalize Claude Code's volatile cch hash in the system prompt? Stabilizes the prefix cache for non-Anthropic providers (qwen/glm/etc.).", raw, {
+		removable: true,
+		resetHint: `remove (default: ${DEFAULTS.normalizeVolatileSystem})`
+	});
+	if (typeof choice === "symbol") return;
+	const fields = {};
+	fields.normalizeVolatileSystem = choice === "reset" ? void 0 : choice;
+	setGlobalConfigFields(configPath, fields);
+	const label = choice === "reset" ? `(default: ${DEFAULTS.normalizeVolatileSystem})` : choice;
+	log.success(`normalizeVolatileSystem set to ${label}`);
+}
+//#endregion
+//#region src/commands/config/override-levers.ts
 function readGlobalTtl(configPath) {
 	if (!configPath) return void 0;
 	try {
@@ -18350,32 +18447,6 @@ function readGlobalTtl(configPath) {
 		return;
 	}
 }
-function showCurrentConfig(modelKey, current) {
-	log.info(`Current config for "${modelKey}":`);
-	if (current.provider) for (const [field, value] of Object.entries(current.provider)) log.info(`  provider.${field}: ${JSON.stringify(value)}`);
-	if (current.sessionId) log.info(`  sessionId: ${current.sessionId}`);
-	if (current.cacheControl) log.info(`  cacheControl: ${current.cacheControl}`);
-	if (current.cacheControlTtl) log.info(`  cacheControlTtl: ${current.cacheControlTtl}`);
-	if (current.normalizeVolatileSystem !== void 0) log.info(`  normalizeVolatileSystem: ${current.normalizeVolatileSystem}`);
-	if (current.headers) for (const [name, value] of Object.entries(current.headers)) log.info(`  headers.${name}: ${value}`);
-}
-async function editProvider(modelKey, current, client) {
-	const isPattern = modelKey.includes("*");
-	const mode = await selectRoutingMode("Routing mode");
-	if (isCancel(mode)) return current;
-	if (mode === "skip") {
-		const { provider: _, ...rest } = current;
-		return rest;
-	}
-	const providerOptions = await fetchProvidersForModel(client, modelKey, isPattern);
-	if (!providerOptions) return current;
-	const result = await selectProvidersByMode(mode, providerOptions);
-	if (!result) return current;
-	return {
-		...current,
-		provider: result.provider
-	};
-}
 async function editSessionId(current) {
 	const result = await collectSessionTriState(current.sessionId);
 	if (result === null) return current;
@@ -18383,7 +18454,6 @@ async function editSessionId(current) {
 	applyField(next, "sessionId", result.sessionId);
 	return next;
 }
-/** @internal */
 async function editCacheControl(current, configPath) {
 	const globalTtl = readGlobalTtl(configPath);
 	const result = await collectCacheTriState(current.cacheControl, current.cacheControlTtl, globalTtl);
@@ -18393,7 +18463,6 @@ async function editCacheControl(current, configPath) {
 	applyField(next, "cacheControlTtl", result.cacheControlTtl);
 	return next;
 }
-/** @internal */
 async function editNormalizeVolatileSystem(current) {
 	const result = await collectNormalizeVolatileSystem(current.normalizeVolatileSystem);
 	if (result === null) return current;
@@ -18401,14 +18470,133 @@ async function editNormalizeVolatileSystem(current) {
 	applyField(next, "normalizeVolatileSystem", result.normalizeVolatileSystem);
 	return next;
 }
-async function applyFieldEdit(field, modelKey, current, client, configPath) {
-	switch (field) {
-		case "provider": return editProvider(modelKey, current, client);
-		case "sessionId": return editSessionId(current);
-		case "cacheControl": return editCacheControl(current, configPath);
-		case "normalizeVolatileSystem": return editNormalizeVolatileSystem(current);
-		default: return current;
+//#endregion
+//#region src/commands/config/session-routing.ts
+async function sessionRoutingCommand(opts) {
+	const configPath = requireConfigPath(opts?.configPath);
+	const raw = readConfigFileRaw(configPath).sessionId;
+	const effective = raw ?? DEFAULTS.sessionId;
+	log.info(`Current: sessionId = ${raw === void 0 ? `(default -> ${effective})` : effective}`);
+	const result = await askTriState("Session routing mode", raw, SESSION_HINTS, { removable: true });
+	if (typeof result === "symbol") return;
+	if (result === "reset") {
+		setGlobalConfigField(configPath, "sessionId", void 0);
+		log.success("sessionId reset to default (auto)");
+		return;
+	}
+	setGlobalConfigField(configPath, "sessionId", result);
+	log.success(`sessionId set to ${result}`);
+}
+//#endregion
+//#region src/commands/config/caching-menu.ts
+/** Cache levers: option list + dispatch in one table. */
+const CACHING_LEVERS = [
+	{
+		value: "cacheControl",
+		label: "Activate caching — mode + TTL (cacheControl)",
+		global: (configPath) => cacheControlCommand({ configPath }),
+		perModel: (current, configPath) => editCacheControl(current, configPath)
+	},
+	{
+		value: "sessionId",
+		label: "Pin provider (sessionId)",
+		global: (configPath) => sessionRoutingCommand({ configPath }),
+		perModel: (current) => editSessionId(current)
+	},
+	{
+		value: "normalizeVolatileSystem",
+		label: "Stabilize prefix (normalizeVolatileSystem)",
+		global: (configPath) => normalizeVolatileSystemCommand({ configPath }),
+		perModel: (current) => editNormalizeVolatileSystem(current)
+	}
+];
+async function runCachingLeverMenu(opts) {
+	for (;;) {
+		note(opts.renderNote(), opts.noteTitle);
+		const choice = await select({
+			message: "Tune which lever?",
+			options: [...CACHING_LEVERS.map((lever) => ({
+				value: lever.value,
+				label: lever.label
+			})), {
+				value: "back",
+				label: opts.backLabel
+			}]
+		});
+		if (isCancel(choice) || choice === "back") return;
+		const chosen = CACHING_LEVERS.find((l) => l.value === choice);
+		if (chosen) await opts.onLever(chosen);
+	}
+}
+async function globalCachingMenu(opts) {
+	const configPath = requireConfigPath(opts?.configPath);
+	await runCachingLeverMenu({
+		noteTitle: "Prompt caching",
+		backLabel: "← Back",
+		renderNote: () => formatGlobalCachingSummary(readConfigFileRaw(configPath)),
+		onLever: (lever) => lever.global(configPath)
+	});
+}
+/** Self-persists each lever; returns the latest override. */
+async function perModelCachingMenu(opts) {
+	let current = opts.current;
+	await runCachingLeverMenu({
+		noteTitle: `Caching for "${opts.modelKey}"`,
+		backLabel: "← Back to override edit",
+		renderNote: () => formatPerModelCachingSummary(opts.modelKey, current, readConfigFile(opts.configPath)),
+		onLever: async (lever) => {
+			const next = await lever.perModel(current, opts.configPath);
+			if (!overridesEqual(next, current)) {
+				setModelOverride(opts.configPath, opts.modelKey, next);
+				current = next;
+			}
+		}
+	});
+	return current;
+}
+async function cachingCommand(opts) {
+	intro("Proxitor · Caching");
+	await globalCachingMenu(opts);
+	outro("Bye!");
+}
+//#endregion
+//#region src/commands/config/edit.ts
+function nvsHint(value) {
+	if (value === void 0) return "(inherit)";
+	return value ? "on" : "off";
+}
+function formatOverrideHint(override) {
+	if (!override) return "(empty)";
+	const parts = [];
+	if (override.provider) {
+		const keys = Object.keys(override.provider);
+		parts.push(`provider: ${keys.join(", ")}`);
+	}
+	if (override.sessionId) parts.push(`session: ${override.sessionId}`);
+	if (override.cacheControl) parts.push(`cache: ${override.cacheControl}`);
+	if (override.normalizeVolatileSystem !== void 0) parts.push(`normalize: ${nvsHint(override.normalizeVolatileSystem)}`);
+	if (override.headers) parts.push(`${Object.keys(override.headers).length} header(s)`);
+	return parts.join(", ") || "(empty)";
+}
+function formatCachingHint(current) {
+	return `cc ${current.cacheControl ?? "inherit"} · ttl ${current.cacheControlTtl ? describeTtl(current.cacheControlTtl) : "inherit"} · sid ${current.sessionId ?? "inherit"} · nvs ${nvsHint(current.normalizeVolatileSystem)}`;
+}
+async function editProvider(modelKey, current, client) {
+	const isPattern = modelKey.includes("*");
+	const mode = await selectRoutingMode("Routing mode");
+	if (isCancel(mode)) return current;
+	if (mode === "skip") {
+		const { provider: _, ...rest } = current;
+		return rest;
 	}
+	const providerOptions = await fetchProvidersForModel(client, modelKey, isPattern);
+	if (!providerOptions) return current;
+	const result = await selectProvidersByMode(mode, providerOptions);
+	if (!result) return current;
+	return {
+		...current,
+		provider: result.provider
+	};
 }
 /** Run the interactive "Edit model override" flow. */
 async function editOverrideCommand(client, configPath) {
@@ -18432,7 +18620,6 @@ async function editOverrideCommand(client, configPath) {
 	if (isCancel(selected)) return;
 	const modelKey = selected;
 	let current = overrides[modelKey] ?? {};
-	showCurrentConfig(modelKey, current);
 	for (;;) {
 		const field = await select({
 			message: "Edit which field?",
@@ -18443,19 +18630,9 @@ async function editOverrideCommand(client, configPath) {
 					hint: formatOverrideHint({ provider: current.provider })
 				},
 				{
-					value: "sessionId",
-					label: "Session ID",
-					hint: current.sessionId ?? "(inherit)"
-				},
-				{
-					value: "cacheControl",
-					label: "Cache control",
-					hint: formatCacheHint(current.cacheControl, current.cacheControlTtl)
-				},
-				{
-					value: "normalizeVolatileSystem",
-					label: "Normalize volatile system",
-					hint: nvsHint(current.normalizeVolatileSystem)
+					value: "caching",
+					label: "💾 Caching",
+					hint: formatCachingHint(current)
 				},
 				{
 					value: "done",
@@ -18464,15 +18641,19 @@ async function editOverrideCommand(client, configPath) {
 			]
 		});
 		if (isCancel(field) || field === "done") break;
-		current = await applyFieldEdit(field, modelKey, current, client, resolvedConfigPath);
-	}
-	const save = await confirm({ message: "Save changes?" });
-	if (isCancel(save) || !save) {
-		outro("Cancelled");
-		return;
+		if (field === "caching") {
+			current = await perModelCachingMenu({
+				modelKey,
+				current,
+				configPath: resolvedConfigPath
+			});
+			continue;
+		}
+		const before = current;
+		current = await editProvider(modelKey, current, client);
+		if (!overridesEqual(current, before)) setModelOverride(resolvedConfigPath, modelKey, current);
 	}
-	setModelOverride(resolvedConfigPath, modelKey, current);
-	outro("✓ Override updated");
+	outro("✓ Done");
 }
 //#endregion
 //#region src/commands/config/list.ts
@@ -18998,31 +19179,6 @@ async function runWizard(opts = {}) {
 	}
 }
 //#endregion
-//#region src/commands/config/cache-control.ts
-async function cacheControlCommand(opts) {
-	const configPath = requireConfigPath(opts?.configPath);
-	const cfg = readConfigFile(configPath);
-	const currentCc = cfg.cacheControl ?? DEFAULTS.cacheControl;
-	const currentTtl = cfg.cacheControlTtl;
-	log.info(`Current: cacheControl = ${currentCc}`);
-	if (currentTtl) log.info(`Current: cacheControlTtl = ${currentTtl}`);
-	const cc = await askTriState("Cache control mode", currentCc, CACHE_HINTS, { removable: true });
-	if (typeof cc === "symbol") return;
-	const fields = {};
-	fields.cacheControl = cc === "reset" ? void 0 : cc;
-	const ttlResult = await askCacheControlTtl(currentTtl, { removable: true });
-	if (typeof ttlResult === "symbol") {
-		setGlobalConfigFields(configPath, fields);
-		log.success(`cacheControl set to ${cc === "reset" ? "(default)" : cc}`);
-		return;
-	}
-	fields.cacheControlTtl = ttlResult === "reset" ? void 0 : ttlResult;
-	setGlobalConfigFields(configPath, fields);
-	const ccLabel = cc === "reset" ? "(default)" : cc;
-	const ttlLabel = ttlResult === "reset" ? "(default)" : ttlResult;
-	log.success(`cacheControl set to ${ccLabel}, TTL = ${ttlLabel}`);
-}
-//#endregion
 //#region src/commands/config/connection.ts
 const FIELD_MAP = {
 	apiKey: {
@@ -19096,39 +19252,6 @@ async function connectionMenuCommand(opts) {
 	log.success(`${entry.label} updated`);
 }
 //#endregion
-//#region src/commands/config/normalize-system.ts
-async function normalizeVolatileSystemCommand(opts) {
-	const configPath = requireConfigPath(opts?.configPath);
-	const current = readConfigFile(configPath).normalizeVolatileSystem ?? DEFAULTS.normalizeVolatileSystem;
-	log.info(`Current: normalizeVolatileSystem = ${current}`);
-	const choice = await askNormalizeVolatileSystem("Normalize Claude Code's volatile cch hash in the system prompt? Stabilizes the prefix cache for non-Anthropic providers (qwen/glm/etc.).", current, {
-		removable: true,
-		resetHint: `remove (default: ${DEFAULTS.normalizeVolatileSystem})`
-	});
-	if (typeof choice === "symbol") return;
-	const fields = {};
-	fields.normalizeVolatileSystem = choice === "reset" ? void 0 : choice;
-	setGlobalConfigFields(configPath, fields);
-	const label = choice === "reset" ? `(default: ${DEFAULTS.normalizeVolatileSystem})` : choice;
-	log.success(`normalizeVolatileSystem set to ${label}`);
-}
-//#endregion
-//#region src/commands/config/session-routing.ts
-async function sessionRoutingCommand(opts) {
-	const configPath = requireConfigPath(opts?.configPath);
-	const current = readConfigFile(configPath).sessionId ?? DEFAULTS.sessionId;
-	log.info(`Current: sessionId = ${current}`);
-	const result = await askTriState("Session routing mode", current, SESSION_HINTS, { removable: true });
-	if (typeof result === "symbol") return;
-	if (result === "reset") {
-		setGlobalConfigField(configPath, "sessionId", void 0);
-		log.success("sessionId reset to default (auto)");
-		return;
-	}
-	setGlobalConfigField(configPath, "sessionId", result);
-	log.success(`sessionId set to ${result}`);
-}
-//#endregion
 //#region src/commands/config.ts
 async function runConfigMenu(client) {
 	intro("Proxitor Config Manager");
@@ -19150,16 +19273,8 @@ async function runConfigMenu(client) {
 					label: "🔑  API key & connection"
 				},
 				{
-					value: "session",
-					label: "🔗  Session routing"
-				},
-				{
-					value: "cache",
-					label: "💾  Cache control"
-				},
-				{
-					value: "normalize",
-					label: "🧹  Normalize volatile system"
+					value: "caching",
+					label: "💾  Caching"
 				},
 				{
 					value: "_sep2",
@@ -19212,14 +19327,8 @@ async function runConfigMenu(client) {
 			case "connection":
 				await connectionMenuCommand();
 				break;
-			case "session":
-				await sessionRoutingCommand();
-				break;
-			case "cache":
-				await cacheControlCommand();
-				break;
-			case "normalize":
-				await normalizeVolatileSystemCommand();
+			case "caching":
+				await globalCachingMenu();
 				break;
 			case "add":
 				await addOverrideCommand({ client });
@@ -19244,7 +19353,7 @@ async function runConfigMenu(client) {
 }
 //#endregion
 //#region src/version.ts
-const version = "0.11.0";
+const version = "0.12.0";
 //#endregion
 //#region src/commands/doctor.ts
 const DEFAULT_TIMEOUT_MS = 3e3;
@@ -19497,11 +19606,15 @@ function fmt(value) {
 	if (value === false) return "off";
 	return String(value);
 }
-const SCALAR_KEYS = [
+/** Cache-lever keys shared by global config + per-model overrides. */
+const CACHE_LEVER_KEYS = [
 	"cacheControl",
 	"cacheControlTtl",
 	"sessionId",
-	"normalizeVolatileSystem",
+	"normalizeVolatileSystem"
+];
+const SCALAR_KEYS = [
+	...CACHE_LEVER_KEYS,
 	"authType",
 	"verbose",
 	"bodyLimit",
@@ -19511,16 +19624,37 @@ function canonicalEntries(record) {
 	if (!record) return "";
 	return JSON.stringify(Object.keys(record).sort().map((key) => [key, record[key]]));
 }
+/** Field-level diff for a single model override; '' if nothing changed. */
+function overrideFieldDiff(prev, next) {
+	const parts = [];
+	for (const key of CACHE_LEVER_KEYS) if (prev?.[key] !== next?.[key]) parts.push(`${key}: ${fmt(prev?.[key])}→${fmt(next?.[key])}`);
+	if (JSON.stringify(buildProviderRouting(prev?.provider)) !== JSON.stringify(buildProviderRouting(next?.provider))) parts.push("provider routing");
+	if (canonicalEntries(prev?.headers) !== canonicalEntries(next?.headers)) parts.push("headers");
+	return parts.join(", ");
+}
+/** Per-override diff: +added, -removed, `key (fields)` for modified; '' if unchanged. */
+function summarizeModelOverridesDiff(prev, next) {
+	const prevKeys = new Set(Object.keys(prev ?? {}));
+	const nextKeys = new Set(Object.keys(next ?? {}));
+	const parts = [];
+	for (const key of [...new Set([...prevKeys, ...nextKeys])].sort()) {
+		const inPrev = prevKeys.has(key);
+		const inNext = nextKeys.has(key);
+		if (inPrev && inNext) {
+			const fields = overrideFieldDiff(prev?.[key], next?.[key]);
+			if (fields) parts.push(`${key} (${fields})`);
+		} else if (inNext) parts.push(`+${key}`);
+		else parts.push(`-${key}`);
+	}
+	return parts.join(", ");
+}
 /** Diff of cache-relevant fields; '' if nothing changed. */
 function summarizeChanges(prev, next) {
 	const parts = [];
 	for (const key of SCALAR_KEYS) if (prev[key] !== next[key]) parts.push(`${key}: ${fmt(prev[key])}→${fmt(next[key])}`);
 	if (JSON.stringify(buildProviderRouting(prev.provider)) !== JSON.stringify(buildProviderRouting(next.provider))) parts.push("provider routing");
-	if (canonicalEntries(prev.modelOverrides) !== canonicalEntries(next.modelOverrides)) {
-		const prevCount = prev.modelOverrides ? Object.keys(prev.modelOverrides).length : 0;
-		const nextCount = next.modelOverrides ? Object.keys(next.modelOverrides).length : 0;
-		parts.push(`modelOverrides: ${prevCount}→${nextCount}`);
-	}
+	const overridesDiff = summarizeModelOverridesDiff(prev.modelOverrides, next.modelOverrides);
+	if (overridesDiff) parts.push(`modelOverrides: ${overridesDiff}`);
 	if (canonicalEntries(prev.headers) !== canonicalEntries(next.headers)) parts.push("headers");
 	return parts.join(", ");
 }
@@ -23230,6 +23364,14 @@ const configCli = (0, import_cjs.subcommands)({
 				});
 			}
 		}),
+		cache: (0, import_cjs.command)({
+			name: "cache",
+			description: "Tune prompt-caching settings (interactive)",
+			args: { ...configArgs },
+			handler: async (args) => {
+				await cachingCommand({ configPath: args.configPath });
+			}
+		}),
 		edit: (0, import_cjs.command)({
 			name: "edit",
 			description: "Edit an existing model override (interactive)",