deepseek-coordination 0.10.1 → 0.11.0

package/lib/index.mjs

@@ -1,8 +1,8 @@
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import Schema$1 from "@deepseek-ai/schemastery";
 import { Service } from "@deepseek-ai/cordis";
-import { closeSync, mkdirSync, openSync, readFileSync, readSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { createHash, randomBytes } from "node:crypto";
 //#region src/shared/enum.ts
@@ -4428,18 +4428,6 @@ const PROFESSION_CONTROLS = [
 ];
 /** Fields whose six defaults differ, therefore one row per scene. */
 const SCENE_FIELDS = [
-	{
-		field: "thinking",
-		copy: "scene.thinking",
-		kind: "enum",
-		options: ["enabled", "disabled"]
-	},
-	{
-		field: "reasoningEffort",
-		copy: "scene.reasoningEffort",
-		kind: "text",
-		wired: true
-	},
 	{
 		field: "requirePlan",
 		copy: "scene.requirePlan",
@@ -5813,9 +5801,11 @@ var SelectionModule = class {
 			} catch {
 				spec = {};
 			}
+			const rawName = typeof option.name === "string" ? option.name.trim() : "";
+			const name = rawName.length > 0 && rawName !== option.value ? rawName : option.value in PermissionLabel ? PermissionLabel[option.value] : option.value;
 			return {
 				value: option.value,
-				name: option.name || PermissionLabel[option.value] || option.value,
+				name,
 				description: option.description ?? spec.description,
 				...spec.sandbox === void 0 ? {} : { sandbox: spec.sandbox },
 				...spec.approval === void 0 ? {} : { approval: spec.approval }
@@ -6754,7 +6744,7 @@ var CompactModule = class {
 * (JSON for objects, String for the rest), so no DSH payload is assumed.
 */
 function readSnapshot(result) {
-	const record = asRecord$3(result);
+	const record = asRecord$4(result);
 	if (record !== void 0) {
 		const hasBefore = Object.hasOwn(record, "before");
 		const hasAfter = Object.hasOwn(record, "after");
@@ -6774,7 +6764,7 @@ function readSnapshot(result) {
 		after: portText(result)
 	};
 }
-function asRecord$3(value) {
+function asRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 /** Turn a port value into recordable text without trusting its shape. */
@@ -8448,12 +8438,12 @@ var TakeoverGate = class {
 	* agent. Returns a disposer; unload delegates every open request.
 	*/
 	install(context) {
-		const register = asFunction$1(asRecord$2(context)?.on);
+		const register = asFunction$1(asRecord$3(context)?.on);
 		if (register === void 0) return () => {};
 		const disposers = [];
 		const subscribe = (name, listener) => {
 			try {
-				const dispose = register.call(context, name, listener);
+				const dispose = register.call(context, name, listener, { prepend: true });
 				if (typeof dispose === "function") disposers.push(dispose);
 			} catch {}
 		};
@@ -8531,7 +8521,7 @@ var TakeoverGate = class {
 	*/
 	async handleApproval(request, next, signal) {
 		if (this.config.ui?.takeover !== true) return next();
-		const event = asRecord$2(request);
+		const event = asRecord$3(request);
 		if (event === void 0) return next();
 		const abortSignal = signal ?? abortSignalOf(event.signal);
 		if (abortSignal?.aborted === true) return next();
@@ -8547,7 +8537,7 @@ var TakeoverGate = class {
 	*/
 	async handleQuestion(request, next, signal) {
 		if (this.config.ui?.takeover !== true) return next();
-		const event = asRecord$2(request);
+		const event = asRecord$3(request);
 		if (event === void 0) return next();
 		const abortSignal = signal ?? abortSignalOf(event.signal);
 		if (abortSignal?.aborted === true) return next();
@@ -8665,7 +8655,7 @@ var TakeoverGate = class {
 	* dropping an otherwise answerable request.
 	*/
 	sessionOf(event) {
-		const agent = asRecord$2(event.agent);
+		const agent = asRecord$3(event.agent);
 		const handle = agent === void 0 ? "" : typeof agent.id === "string" ? agent.id : "";
 		if (handle.length === 0) return void 0;
 		try {
@@ -8675,7 +8665,7 @@ var TakeoverGate = class {
 		}
 	}
 };
-function asRecord$2(value) {
+function asRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
 function asFunction$1(value) {
@@ -8683,13 +8673,13 @@ function asFunction$1(value) {
 }
 /** Forward the event signal only when it behaves like one. */
 function abortSignalOf(value) {
-	const record = asRecord$2(value);
+	const record = asRecord$3(value);
 	if (record === void 0) return void 0;
 	if (typeof record.aborted !== "boolean" || typeof record.addEventListener !== "function") return void 0;
 	return value;
 }
 function handleOf$1(value) {
-	const record = asRecord$2(value);
+	const record = asRecord$3(value);
 	return typeof record?.handle === "string" && record.handle.length > 0 ? record.handle : void 0;
 }
 /** Build the JSON-safe approval payload the Client renders. */
@@ -8703,7 +8693,7 @@ function approvalPayloadOf(event) {
 	};
 }
 function displayReasonOf(value) {
-	const record = asRecord$2(value);
+	const record = asRecord$3(value);
 	if (record === void 0) return void 0;
 	const localized = {};
 	for (const [locale, copy] of Object.entries(record)) if (typeof copy === "string") localized[locale] = copy;
@@ -8715,7 +8705,7 @@ function questionSpecsOf(value) {
 	const questions = [];
 	const seen = /* @__PURE__ */ new Set();
 	for (const candidate of value) {
-		const record = asRecord$2(candidate);
+		const record = asRecord$3(candidate);
 		if (record === void 0) continue;
 		const id = typeof record.id === "string" ? record.id : "";
 		const question = typeof record.question === "string" ? record.question : "";
@@ -8739,7 +8729,7 @@ function optionsOf(value) {
 	if (!Array.isArray(value)) return [];
 	const options = [];
 	for (const candidate of value) {
-		const record = asRecord$2(candidate);
+		const record = asRecord$3(candidate);
 		if (record === void 0) continue;
 		const label = typeof record.label === "string" ? record.label : "";
 		if (label.length === 0) continue;
@@ -8751,7 +8741,7 @@ function optionsOf(value) {
 	return options;
 }
 function intentOf$1(value) {
-	const record = asRecord$2(value);
+	const record = asRecord$3(value);
 	if (record === void 0) return void 0;
 	if (typeof record.kind !== "string" || typeof record.approve !== "string") return void 0;
 	return {
@@ -8760,7 +8750,7 @@ function intentOf$1(value) {
 	};
 }
 function waitOf(value) {
-	const record = asRecord$2(value);
+	const record = asRecord$3(value);
 	if (record === void 0) return void 0;
 	if (typeof record.callId !== "string" || record.callId.length === 0) return void 0;
 	return {
@@ -8769,7 +8759,7 @@ function waitOf(value) {
 	};
 }
 function validateAnswer(entry, answer) {
-	const record = asRecord$2(answer);
+	const record = asRecord$3(answer);
 	if (record === void 0) throw new InvalidArgumentError("takeover answer must be an object");
 	if (record.kind !== entry.type) throw new InvalidArgumentError(`takeover answer kind must be "${entry.type}"`, { kind: record.kind });
 	if (entry.type === "approval") return {
@@ -8794,7 +8784,7 @@ function questionAnswersOf(questions, value) {
 	const seen = /* @__PURE__ */ new Set();
 	const answers = [];
 	for (const candidate of value) {
-		const record = asRecord$2(candidate);
+		const record = asRecord$3(candidate);
 		if (record === void 0) throw new InvalidArgumentError("question answer entry must be an object");
 		const id = record.id;
 		if (typeof id !== "string" || id.length === 0) throw new InvalidArgumentError("question answer entry must carry a non-empty id");
@@ -12802,9 +12792,6 @@ var TurnPipeline = class {
 			});
 			return report;
 		}
-		if (turn.effort === profile.reasoningEffort) policy.applied.push("effort");
-		else this.defer(policy, report, "reasoningEffort", `turn effort "${turn.effort}" differs from the scene effort "${profile.reasoningEffort}"`);
-		this.defer(policy, report, "thinking", "no DSH model-config port: the pipeline records the scene but cannot toggle reasoning");
 		this.defer(policy, report, "allowBash", "no execution-policy port: bash permission is left to the DSH permission preset");
 		this.defer(policy, report, "maxIteration", "no iterative driver consumes scene.maxIteration yet");
 		policy.applied.push("allowWeb");
@@ -12973,6 +12960,12 @@ function evidenceCount(value) {
 		return 1;
 	}
 }
+/** The neutral effort recorded when DSH has not committed a route yet. */
+const DefaultEffort = "medium";
+/** Narrow an unknown to a plain record without throwing. */
+function recordOf$1(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
 function textOr(value, fallback) {
 	return typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
 }
@@ -13137,6 +13130,26 @@ var CoordinationService = class extends Service {
 	listProfessionRecord(session) {
 		return this.profession.listProfessionRecord(session);
 	}
+	/**
+	* The reasoning effort DSH will send for this session.
+	*
+	* Read from the session's own request header instead of plugin config: the
+	* model page owns this choice and the plugin never overrides it. A session
+	* with no committed route yet has no header, so the row records the neutral
+	* default rather than guessing from a scene literal.
+	*/
+	observedEffort(sessionId) {
+		try {
+			const raw = recordOf$1(this.runtime.rawSession(sessionId));
+			const read = raw?.requestHeader;
+			if (typeof read !== "function") return DefaultEffort;
+			const config = recordOf$1(recordOf$1(read.call(raw))?.config);
+			const effort = typeof config?.reasoningEffort === "string" ? config.reasoningEffort.trim() : "";
+			return effort.length > 0 ? effort : DefaultEffort;
+		} catch {
+			return DefaultEffort;
+		}
+	}
 	/** Open (or reuse) the coordination turn for one DSH turn. */
 	async beginTurn(sessionId, dshTurn, promptText = "") {
 		const session = this.session.ensure(sessionId);
@@ -13144,7 +13157,6 @@ var CoordinationService = class extends Service {
 		if (existing !== void 0 && existing.dshTurn === dshTurn) return this.turn.get(existing.identity);
 		if (existing !== void 0) this.finishQuietly(existing.identity, "done");
 		const selection = this.selection.get(sessionId);
-		const scene = resolveSceneProfile(this.config, selection.scene);
 		const turn = this.turn.create(session.identity, {
 			content: promptText,
 			profession: selection.profession,
@@ -13152,7 +13164,7 @@ var CoordinationService = class extends Service {
 			scene: selection.scene,
 			validation: selection.validation,
 			command: "none",
-			effort: scene.reasoningEffort
+			effort: this.observedEffort(sessionId)
 		});
 		this.dshTurns.set(sessionId, {
 			dshTurn,
@@ -13436,18 +13448,18 @@ function bootHost(db, config, handles, clock) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null;
 }
-function asRecord$1(value) {
+function asRecord$2(value) {
 	return isRecord(value) ? value : void 0;
 }
 function asFunction(value) {
 	return typeof value === "function" ? value : void 0;
 }
-function asString(value, fallback = "") {
+function asString$1(value, fallback = "") {
 	return typeof value === "string" ? value : fallback;
 }
 /** Resolve one Cordis service without throwing when it is absent. */
 function serviceOf(context, name) {
-	const holder = asRecord$1(context);
+	const holder = asRecord$2(context);
 	if (holder === void 0) return void 0;
 	const get = asFunction(holder.get);
 	if (get !== void 0) try {
@@ -13455,13 +13467,13 @@ function serviceOf(context, name) {
 		if (isRecord(value) || typeof value === "function") return isRecord(value) ? value : { call: value };
 	} catch {}
 	try {
-		return asRecord$1(holder[name]);
+		return asRecord$2(holder[name]);
 	} catch {
 		return;
 	}
 }
 function makeLogger(context) {
-	const logger = asRecord$1(context)?.["logger"];
+	const logger = asRecord$2(context)?.["logger"];
 	if (!isRecord(logger)) return void 0;
 	const record = (level) => {
 		const fn = asFunction(logger[level]);
@@ -13480,42 +13492,42 @@ function makeLogger(context) {
 	};
 }
 function adaptProvider(value) {
-	const record = asRecord$1(value) ?? {};
-	const id = asString(record.id) || asString(record.provider) || asString(record.name);
+	const record = asRecord$2(value) ?? {};
+	const id = asString$1(record.id) || asString$1(record.provider) || asString$1(record.name);
 	return {
 		id,
-		name: asString(record.name) || id
+		name: asString$1(record.name) || id
 	};
 }
 function adaptConfigurableProvider(value) {
-	const record = asRecord$1(value) ?? {};
-	const provider = asString(record.provider) || asString(record.id);
+	const record = asRecord$2(value) ?? {};
+	const provider = asString$1(record.provider) || asString$1(record.id);
 	const settingsPath = Array.isArray(record.settingsPath) ? record.settingsPath.filter((entry) => typeof entry === "string") : [];
 	return {
 		provider,
-		displayName: asString(record.displayName) || provider,
-		settingsNs: asString(record.settingsNs),
+		displayName: asString$1(record.displayName) || provider,
+		settingsNs: asString$1(record.settingsNs),
 		settingsPath,
 		...typeof record.declared === "boolean" ? { declared: record.declared } : {},
 		...typeof record.error === "string" ? { error: record.error } : {}
 	};
 }
 function adaptModel(provider, value) {
-	const record = asRecord$1(value) ?? {};
-	const id = asString(record.id) || asString(record.model);
+	const record = asRecord$2(value) ?? {};
+	const id = asString$1(record.id) || asString$1(record.model);
 	return {
-		provider: asString(record.provider) || provider,
+		provider: asString$1(record.provider) || provider,
 		id,
-		name: asString(record.name) || id,
+		name: asString$1(record.name) || id,
 		...typeof record.description === "string" ? { description: record.description } : {},
 		...Array.isArray(record.inputModalities) ? { inputModalities: record.inputModalities.filter((entry) => typeof entry === "string") } : {}
 	};
 }
 function adaptResolvedModel(provider, model, value) {
 	const base = adaptModel(provider, value);
-	const record = asRecord$1(value) ?? {};
-	const context = asRecord$1(record.context);
-	const reasoning = asRecord$1(record.reasoning);
+	const record = asRecord$2(value) ?? {};
+	const context = asRecord$2(record.context);
+	const reasoning = asRecord$2(record.reasoning);
 	const efforts = Array.isArray(reasoning?.efforts) ? reasoning.efforts : [];
 	return {
 		...base,
@@ -13523,9 +13535,9 @@ function adaptResolvedModel(provider, model, value) {
 		...context !== void 0 && typeof context.contextWindow === "number" ? { context: { contextWindow: context.contextWindow } } : {},
 		...typeof record.defaultMaxTokens === "number" ? { defaultMaxTokens: record.defaultMaxTokens } : {},
 		...reasoning === void 0 ? {} : { reasoning: {
-			efforts: efforts.map((entry) => asRecord$1(entry)).filter((entry) => entry !== void 0).map((entry) => ({
-				id: asString(entry.id),
-				name: asString(entry.name) || asString(entry.id),
+			efforts: efforts.map((entry) => asRecord$2(entry)).filter((entry) => entry !== void 0).map((entry) => ({
+				id: asString$1(entry.id),
+				name: asString$1(entry.name) || asString$1(entry.id),
 				...typeof entry.description === "string" ? { description: entry.description } : {}
 			})),
 			...typeof reasoning.defaultEffort === "string" ? { defaultEffort: reasoning.defaultEffort } : {}
@@ -13569,9 +13581,9 @@ function makeAgentPort(context) {
 	const list = asFunction(agents.list);
 	if (get === void 0 && list === void 0) return void 0;
 	const toView = (value) => {
-		const record = asRecord$1(value);
+		const record = asRecord$2(value);
 		if (record === void 0) return void 0;
-		const id = asString(record.id);
+		const id = asString$1(record.id);
 		return id.length === 0 ? void 0 : {
 			id,
 			session: record.session
@@ -13681,7 +13693,7 @@ function makeCompactionPort(context, rawAgent) {
 			return await compactNow.call(compaction, live, signal);
 		},
 		...compactIfNeeded === void 0 ? {} : { compactIfNeeded: async (agent, trigger, signal) => {
-			const live = asRecord$1(rawAgent(agent.id)) ?? {};
+			const live = asRecord$2(rawAgent(agent.id)) ?? {};
 			const session = live.session;
 			if (session === void 0) return null;
 			const options = isRecord(live.options) ? live.options : {};
@@ -13719,22 +13731,22 @@ function makePermissionPresetPort(context) {
 	const resolve = asFunction(presets.resolve);
 	return {
 		catalog: () => {
-			const value = asRecord$1(catalog.call(presets)) ?? {};
+			const value = asRecord$2(catalog.call(presets)) ?? {};
 			return {
-				options: (Array.isArray(value.options) ? value.options : []).map((entry) => asRecord$1(entry)).filter((entry) => entry !== void 0).map((entry) => ({
-					value: asString(entry.value),
-					name: asString(entry.name) || asString(entry.value),
+				options: (Array.isArray(value.options) ? value.options : []).map((entry) => asRecord$2(entry)).filter((entry) => entry !== void 0).map((entry) => ({
+					value: asString$1(entry.value),
+					name: asString$1(entry.name) || asString$1(entry.value),
 					...typeof entry.description === "string" ? { description: entry.description } : {}
 				})).filter((entry) => entry.value.length > 0),
 				...typeof value.defaultPreset === "string" ? { defaultPreset: value.defaultPreset } : {}
 			};
 		},
-		current: (session) => asString(current.call(presets, session)),
+		current: (session) => asString$1(current.call(presets, session)),
 		set: (session, name) => {
 			set.call(presets, session, name);
 		},
 		...resolve === void 0 ? {} : { resolve: (name) => {
-			const value = asRecord$1(resolve.call(presets, name)) ?? {};
+			const value = asRecord$2(resolve.call(presets, name)) ?? {};
 			return {
 				...typeof value.sandbox === "string" ? { sandbox: value.sandbox } : {},
 				...typeof value.approval === "string" ? { approval: value.approval } : {},
@@ -13749,15 +13761,15 @@ function makeSandboxPolicyPort(context) {
 	if (policy === void 0) return void 0;
 	const resolve = asFunction(policy.resolve);
 	const overrideOf = asFunction(policy.overrideOf);
-	const defaultMode = asString(policy.defaultMode, "workspace-write");
+	const defaultMode = asString$1(policy.defaultMode, "workspace-write");
 	if (resolve === void 0) return void 0;
 	return {
 		defaultMode,
 		resolve: (request) => {
-			const value = asRecord$1(resolve.call(policy, request ?? {})) ?? {};
+			const value = asRecord$2(resolve.call(policy, request ?? {})) ?? {};
 			return {
-				mode: asString(value.mode, defaultMode),
-				workspaceRoot: asString(value.workspaceRoot)
+				mode: asString$1(value.mode, defaultMode),
+				workspaceRoot: asString$1(value.workspaceRoot)
 			};
 		},
 		overrideOf: (session) => {
@@ -13788,7 +13800,7 @@ function createRuntime(context) {
 	};
 }
 function warn(context, message, error) {
-	const logger = asRecord$1(asRecord$1(context)?.["logger"]);
+	const logger = asRecord$2(asRecord$2(context)?.["logger"]);
 	const fn = asFunction(logger?.warn);
 	if (fn !== void 0) try {
 		fn.call(logger, `deepseek-coordination: ${message}: ${error instanceof Error ? error.message : String(error)}`);
@@ -13805,7 +13817,7 @@ function contentText(value) {
 			parts.push(entry);
 			continue;
 		}
-		const text = asString(asRecord$1(entry)?.text);
+		const text = asString$1(asRecord$2(entry)?.text);
 		if (text.length > 0) parts.push(text);
 	}
 	return parts.join("\n");
@@ -13818,7 +13830,7 @@ function contentText(value) {
 function promptTextOfMessages(messages) {
 	if (!Array.isArray(messages)) return void 0;
 	for (let index = messages.length - 1; index >= 0; index -= 1) {
-		const message = asRecord$1(messages[index]);
+		const message = asRecord$2(messages[index]);
 		if (message?.role !== "user") continue;
 		const text = contentText(message.content).trim();
 		if (text.length > 0) return text;
@@ -13836,12 +13848,12 @@ const TurnHookBudgetMs = 5e3;
 * here at all.
 */
 function installTurnLifecycle(context, lifecycle) {
-	const on = asFunction(asRecord$1(context)?.on);
+	const on = asFunction(asRecord$2(context)?.on);
 	if (on === void 0) return () => {};
 	const disposers = [];
 	const preStep = on.call(context, "agent/pre-step", async (payload, next) => {
-		const record = asRecord$1(payload);
-		const agentId = asString(asRecord$1(record?.agent)?.id);
+		const record = asRecord$2(payload);
+		const agentId = asString$1(asRecord$2(record?.agent)?.id);
 		if (agentId.length > 0 && typeof record?.turn === "number") {
 			const prompt = promptTextOfMessages(record?.messages);
 			const observation = {
@@ -13868,8 +13880,8 @@ function installTurnLifecycle(context, lifecycle) {
 	});
 	if (typeof preStep === "function") disposers.push(preStep);
 	const stopping = on.call(context, "agent/turn-stopping", async (payload) => {
-		const record = asRecord$1(payload);
-		const agentId = asString(asRecord$1(record?.agent)?.id);
+		const record = asRecord$2(payload);
+		const agentId = asString$1(asRecord$2(record?.agent)?.id);
 		try {
 			if (agentId.length > 0 && typeof record?.turn === "number") await lifecycle.end({
 				session: agentId,
@@ -13882,8 +13894,8 @@ function installTurnLifecycle(context, lifecycle) {
 	if (typeof stopping === "function") disposers.push(stopping);
 	if (lifecycle.fail !== void 0) {
 		const failed = on.call(context, "agent/error", (payload) => {
-			const record = asRecord$1(payload);
-			const agentId = asString(asRecord$1(record?.agent)?.id);
+			const record = asRecord$2(payload);
+			const agentId = asString$1(asRecord$2(record?.agent)?.id);
 			if (agentId.length === 0 || typeof record?.turn !== "number") return;
 			const turn = record.turn;
 			const failure = record.error;
@@ -13904,6 +13916,463 @@ function installTurnLifecycle(context, lifecycle) {
 	};
 }
 //#endregion
+//#region src/host/settings-store.ts
+/**
+* Durable settings edits for the host's own knobs (v24 §19).
+*
+* DSH's settings service only persists fields whose schema node is volatile,
+* and a volatile node changes every parsed value into a reference wrapper —
+* which this host cannot adopt without rewriting every config reader. The
+* settings page therefore persists through this module instead: one small JSON
+* document beside the coordination database, holding only the paths the page
+* actually wrote.
+*
+* Contract:
+*  - the document is a flat `{ "<dotted.path>": scalar }` map, the same shape
+*    the `POST /config` route speaks, so nothing is nested twice;
+*  - a missing, unreadable or malformed file means "no overrides", never an
+*    error: a deployment that never opened the page has no state to load;
+*  - writes are atomic enough for one process (temp file + rename), so a crash
+*    mid-write cannot truncate the previous document;
+*  - the two deployment secrets are never stored: `applyConfigPatch` refuses
+*    them before this module is reached, and the filter is repeated here so a
+*    hand-edited file cannot smuggle them in.
+*/
+/** File name placed beside the coordination database. */
+const SETTINGS_FILE = "config.overrides.json";
+/** Paths this module must never persist, even when a patch names them. */
+const REFUSED_KEYS = /* @__PURE__ */ new Set(["database", "databasePath"]);
+/** The override document beside one database file. */
+function settingsPath(databasePath) {
+	return join(dirname(databasePath), SETTINGS_FILE);
+}
+/**
+* Read the stored overrides of one profile.
+*
+* Non-scalar entries and refused keys are dropped rather than surfaced: a
+* corrupt document must degrade to "no overrides", so the resolved config stays
+* exactly what the deployment patch describes.
+*/
+function readOverrides(file) {
+	let text;
+	try {
+		text = readFileSync(file, "utf8");
+	} catch {
+		return {};
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return {};
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
+	const overrides = {};
+	for (const [key, value] of Object.entries(parsed)) {
+		if (REFUSED_KEYS.has(key)) continue;
+		if (typeof value === "string" || typeof value === "boolean") overrides[key] = value;
+		else if (typeof value === "number" && Number.isFinite(value)) overrides[key] = value;
+	}
+	return overrides;
+}
+/**
+* Merge one applied patch into the stored overrides.
+*
+* @returns true when the document now holds the patch; false when the directory
+* or file could not be written (the caller then reports `persisted: false`).
+*/
+function writeOverrides(file, patch) {
+	const merged = readOverrides(file);
+	for (const [key, value] of Object.entries(patch)) {
+		if (REFUSED_KEYS.has(key)) continue;
+		merged[key] = value;
+	}
+	const temporary = `${file}.${process.pid}.tmp`;
+	try {
+		mkdirSync(dirname(file), { recursive: true });
+		writeFileSync(temporary, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
+		renameSync(temporary, file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/host/proxy-adapter.ts
+/**
+* Provider allowlist shared by the adapter and the routing listener.
+*
+* Only the deployment's own model routes may be proxied. Anything else (a
+* provider another plugin registered, a future third-party route) is left
+* exactly as the harness built it.
+*/
+const PROXY_ALLOWED_PROVIDERS = [
+	"deepseek",
+	"deepseek-account",
+	"deepseek-official"
+];
+/** True when the proxy may intercept this provider route. */
+function isProxyProviderAllowed(provider, allow = PROXY_ALLOWED_PROVIDERS) {
+	return typeof provider === "string" && allow.includes(provider);
+}
+function asRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function asString(value) {
+	return typeof value === "string" ? value : "";
+}
+/** Structural shape of one request: counts only, never content. */
+function summarise(request) {
+	const messages = Array.isArray(request.messages) ? request.messages : [];
+	let chars = 0;
+	for (const message of messages) {
+		const content = asRecord$1(message)?.content;
+		if (typeof content === "string") chars += content.length;
+		else if (Array.isArray(content)) for (const block of content) {
+			const record = asRecord$1(block);
+			if (typeof record?.text === "string") chars += record.text.length;
+		}
+	}
+	const tools = Array.isArray(request.tools) ? request.tools.length : void 0;
+	return {
+		messages: messages.length,
+		chars,
+		...tools === void 0 ? {} : { tools }
+	};
+}
+/** Build the adapter. Registration and disposal belong to the caller. */
+function createProxyAdapter(options) {
+	const { provider: proxyProvider, llm } = options;
+	const allow = options.allowProviders ?? PROXY_ALLOWED_PROVIDERS;
+	/** The real route, or `undefined` before the first request names one. */
+	const upstream = () => {
+		const route = options.routeOf();
+		if (route === void 0) return void 0;
+		const provider = asString(route.provider).trim();
+		if (provider.length === 0) return void 0;
+		const model = asString(route.model).trim();
+		return {
+			provider,
+			...model.length === 0 ? {} : { model }
+		};
+	};
+	const stream = (request) => {
+		const frozen = asRecord$1(request);
+		if (frozen === void 0) {
+			options.trace?.({
+				event: "refuse",
+				provider: proxyProvider,
+				reason: "request-not-an-object"
+			});
+			throw new Error("coordination proxy: the request is not an object");
+		}
+		const route = upstream();
+		if (route === void 0) {
+			options.trace?.({
+				event: "refuse",
+				provider: proxyProvider,
+				reason: "no-upstream-route"
+			});
+			throw new Error("coordination proxy: no upstream route recorded yet");
+		}
+		if (route.provider === proxyProvider) {
+			options.trace?.({
+				event: "refuse",
+				provider: proxyProvider,
+				reason: "self-forward"
+			});
+			throw new Error(`coordination proxy: refusing to forward "${proxyProvider}" to itself`);
+		}
+		if (!isProxyProviderAllowed(route.provider, allow)) {
+			options.trace?.({
+				event: "refuse",
+				provider: route.provider,
+				reason: "provider-not-allowlisted"
+			});
+			throw new Error(`coordination proxy: provider "${route.provider}" is not on the allowlist`);
+		}
+		const forwarding = llm.stream;
+		if (typeof forwarding !== "function") {
+			options.trace?.({
+				event: "refuse",
+				provider: route.provider,
+				reason: "stream-unavailable"
+			});
+			throw new Error("coordination proxy: ctx.llm.stream is unavailable");
+		}
+		const outgoing = {
+			...options.decorate === void 0 ? { ...frozen } : options.decorate(frozen),
+			provider: route.provider
+		};
+		options.trace?.({
+			event: "forward",
+			provider: route.provider,
+			...typeof outgoing.model === "string" ? { model: outgoing.model } : {},
+			...summarise(outgoing)
+		});
+		return forwarding.call(llm, outgoing);
+	};
+	return {
+		providerInfo: (provider) => ({
+			id: provider,
+			name: "Coordination Proxy"
+		}),
+		providerRetryPolicy: () => void 0,
+		imageRequestPricing: () => void 0,
+		imageRequestTarget: (_provider, _model, image) => ({
+			width: image.width,
+			height: image.height,
+			maxBytes: image.bytes
+		}),
+		async listModels(provider) {
+			const route = upstream();
+			if (route === void 0 || typeof llm.listModels !== "function") return [];
+			try {
+				const models = await llm.listModels(route.provider);
+				return Array.isArray(models) ? models.map((entry) => {
+					const record = asRecord$1(entry);
+					return record === void 0 ? entry : {
+						...record,
+						provider
+					};
+				}) : [];
+			} catch {
+				return [];
+			}
+		},
+		async resolveModel(provider, model, signal) {
+			const route = upstream();
+			if (route !== void 0 && typeof llm.resolveModelInfo === "function") try {
+				const info = asRecord$1(await llm.resolveModelInfo(route.provider, model, signal));
+				if (info !== void 0) return {
+					...info,
+					provider,
+					id: model,
+					name: asString(info.name) || model
+				};
+			} catch {}
+			return {
+				provider,
+				id: model,
+				name: model
+			};
+		},
+		async prepareCall(provider, model, signal) {
+			return {
+				model: await this.resolveModel(provider, model, signal),
+				stream: (request) => stream(request)
+			};
+		},
+		stream
+	};
+}
+//#endregion
+//#region src/host/model-brand.ts
+/**
+* Built-in profiles.
+*
+* Where a provider documents both an automatic and an explicit mode (Google),
+* the conservative automatic reading is used: the plugin can keep a prefix
+* stable, and cannot emit markers.
+*/
+const BRAND_PROFILES = {
+	deepseek: {
+		brand: "deepseek",
+		label: "DeepSeek",
+		automaticPrefixCache: true,
+		explicitCacheBreakpoints: false,
+		minPrefixTokens: 64,
+		effortBreaksCache: true,
+		stripVolatileHelps: true,
+		note: "Automatic prefix cache; keep the prefix stable and avoid effort changes."
+	},
+	openai: {
+		brand: "openai",
+		label: "OpenAI",
+		automaticPrefixCache: true,
+		explicitCacheBreakpoints: false,
+		minPrefixTokens: 1024,
+		effortBreaksCache: false,
+		stripVolatileHelps: true,
+		note: "Automatic prompt cache above ~1k tokens; effort does not change the prefix."
+	},
+	anthropic: {
+		brand: "anthropic",
+		label: "Anthropic",
+		automaticPrefixCache: false,
+		explicitCacheBreakpoints: true,
+		minPrefixTokens: 1024,
+		effortBreaksCache: true,
+		stripVolatileHelps: false,
+		note: "Explicit cache_control breakpoints only; this plugin cannot emit them."
+	},
+	google: {
+		brand: "google",
+		label: "Google",
+		automaticPrefixCache: true,
+		explicitCacheBreakpoints: true,
+		minPrefixTokens: 1024,
+		effortBreaksCache: false,
+		stripVolatileHelps: true,
+		note: "Implicit prefix cache plus optional explicit contexts; the implicit mode is the safe lever."
+	},
+	xai: {
+		brand: "xai",
+		label: "xAI",
+		automaticPrefixCache: true,
+		explicitCacheBreakpoints: false,
+		minPrefixTokens: 1024,
+		effortBreaksCache: true,
+		stripVolatileHelps: true,
+		note: "Automatic prefix cache; effort and prefix edits both reset it."
+	},
+	moonshot: {
+		brand: "moonshot",
+		label: "Moonshot",
+		automaticPrefixCache: true,
+		explicitCacheBreakpoints: false,
+		minPrefixTokens: 1024,
+		effortBreaksCache: true,
+		stripVolatileHelps: true,
+		note: "Automatic prefix cache; reasoning content is preserved separately."
+	},
+	qwen: {
+		brand: "qwen",
+		label: "Qwen",
+		automaticPrefixCache: true,
+		explicitCacheBreakpoints: false,
+		minPrefixTokens: 1024,
+		effortBreaksCache: false,
+		stripVolatileHelps: true,
+		note: "Automatic prefix cache; keep the system prompt and tool list stable."
+	},
+	zhipu: {
+		brand: "zhipu",
+		label: "Zhipu",
+		automaticPrefixCache: true,
+		explicitCacheBreakpoints: false,
+		minPrefixTokens: 1024,
+		effortBreaksCache: true,
+		stripVolatileHelps: true,
+		note: "Automatic prefix cache; treat a parameter change as a cache reset."
+	},
+	mistral: {
+		brand: "mistral",
+		label: "Mistral",
+		automaticPrefixCache: true,
+		explicitCacheBreakpoints: false,
+		minPrefixTokens: 1024,
+		effortBreaksCache: false,
+		stripVolatileHelps: true,
+		note: "Prefix caching with a conservative minimum; stable prefixes are the lever."
+	},
+	meta: {
+		brand: "meta",
+		label: "Meta",
+		automaticPrefixCache: true,
+		explicitCacheBreakpoints: false,
+		minPrefixTokens: 1024,
+		effortBreaksCache: false,
+		stripVolatileHelps: true,
+		note: "Self-hosted families vary by deployment; the conservative prefix rule applies."
+	},
+	unknown: {
+		brand: "unknown",
+		label: "Unknown",
+		automaticPrefixCache: true,
+		explicitCacheBreakpoints: false,
+		minPrefixTokens: 1024,
+		effortBreaksCache: true,
+		stripVolatileHelps: true,
+		note: "Unknown family: assume an automatic prefix cache and keep everything stable."
+	}
+};
+/**
+* Brand patterns, tested against provider + model + display name.
+*
+* Order matters: the first match wins, so a reseller route named after its
+* model (`acme-claude`) still lands on Anthropic before any generic rule.
+*/
+const BRAND_PATTERNS = [
+	{
+		brand: "anthropic",
+		pattern: /anthropic|claude/i
+	},
+	{
+		brand: "openai",
+		pattern: /openai|chatgpt|\bgpt\b|gpt-[0-9o]|\bo[134]\b/i
+	},
+	{
+		brand: "google",
+		pattern: /google|gemini|vertex/i
+	},
+	{
+		brand: "deepseek",
+		pattern: /deepseek/i
+	},
+	{
+		brand: "xai",
+		pattern: /\bxai\b|grok/i
+	},
+	{
+		brand: "moonshot",
+		pattern: /moonshot|kimi/i
+	},
+	{
+		brand: "qwen",
+		pattern: /qwen|tongyi|dashscope|alibaba/i
+	},
+	{
+		brand: "zhipu",
+		pattern: /zhipu|chatglm|\bglm\b/i
+	},
+	{
+		brand: "mistral",
+		pattern: /mistral|mixtral|codestral/i
+	},
+	{
+		brand: "meta",
+		pattern: /\bllama\b|meta-llama/i
+	}
+];
+/** Classify one host-reported model identity onto a known brand. */
+function classifyModelBrand(identity) {
+	const haystack = [
+		identity.provider,
+		identity.model,
+		identity.name,
+		identity.description
+	].filter((part) => typeof part === "string" && part.length > 0).join(" ");
+	if (haystack.length === 0) return "unknown";
+	for (const row of BRAND_PATTERNS) if (row.pattern.test(haystack)) return row.brand;
+	return "unknown";
+}
+/** The profile for one host-reported identity. */
+function brandProfileOf(identity) {
+	return BRAND_PROFILES[classifyModelBrand(identity)];
+}
+/**
+* Whether the proxy has a useful local lever for this model.
+*
+* With an explicit-breakpoint family the honest answer is "no": the plugin can
+* keep bytes stable, but reuse is decided by markers it cannot write.
+*/
+function hasLocalCacheLever(profile) {
+	return profile.automaticPrefixCache && profile.stripVolatileHelps;
+}
+/**
+* Whether outgoing content should be rewritten for this model right now.
+*
+* Two gates, both deliberate:
+*  - the operator switch (`cache.enabled`) is read live, so the settings page
+*    turns the rewrite off immediately;
+*  - a family without an automatic prefix cache is never rewritten — rewriting
+*    its bytes cannot improve reuse and only risks changing what the model sees.
+*/
+function shouldDecorate(profile, cacheEnabled) {
+	return cacheEnabled && hasLocalCacheLever(profile);
+}
+//#endregion
 //#region src/shared/i18n.ts
 /**
 * The plugin's single source of user-visible and model-facing copy (v24 §22,
@@ -14538,14 +15007,6 @@ const ZH = {
 					label: "工具结果字节上限",
 					hint: "工具返回给模型的字节上限；0 表示不限制。"
 				},
-				"scene.thinking": {
-					label: "思考模式",
-					hint: "是否把推理过程摊开；对话和办公默认关闭。"
-				},
-				"scene.reasoningEffort": {
-					label: "推理强度",
-					hint: "原样传给宿主模型的强度名，例如 high；本插件不改写。"
-				},
 				"scene.requirePlan": {
 					label: "必须出计划",
 					hint: "这一情景是否必须先有可评分的计划。"
@@ -14607,10 +15068,6 @@ const ZH = {
 					compact: "压缩",
 					permission: "权限"
 				},
-				thinkingOptions: {
-					enabled: "开启",
-					disabled: "关闭"
-				},
 				defaultValue: "默认",
 				scene: "情景",
 				allScenes: "所有情景",
@@ -15332,14 +15789,6 @@ const COPY_BY_LOCALE = {
 						label: "Tool result bytes",
 						hint: "Byte cap on a tool result returned to the model; 0 means no cap."
 					},
-					"scene.thinking": {
-						label: "Thinking mode",
-						hint: "Whether reasoning is shown; off by default for dialogue and office."
-					},
-					"scene.reasoningEffort": {
-						label: "Reasoning effort",
-						hint: "Effort name passed to the host model unchanged, e.g. high."
-					},
 					"scene.requirePlan": {
 						label: "Plan required",
 						hint: "Whether this scene must produce a scoreable plan first."
@@ -15401,10 +15850,6 @@ const COPY_BY_LOCALE = {
 						compact: "Compact",
 						permission: "Permission"
 					},
-					thinkingOptions: {
-						enabled: "On",
-						disabled: "Off"
-					},
 					defaultValue: "Default",
 					scene: "Scene",
 					allScenes: "All scenes",
@@ -27006,27 +27451,307 @@ function sessionOf(url, body) {
 	return (fromQuery ?? fromBody ?? "").trim();
 }
 /**
-* Best-effort persistence of an already-applied settings patch.
+* Nest a flat dotted override map, then merge it over the deployment config.
 *
-* DSH owns persistence; the plugin never writes a second config file. When the
-* host exposes `ctx.settings.update`, the patch is forwarded under the plugin
-* name. A missing port or a refusal leaves the live config (already applied) in
-* force and reports `persisted: false`, so the page can say "applies to this
-* process only" instead of claiming a durable save.
+* Stored overrides win over the profile patch: the operator changed those paths
+* from the page, which is the most recent intent. `resolveConfig` still applies
+* every invariant afterwards (forced flags, weight normalisation, clamping).
 */
-async function persistConfig(context, patch) {
-	const settings = context.settings;
-	if (settings === void 0 || typeof settings.update !== "function") return false;
+function mergeOverrides(input, overrides) {
+	const document = {};
+	for (const [key, value] of Object.entries(overrides)) writeConfigPath(document, key, value);
+	return deepMergeRecords(input ?? {}, document);
+}
+/** Recursive merge for plain records; arrays and scalars replace. */
+function deepMergeRecords(base, patch) {
+	if (typeof base !== "object" || base === null || Array.isArray(base)) return patch;
+	if (typeof patch !== "object" || patch === null || Array.isArray(patch)) return patch;
+	const result = { ...base };
+	for (const [key, value] of Object.entries(patch)) result[key] = key in result ? deepMergeRecords(result[key], value) : value;
+	return result;
+}
+/** Resolve a Cordis service without tripping the context proxy. */
+function serviceOrUndefined(context, name) {
+	const getter = context.get;
+	if (typeof getter !== "function") return void 0;
 	try {
-		await settings.update(name, { ...patch });
-		return true;
+		const value = getter.call(context, name);
+		return typeof value === "object" && value !== null ? value : void 0;
 	} catch {
-		return false;
+		return;
+	}
+}
+/** The host webserver, when the profile runs one (a headless profile does not). */
+function webServerOf(context) {
+	const service = serviceOrUndefined(context, "webServer");
+	return service !== void 0 && typeof service.register === "function" ? service : void 0;
+}
+/** The live `ctx.llm` runtime; the proxy adapter needs `stream`, not the port. */
+function llmRuntimeOf(context) {
+	const service = serviceOrUndefined(context, "llm");
+	return service !== void 0 && typeof service.stream === "function" ? service : void 0;
+}
+/** Provider route the cache proxy registers under. */
+const PROXY_PROVIDER = "coordination-proxy";
+const proxyStatus = {
+	available: false,
+	enabled: false,
+	provider: PROXY_PROVIDER,
+	forwards: 0,
+	refusals: 0,
+	decorate: false
+};
+/** The status snapshot handed to `GET /proxy/status`. */
+function cacheProxyStatus() {
+	return {
+		...proxyStatus,
+		...proxyStatus.upstream === void 0 ? {} : { upstream: { ...proxyStatus.upstream } }
+	};
+}
+/** The deployment's default model route, used when no request has named one yet. */
+function defaultRouteOf(context) {
+	const service = serviceOrUndefined(context, "agentDefaultModel");
+	const current = service?.currentSelection;
+	if (typeof current !== "function") return void 0;
+	try {
+		const selection = current.call(service);
+		const record = typeof selection === "object" && selection !== null ? selection : void 0;
+		const provider = typeof record?.provider === "string" ? record.provider : "";
+		const model = typeof record?.model === "string" ? record.model : "";
+		return provider.length > 0 && model.length > 0 ? {
+			provider,
+			model
+		} : void 0;
+	} catch {
+		return;
 	}
 }
+/**
+* Register the experimental cache proxy.
+*
+* `agent/request` rewrites the route to the proxy provider and remembers the
+* real one; the adapter forwards each frozen request to it after rebuilding it.
+* Every step fails open: no llm runtime, no adapter registration or no event bus
+* simply leaves the normal path untouched.
+*
+* Security posture (see `host/proxy-adapter.ts` for the full model):
+*  - only providers on `PROXY_ALLOWED_PROVIDERS` are ever intercepted, so the
+*    proxy cannot redirect traffic to an endpoint this plugin invented;
+*  - the trace file receives structural events only — provider, model, counts,
+*    sizes — never prompt or answer text;
+*  - the adapter holds no transport and no credential: forwarding delegates to
+*    `ctx.llm.stream`, so the real adapter keeps authentication and egress.
+*
+* The switch is a file (`proxy.enable`) as well as an environment variable: the
+* desktop app is launched from the shell's environment, so a file is the only
+* way to turn the experiment on without restarting with new variables.
+*/
+function installCacheProxy(context, stateDir, decorate) {
+	const flagFile = join(stateDir, "proxy.enable");
+	const logFile = join(stateDir, "proxy.log");
+	if (process.env.DSH_COORDINATION_PROXY !== "1" && !existsSync(flagFile)) return () => {};
+	const llm = llmRuntimeOf(context);
+	const service = serviceOrUndefined(context, "llm");
+	const register = service?.registerAdapter;
+	const on = context.on;
+	if (llm === void 0 || typeof register !== "function" || typeof on !== "function") return () => {};
+	/**
+	* Append one structural event as a JSON line.
+	*
+	* JSON (not a formatted sentence) keeps the record unambiguous, and the event
+	* type has no field that can carry content — a reviewer can verify the whole
+	* leak surface by reading `ProxyTraceEvent`.
+	*/
+	const trace = (event) => {
+		if (event.event === "forward") {
+			proxyStatus.forwards += 1;
+			proxyStatus.lastForwardAt = (/* @__PURE__ */ new Date()).toISOString();
+		}
+		if (event.event === "refuse") proxyStatus.refusals += 1;
+		const line = JSON.stringify({
+			ts: (/* @__PURE__ */ new Date()).toISOString(),
+			...event
+		});
+		try {
+			appendFileSync(logFile, `${line}\n`, "utf8");
+		} catch {}
+		if (process.env.DSH_COORDINATION_PROXY_DEBUG === "1") console.error(`[coordination-proxy] ${line}`);
+	};
+	let upstream = defaultRouteOf(context);
+	if (upstream !== void 0) {
+		proxyStatus.upstream = { ...upstream };
+		trace({
+			event: "install",
+			provider: PROXY_PROVIDER,
+			model: upstream.model
+		});
+	} else trace({
+		event: "install",
+		provider: PROXY_PROVIDER
+	});
+	/**
+	* Classify the host-reported model identity onto a built-in cache brand.
+	*
+	* `ctx.llm.resolveModelInfo(provider, model)` is the host's own answer for
+	* "what model is this": it carries the display name and description that a
+	* provider route id alone cannot. The call may hit the adapter, so it is
+	* fired and forgotten — routing never waits on catalog I/O, and a failure
+	* simply leaves the `unknown` conservative profile in place.
+	*/
+	let describedKey = "";
+	const describeModel = (provider, model) => {
+		const key = `${provider}\u0000${model}`;
+		if (key === describedKey) return;
+		describedKey = key;
+		const llmService = serviceOrUndefined(context, "llm");
+		const resolve = llmService?.resolveModelInfo;
+		const apply = (identity) => {
+			const profile = brandProfileOf(identity);
+			proxyStatus.model = {
+				brand: profile.brand,
+				label: profile.label,
+				automaticPrefixCache: profile.automaticPrefixCache,
+				explicitCacheBreakpoints: profile.explicitCacheBreakpoints,
+				minPrefixTokens: profile.minPrefixTokens,
+				effortBreaksCache: profile.effortBreaksCache,
+				stripVolatileHelps: profile.stripVolatileHelps,
+				note: profile.note
+			};
+			trace({
+				event: "model",
+				provider,
+				model,
+				brand: profile.brand
+			});
+		};
+		if (typeof resolve !== "function") {
+			apply({
+				provider,
+				model
+			});
+			return;
+		}
+		try {
+			const pending = resolve.call(llmService, provider, model);
+			if (pending instanceof Promise) {
+				pending.then((info) => {
+					const record = typeof info === "object" && info !== null ? info : void 0;
+					apply({
+						provider,
+						model,
+						...typeof record?.name === "string" ? { name: record.name } : {},
+						...typeof record?.description === "string" ? { description: record.description } : {}
+					});
+				}).catch(() => {
+					apply({
+						provider,
+						model
+					});
+				});
+				return;
+			}
+			const record = typeof pending === "object" && pending !== null ? pending : void 0;
+			apply({
+				provider,
+				model,
+				...typeof record?.name === "string" ? { name: record.name } : {},
+				...typeof record?.description === "string" ? { description: record.description } : {}
+			});
+		} catch {
+			apply({
+				provider,
+				model
+			});
+		}
+	};
+	if (upstream !== void 0) describeModel(upstream.provider, upstream.model ?? "");
+	const adapter = createProxyAdapter({
+		provider: PROXY_PROVIDER,
+		llm,
+		routeOf: () => upstream,
+		allowProviders: PROXY_ALLOWED_PROVIDERS,
+		trace,
+		...decorate === void 0 ? {} : { decorate: (request) => decorate(request, {
+			provider: upstream?.provider ?? "",
+			model: upstream?.model ?? ""
+		}) }
+	});
+	let registration;
+	let detach;
+	try {
+		registration = register.call(service, [PROXY_PROVIDER], adapter);
+		detach = on.call(context, "agent/request", async (_payload, next) => {
+			const seed = await next();
+			const record = typeof seed === "object" && seed !== null ? seed : void 0;
+			const provider = typeof record?.provider === "string" ? record.provider : "";
+			const model = typeof record?.model === "string" ? record.model : "";
+			if (record === void 0 || provider.length === 0 || model.length === 0 || provider === PROXY_PROVIDER) {
+				if (upstream === void 0) upstream = defaultRouteOf(context);
+				return seed;
+			}
+			if (!isProxyProviderAllowed(provider, PROXY_ALLOWED_PROVIDERS)) {
+				trace({
+					event: "refuse",
+					provider,
+					reason: "provider-not-allowlisted"
+				});
+				return seed;
+			}
+			upstream = {
+				provider,
+				model
+			};
+			proxyStatus.upstream = { ...upstream };
+			trace({
+				event: "route",
+				provider,
+				model
+			});
+			describeModel(provider, model);
+			return {
+				...record,
+				provider: PROXY_PROVIDER,
+				model
+			};
+		}, { prepend: true });
+	} catch {
+		trace({
+			event: "refuse",
+			provider: PROXY_PROVIDER,
+			reason: "registration-failed"
+		});
+		return () => {};
+	}
+	proxyStatus.available = true;
+	proxyStatus.enabled = true;
+	proxyStatus.decorate = decorate !== void 0;
+	return () => {
+		proxyStatus.enabled = false;
+		proxyStatus.decorate = false;
+		if (typeof detach === "function") try {
+			detach();
+		} catch {}
+		if (typeof registration === "function") try {
+			registration();
+		} catch {}
+	};
+}
 function apply(context, configInput) {
-	const service = new CoordinationService(context, resolveConfig(configInput), createRuntime(context));
+	const configured = resolveConfig(configInput);
+	const settingsFile = settingsPath(resolveDatabasePath(configured.databasePath, configured.database));
+	const stored = readOverrides(settingsFile);
+	const config = Object.keys(stored).length === 0 ? configured : resolveConfig(mergeOverrides(configInput, stored));
+	const service = new CoordinationService(context, config, createRuntime(context));
 	service.turn.recoverInterrupted();
+	if (process.env.DSH_COORDINATION_PROXY === "1" || existsSync(join(dirname(settingsFile), "proxy.enable"))) {
+		const decorate = (request, identity) => {
+			if (!shouldDecorate(brandProfileOf(identity), config.cache.enabled)) return request;
+			const strategy = service.provider.cacheStrategy(identity.provider);
+			const { cacheWarning: _advice, ...outgoing } = service.cache.decorate(request, strategy);
+			return outgoing;
+		};
+		context.effect(() => installCacheProxy(context, dirname(settingsFile), decorate), `${name}: cache proxy`);
+	}
 	/** Re-register the tools after `POST /locale` changed the copy language. */
 	let refreshTools;
 	context.effect(() => () => {
@@ -27084,7 +27809,9 @@ function apply(context, configInput) {
 		};
 	}, `${name}: tools`);
 	context.effect(() => {
-		const dispose = context.webServer.register({
+		const webServer = webServerOf(context);
+		if (webServer === void 0) return () => {};
+		const dispose = webServer.register({
 			kind: "prefix",
 			path: ROUTE_PREFIX,
 			handler: async (request, response) => {
@@ -27103,6 +27830,13 @@ function apply(context, configInput) {
 						});
 						return;
 					}
+					if (path === "/proxy/status" && method === "GET") {
+						json(response, {
+							ok: true,
+							value: cacheProxyStatus()
+						});
+						return;
+					}
 					if (path === "/echo" && method === "POST") {
 						json(response, {
 							ok: true,
@@ -27320,7 +28054,7 @@ function apply(context, configInput) {
 						if (outcome.compaction !== null) service.applyCompactionPolicy(outcome.compaction);
 						const appliedPatch = {};
 						for (const key of outcome.applied) appliedPatch[key] = patch[key];
-						const persisted = outcome.applied.length > 0 ? await persistConfig(context, appliedPatch) : false;
+						const persisted = outcome.applied.length > 0 ? writeOverrides(settingsFile, appliedPatch) : false;
 						json(response, {
 							ok: true,
 							value: {
@@ -27375,4 +28109,4 @@ function apply(context, configInput) {
 	}, `${name}: ${ROUTE_PREFIX} routes`);
 }
 //#endregion
-export { Config, apply, inject, name };
+export { Config, apply, cacheProxyStatus, inject, name };