proxitor 0.11.0 → 0.13.0

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";
@@ -16251,6 +16251,7 @@ const modelOverrideSchema = object({
 	headers: record(string$1(), string$1()).optional(),
 	cacheControl: triStateSchema.optional(),
 	cacheControlTtl: ttlSchema.optional(),
+	rewriteBlockTtl: triStateSchema.optional(),
 	sessionId: triStateSchema.optional(),
 	normalizeVolatileSystem: boolean().optional()
 }).strict();
@@ -16269,6 +16270,7 @@ const proxyConfigSchema = object({
 	headers: record(string$1(), string$1()).optional(),
 	cacheControl: triStateSchema.default("auto"),
 	cacheControlTtl: ttlSchema.optional(),
+	rewriteBlockTtl: triStateSchema.default("skip"),
 	sessionId: triStateSchema.default("auto"),
 	normalizeVolatileSystem: boolean().default(false),
 	modelOverrides: record(string$1().min(1), modelOverrideSchema).optional()
@@ -16398,6 +16400,7 @@ function resolveModelConfig(config, modelName) {
 		headers: config.headers ? { ...config.headers } : void 0,
 		cacheControl: config.cacheControl,
 		cacheControlTtl: config.cacheControlTtl,
+		rewriteBlockTtl: config.rewriteBlockTtl,
 		sessionId: config.sessionId,
 		normalizeVolatileSystem: config.normalizeVolatileSystem
 	};
@@ -16427,6 +16430,7 @@ function applyOverride(result, override) {
 	};
 	if (override.cacheControl !== void 0) result.cacheControl = override.cacheControl;
 	if (override.cacheControlTtl !== void 0) result.cacheControlTtl = override.cacheControlTtl;
+	if (override.rewriteBlockTtl !== void 0) result.rewriteBlockTtl = override.rewriteBlockTtl;
 	if (override.sessionId !== void 0) result.sessionId = override.sessionId;
 	if (override.normalizeVolatileSystem !== void 0) result.normalizeVolatileSystem = override.normalizeVolatileSystem;
 }
@@ -16491,18 +16495,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");
@@ -17917,6 +17932,12 @@ const CACHE_HINTS = {
 	always: "All models",
 	skip: "Passthrough — leave client cache_control headers as-is"
 };
+/** Shared hint texts for the rewrite-block-ttl tri-state — used in cache-control command + override editor. */
+const REWRITE_HINTS = {
+	auto: "Anthropic models only — normalize blocks to match root",
+	always: "All models",
+	skip: "Leave client block ttl as-is (may mismatch root)"
+};
 const NORMALIZE_HINTS = {
 	on: "Rewrite cch → stable prefix cache",
 	off: "Passthrough — rewrite nothing"
@@ -17938,7 +17959,7 @@ async function askNormalizeVolatileSystem(message, current, opts) {
 	});
 	return await select({
 		message,
-		initialValue: current ?? false,
+		initialValue: current ?? (opts?.removable ? "reset" : false),
 		options
 	});
 }
@@ -17967,7 +17988,7 @@ async function askTriState(message, current, hints, opts) {
 	});
 	return await select({
 		message,
-		initialValue: current ?? "auto",
+		initialValue: current ?? (opts?.removable ? "reset" : "auto"),
 		options
 	});
 }
@@ -18003,7 +18024,7 @@ async function askCacheControlTtl(current, opts) {
 	});
 	return await select({
 		message: "Cache TTL",
-		initialValue: current ?? "5m",
+		initialValue: current ?? (opts?.removable ? "reset" : "5m"),
 		options
 	});
 }
@@ -18016,14 +18037,17 @@ 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 });
+/**
+* Collects cacheControl mode, TTL, and rewriteBlockTtl.
+* Mode-cancel aborts; TTL-cancel keeps existing TTL; rewrite-cancel keeps existing rewrite.
+*/
+async function collectCacheTriState(currentCc, currentTtl, globalTtl, currentRewrite) {
+	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 };
@@ -18032,14 +18056,19 @@ async function collectCacheTriState(currentCc, currentTtl, globalTtl) {
 		removable: true,
 		globalTtl
 	});
