proxitor 0.10.1 → 0.12.0

package/dist/cli.mjs

@@ -4,10 +4,10 @@ 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, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unwatchFile, watchFile, writeFileSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 import { createServer } from "node:net";
 import { STATUS_CODES, createServer as createServer$1 } from "node:http";
@@ -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 nvsLabel(value, globalValue) {
+	if (value === void 0) return `(inherit -> ${globalValue ? "on" : "off"})`;
+	return value ? "on" : "off";
 }
-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 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,15 +18470,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 +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.10.1";
+const version = "0.12.0";
 //#endregion
 //#region src/commands/doctor.ts
 const DEFAULT_TIMEOUT_MS = 3e3;
@@ -19482,6 +19591,167 @@ async function doctorCommand(opts = {}) {
 	return exitCode;
 }
 //#endregion
+//#region src/config-source.ts
+/** Default watcher: fs.watchFile polling; returns a stop function. */
+const watchStat = (filename, pollIntervalMs, onChange) => {
+	watchFile(filename, {
+		interval: pollIntervalMs,
+		persistent: false
+	}, onChange);
+	return () => unwatchFile(filename);
+};
+function fmt(value) {
+	if (value === void 0) return "unset";
+	if (value === true) return "on";
+	if (value === false) return "off";
+	return String(value);
+}
+/** Cache-lever keys shared by global config + per-model overrides. */
+const CACHE_LEVER_KEYS = [
+	"cacheControl",
+	"cacheControlTtl",
+	"sessionId",
+	"normalizeVolatileSystem"
+];
+const SCALAR_KEYS = [
+	...CACHE_LEVER_KEYS,
+	"authType",
+	"verbose",
+	"bodyLimit",
+	"openrouterBaseUrl"
+];
+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");
+	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(", ");
+}
+function createConfigSource(options) {
+	return new FileWatchingConfigSource(options);
+}
+var FileWatchingConfigSource = class {
+	current;
+	loadOptions;
+	load;
+	pollIntervalMs;
+	watch;
+	boundHost;
+	boundPort;
+	resolvedPath;
+	stopWatch;
+	loading = false;
+	pending = false;
+	watching = false;
+	constructor(options) {
+		this.current = options.initial;
+		this.loadOptions = options.loadOptions;
+		this.load = options.load ?? loadConfig;
+		this.pollIntervalMs = options.pollIntervalMs ?? 1e3;
+		this.watch = options.watch ?? watchStat;
+		this.boundHost = options.initial.host;
+		this.boundPort = options.initial.port;
+		this.resolvedPath = options.loadOptions.noConfig ? null : tryFindConfigFile(options.loadOptions.configPath);
+	}
+	get() {
+		return this.current;
+	}
+	async reload() {
+		if (this.loading) {
+			this.pending = true;
+			return { ok: true };
+		}
+		this.loading = true;
+		try {
+			const next = await this.load(this.loadOptions);
+			const restartNeeded = next.host !== this.boundHost || next.port !== this.boundPort;
+			let diff = "";
+			try {
+				diff = summarizeChanges(this.current, next);
+			} catch {
+				diff = "";
+			}
+			this.current = next;
+			if (restartNeeded) logger.warn("host/port changed — restart proxitor to apply (live reload does not re-bind the socket)");
+			logger.info(`Config reloaded${diff ? ` — ${diff}` : " (no material changes)"}`);
+			return { ok: true };
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			logger.error(`Config reload failed — keeping previous config: ${msg}`);
+			return {
+				ok: false,
+				error: msg
+			};
+		} finally {
+			this.loading = false;
+			if (this.pending) {
+				this.pending = false;
+				this.reload();
+			}
+		}
+	}
+	start() {
+		if (this.watching) return;
+		if (!this.resolvedPath) {
+			logger.info("Live config reload disabled (no config file)");
+			return;
+		}
+		this.watching = true;
+		const path = this.resolvedPath;
+		this.stopWatch = this.watch(path, this.pollIntervalMs, (curr, prev) => {
+			try {
+				this.onStat(path, curr, prev);
+			} catch {}
+		});
+	}
+	onStat(path, curr, prev) {
+		if (curr.nlink === 0) {
+			logger.warn(`config file disappeared — keeping current config (${path})`);
+			return;
+		}
+		if (curr.mtimeMs === prev.mtimeMs) return;
+		this.reload();
+	}
+	stop() {
+		if (this.watching) {
+			this.stopWatch?.();
+			this.stopWatch = void 0;
+			this.watching = false;
+		}
+	}
+};
+//#endregion
 //#region node_modules/.pnpm/@hono+node-server@2.0.4_hono@4.12.25/node_modules/@hono/node-server/dist/index.mjs
 var RequestError = class extends Error {
 	constructor(message, options) {
@@ -22876,20 +23146,23 @@ const injectChain = [
 	normalizeVolatileSystemMiddleware,
 	injectSessionId
 ];
-function createProxyServer(config, onReady) {
+function createProxyServer(source, onReady) {
 	const app = new Hono();
-	const globalRouting = buildProviderRouting(config.provider);
-	const modelOverrideKeys = Object.keys(config.modelOverrides ?? []);
 	app.use("*", async (c, next) => {
-		c.set("config", config);
+		c.set("config", source.get());
 		await next();
 	});
-	app.get("/health", (c) => c.json({
-		ok: true,
-		upstream: config.openrouterBaseUrl,
-		provider: globalRouting ?? "not configured",
-		modelOverrides: modelOverrideKeys
-	}));
+	app.get("/health", (c) => {
+		const config = source.get();
+		const globalRouting = buildProviderRouting(config.provider);
+		const modelOverrideKeys = Object.keys(config.modelOverrides ?? []);
+		return c.json({
+			ok: true,
+			upstream: config.openrouterBaseUrl,
+			provider: globalRouting ?? "not configured",
+			modelOverrides: modelOverrideKeys
+		});
+	});
 	for (const path of INJECT_PATHS) app.post(path, setupRequest, readBody, ...injectChain, buildUpstreamReq, forwardRequest);
 	app.all("*", setupRequest, readBody, resolveConfig, buildUpstreamReq, forwardRequest);
 	app.onError((err, c) => {
@@ -22900,20 +23173,22 @@ function createProxyServer(config, onReady) {
 			type: "proxy_internal_error"
 		} }, { status: 500 });
 	});
+	const initial = source.get();
 	return serve({
 		fetch: app.fetch,
-		port: config.port,
-		hostname: config.host
+		port: initial.port,
+		hostname: initial.host
 	}, onReady);
 }
 const SHUTDOWN_TIMEOUT_MS = 1e4;
-function startProxyServer(config, onReady) {
-	const server = createProxyServer(config, onReady);
+function startProxyServer(source, onReady) {
+	const server = createProxyServer(source, onReady);
 	let shuttingDown = false;
 	function shutdown(signal) {
 		if (shuttingDown) return;
 		shuttingDown = true;
 		logger.info(`${signal} received — draining active connections…`);
+		source.stop();
 		const timer = setTimeout(() => {
 			logger.warn("Forcing shutdown — drain timeout exceeded");
 			process.exit(1);
@@ -23031,17 +23306,24 @@ const startCommand = (0, import_cjs.command)({
 	},
 	handler: async ({ configPath, port, host, noConfig, openrouterKey, verbose }) => {
 		try {
-			const cfg = await loadConfig({
+			const loadOptions = {
 				configPath,
 				noConfig,
 				port,
 				host,
 				openrouterKey,
 				verbose
+			};
+			const cfg = await loadConfig(loadOptions);
+			const source = createConfigSource({
+				loadOptions,
+				initial: cfg
 			});
-			startProxyServer(cfg, () => {
+			source.start();
+			startProxyServer(source, () => {
 				logger.ready(`Proxitor proxy listening on ${cfg.host}:${cfg.port}`);
 				logger.info("Routing requests to OpenRouter");
+				if (source.resolvedPath) logger.info(`Watching ${source.resolvedPath} for changes (live reload)`);
 			});
 		} catch (error) {
 			logger.error("Failed to start proxy:", error);
@@ -23082,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)",