-	if (typeof ttl === "symbol") return { cacheControl };
-	if (ttl === "reset") return {
-		cacheControl,
-		cacheControlTtl: { remove: true }
-	};
+	let cacheControlTtl;
+	if (typeof ttl === "symbol") cacheControlTtl = void 0;
+	else if (ttl === "reset") cacheControlTtl = { remove: true };
+	else cacheControlTtl = { value: ttl };
+	const rewrite = await askTriState("Rewrite block TTLs", currentRewrite, REWRITE_HINTS, { removable: true });
+	let rewriteBlockTtl;
+	if (typeof rewrite === "symbol") rewriteBlockTtl = void 0;
+	else if (rewrite === "reset") rewriteBlockTtl = { remove: true };
+	else rewriteBlockTtl = { value: rewrite };
 	return {
 		cacheControl,
-		cacheControlTtl: { value: ttl }
+		cacheControlTtl,
+		rewriteBlockTtl
 	};
 }
 async function collectNormalizeVolatileSystem(currentNvs) {
@@ -18318,30 +18347,137 @@ 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
+/**
+* Map a ResolvedField into the `fields` object for `setGlobalConfigFields`:
+* {value}→assign value, {remove}→assign undefined (delete from disk),
+* undefined→omit the key (keep existing on disk).
+*
+* This is the file-write counterpart of `applyField`. The in-memory `applyField`
+* can `delete` an existing key, but a fresh `fields` object fed to
+* `setGlobalConfigFields` needs an explicit `undefined` value to trigger
+* removal — so keep-existing (undefined field) must be distinguished from
+* remove ({remove:true}) by omitting vs. assigning the key.
+*/
+function assignField(fields, key, field) {
+	if (field === void 0) return;
+	fields[key] = "remove" in field ? void 0 : field.value;
+}
+function fieldLabel(field, fallback) {
+	if (field === void 0) return fallback;
+	if ("remove" in field) return "(default)";
+	return String(field.value);
+}
+async function cacheControlCommand(opts) {
+	const configPath = requireConfigPath(opts?.configPath);
+	const cfg = readConfigFileRaw(configPath);
+	const rawCc = cfg.cacheControl;
+	const rawTtl = cfg.cacheControlTtl;
+	const rawRewrite = cfg.rewriteBlockTtl;
+	const effectiveCc = rawCc ?? DEFAULTS.cacheControl;
+	const effectiveRewrite = rawRewrite ?? DEFAULTS.rewriteBlockTtl;
+	log.info(`Current: cacheControl = ${rawCc === void 0 ? `(default -> ${effectiveCc})` : effectiveCc}`);
+	if (rawTtl) log.info(`Current: cacheControlTtl = ${rawTtl}`);
+	log.info(`Current: rewriteBlockTtl = ${rawRewrite === void 0 ? `(default -> ${effectiveRewrite})` : rawRewrite}`);
+	const result = await collectCacheTriState(rawCc, rawTtl, void 0, rawRewrite);
+	if (result === null) return;
+	const fields = {};
+	assignField(fields, "cacheControl", result.cacheControl);
+	assignField(fields, "cacheControlTtl", result.cacheControlTtl);
+	assignField(fields, "rewriteBlockTtl", result.rewriteBlockTtl);
+	setGlobalConfigFields(configPath, fields);
+	log.success(`cacheControl set to ${fieldLabel(result.cacheControl, effectiveCc)}, TTL = ${fieldLabel(result.cacheControlTtl, "(unchanged)")}, rewrite = ${fieldLabel(result.rewriteBlockTtl, effectiveRewrite)}`);
+}
+//#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 rewrite = globalTriStateLabel(cfg.rewriteBlockTtl, DEFAULTS.rewriteBlockTtl);
+	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)}`,
+		`  rewriteBlockTtl         = ${rewrite}    (normalize block ttl)`,
+		`  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 gRewrite = globalCfg.rewriteBlockTtl ?? DEFAULTS.rewriteBlockTtl;
+	const gSid = globalCfg.sessionId ?? DEFAULTS.sessionId;
+	const gNvs = globalCfg.normalizeVolatileSystem ?? DEFAULTS.normalizeVolatileSystem;
+	const cc = current.cacheControl ?? `(inherit -> ${gCc})`;
+	const ttl = perModelTtl(current, globalCfg);
+	const rewrite = current.rewriteBlockTtl ?? `(inherit -> ${gRewrite})`;
+	const sid = current.sessionId ?? `(inherit -> ${gSid})`;
+	const nvs = nvsLabel(current.normalizeVolatileSystem, gNvs);
+	return [
+		`Caching for "${modelKey}"`,
+		"",
+		`  cacheControl            = ${cc}`,
+		`  cacheControlTtl         = ${ttl}`,
+		`  rewriteBlockTtl         = ${rewrite}`,
+		`  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 +18486,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,17 +18493,16 @@ 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);
+	const result = await collectCacheTriState(current.cacheControl, current.cacheControlTtl, globalTtl, current.rewriteBlockTtl);
 	if (result === null) return current;
 	const next = { ...current };
 	applyField(next, "cacheControl", result.cacheControl);
 	applyField(next, "cacheControlTtl", result.cacheControlTtl);
+	applyField(next, "rewriteBlockTtl", result.rewriteBlockTtl);
 	return next;
 }
-/** @internal */
 async function editNormalizeVolatileSystem(current) {
 	const result = await collectNormalizeVolatileSystem(current.normalizeVolatileSystem);
 	if (result === null) return current;
@@ -18401,15 +18510,134 @@ 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) {
 	intro("Edit Model Override");
@@ -18432,7 +18660,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 +18670,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 +18681,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 +19219,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 +19292,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 +19313,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 +19367,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 +19393,7 @@ async function runConfigMenu(client) {
 }
 //#endregion
 //#region src/version.ts
-const version = "0.11.0";
+const version = "0.13.0";
 //#endregion
 //#region src/commands/doctor.ts
 const DEFAULT_TIMEOUT_MS = 3e3;
@@ -19497,11 +19646,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 +19664,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(", ");
 }
@@ -22771,6 +22945,56 @@ function buildCacheControl(existing, ttl, isAnthropic) {
 	}
 	return base;
 }
+/**
+* Whether to normalize block-level cache_control TTLs. Mirrors the cacheControl
+* tri-state: `auto` rewrites only when injection is active on an Anthropic-native
+* endpoint; `always` rewrites everywhere; `skip` never.
+*/
+function shouldRewriteBlockTtl(mode, cacheControlMode, modelName, path) {
+	if (mode === "skip") return false;
+	if (mode === "always") return true;
+	return isAnthropicEndpoint(modelName, path) && shouldInjectCacheControl(cacheControlMode, modelName, path);
+}
+/** Shallow, order-independent comparison of two cache_control objects. */
+function sameCacheControl(a, b) {
+	const ka = Object.keys(a);
+	const kb = Object.keys(b);
+	if (ka.length !== kb.length) return false;
+	return ka.every((k) => a[k] === b[k]);
+}
+/**
+* Normalize the TTL on every existing block-level cache_control breakpoint
+* (system, tools, messages[].content) to match the configured TTL. Reuses
+* buildCacheControl so block and root stay consistent. Adds no new breakpoints.
+* Returns whether any block was changed.
+*/
+function rewriteBlockTtls(body, ttl, isAnthropic) {
+	let mutated = false;
+	const rewriteNode = (obj) => {
+		const cc = obj.cache_control;
+		if (cc !== null && typeof cc === "object" && !Array.isArray(cc)) {
+			const next = buildCacheControl(cc, ttl, isAnthropic);
+			if (!sameCacheControl(cc, next)) {
+				obj.cache_control = next;
+				mutated = true;
+			}
+		}
+	};
+	const visitBlocks = (arr) => {
+		if (!Array.isArray(arr)) return;
+		for (const item of arr) {
+			if (item === null || typeof item !== "object" || Array.isArray(item)) continue;
+			const obj = item;
+			rewriteNode(obj);
+			visitBlocks(obj.content);
+		}
+	};
+	visitBlocks(body.system);
+	visitBlocks(body.tools);
+	const messages = body.messages;
+	for (const m of messages ?? []) visitBlocks(m?.content);
+	return mutated;
+}
 //#endregion
 //#region src/proxy/middleware/inject-cache-control.ts
 const injectCacheControl = createMiddleware(async (c, next) => {
@@ -22780,11 +23004,16 @@ const injectCacheControl = createMiddleware(async (c, next) => {
 		await next();
 		return;
 	}
+	const isAnthropic = isAnthropicEndpoint(c.var.modelName, c.req.path);
+	let mutated = false;
 	if (shouldInjectCacheControl(resolved.cacheControl, c.var.modelName, c.req.path)) {
-		const isAnthropic = isAnthropicEndpoint(c.var.modelName, c.req.path);
 		parsedBody.cache_control = buildCacheControl(parsedBody.cache_control, resolved.cacheControlTtl, isAnthropic);
-		c.set("bodyMutated", true);
+		mutated = true;
 	}
+	if (shouldRewriteBlockTtl(resolved.rewriteBlockTtl, resolved.cacheControl, c.var.modelName, c.req.path)) {
+		if (rewriteBlockTtls(parsedBody, resolved.cacheControlTtl, isAnthropic)) mutated = true;
+	}
+	if (mutated) c.set("bodyMutated", true);
 	await next();
 });
 //#endregion
@@ -23230,6 +23459,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)",