dsh-local-models 0.4.0 → 0.5.0

package/README.md

@@ -113,7 +113,9 @@ Launch flags are fixed to the validated daily config: full offload, `-b 2048 -ub
 | `POST /local-models/profiles/remove` | delete a profile |
 | `GET /local-models/settings` / `POST` | read / update plugin settings (`autostartRouter`, `autoUnloadMins`, `binPath`, `shortcuts`, `vramGb`) |
 | `POST /local-models/runtime/check` | `{binPath}` → resolve + `<bin> --version` (the Runtime card's Check) |
-| `POST /local-models/router/start` | build presets from profiles + start router |
+| `POST /local-models/router/start` | build presets from profiles + start router (also syncs the compaction headroom patch — `{compactionSync:false}` opts out) |
+| `GET /local-models/compaction[?profile=]` | per-model compaction threshold coverage |
+| `POST /local-models/compaction/sync` | merge headroom overrides into the profile patch (`{profile,dryRun}`) |
 | `POST /local-models/router/unload` | unload one router model |
 | `POST /local-models/router/unload-all` | unload all router models |
 | `POST /local-models/register` | add the ready server as an `llm-pi-ai` route |

package/lib/client.js

@@ -758,6 +758,11 @@ window.__ModuleLoader__.load({
 			var error = errPair[0], setError = errPair[1];
 			var regPair = useStatePair(null);
 			var registered = regPair[0], setRegistered = regPair[1];
+			// Last compaction-sync note (transient action feedback like
+			// `registered`: derived display, no localStorage — the poll's
+			// status.compaction is the durable source of truth).
+			var cmpPair = useStatePair(null);
+			var compactionNote = cmpPair[0], setCompactionNote = cmpPair[1];
 			var profPair = useStatePair([]);
 			var profiles = profPair[0], setProfiles = profPair[1];
 			var profNamePair = useStatePair("");
@@ -1299,15 +1304,43 @@ window.__ModuleLoader__.load({
 					});
 			};
 
+			var compactionSummary = function (sync) {
+				if (!sync) return null;
+				if (!sync.ok) return "Compaction sync failed: " + (sync.error || "unknown error");
+				var parts = [];
+				if (sync.added && sync.added.length > 0) parts.push("+" + sync.added.length + " (" + sync.added.join(", ") + ")");
+				if (sync.updated && sync.updated.length > 0) parts.push("~" + sync.updated.length + " (" + sync.updated.join(", ") + ")");
+				if (parts.length === 0) {
+					return "Compaction headroom already covers " + (sync.policies ? sync.policies.length : 0) + " router models.";
+				}
+				return "Compaction sync (" + (sync.profile || "web") + "): " + parts.join(" ") + " — restart dsh web to apply.";
+			};
+
 			var doStartRouter = function () {
 				runAction("/local-models/router/start", {},
 					function (res) {
 						if (!res.ok) setError((res.body && res.body.error) || "router start failed");
 						else pendingRouterRegRef.current = true;
+						if (res.body && res.body.compactionSync) {
+							var msg = compactionSummary(res.body.compactionSync);
+							if (res.body.compactionSync.ok) setCompactionNote(msg);
+							else setError(msg);
+						}
 						refresh();
 					});
 			};
 
+			var doSyncCompaction = function () {
+				setCompactionNote(null);
+				post("/local-models/compaction/sync", { profile: "web" })
+					.then(function (res) {
+						if (!res.ok) setError((res.body && res.body.error) || "compaction sync failed");
+						else setCompactionNote(compactionSummary(res.body));
+					})
+					.catch(function (e2) { setError(String(e2)); })
+					.finally(refresh);
+			};
+
 			var doUpdateSettings = function (patch) {
 				runAction("/local-models/settings", patch,
 					function (res) {
@@ -1829,6 +1862,35 @@ window.__ModuleLoader__.load({
 						stale ? h("p", { style: style.warn }, "Timer changed — restart the server to apply it now.") : null,
 					);
 				})(),
+				(function () {
+					// Compaction headroom coverage for the daily profile: the
+					// server reports it on every poll (status.compaction), so
+					// this is display-only — no local edits to fight the poll.
+					var c = status.compaction;
+					if (!c) return null;
+					var bad = !!(c.error || (c.missing && c.missing.length > 0) || c.stale > 0);
+					var line;
+					if (c.error) line = "Compaction headroom: unavailable (" + c.error + ").";
+					else if (c.total === 0) line = "Compaction headroom: no saved profiles yet.";
+					else if (!bad) line = "Compaction headroom: " + c.covered + "/" + c.total + " router models covered.";
+					else {
+						var bits = [];
+						if (c.missing && c.missing.length > 0) bits.push("missing: " + c.missing.join(", "));
+						if (c.stale > 0) bits.push(c.stale + " stale");
+						line = "Compaction headroom: " + c.covered + "/" + c.total + " covered (" + bits.join("; ") + ") — sync, then restart dsh web.";
+					}
+					return h(
+						"div",
+						{ style: { display: "flex", flexDirection: "column", gap: 4 } },
+						h("p", { style: bad ? style.warn : style.small }, line),
+						h(
+							"div",
+							{ style: style.row },
+							h("button", { style: style.secondaryButton, onClick: doSyncCompaction, disabled: busy }, "Sync compaction headroom"),
+						),
+						compactionNote !== null ? h("p", { style: style.small }, compactionNote) : null,
+					);
+				})(),
 			);
 
 			// ---- render: page ----

package/lib/index.js

@@ -12,6 +12,11 @@
  *   GET   /local-models/logs?offset=&max= → tail of llama-server.log (terminal)
  *   POST  /local-models/run             → {path, ctx, mtp, kv} → spawn llama-server
  *   POST  /local-models/stop            → stop the child (or reap the port)
+ *   POST  /local-models/router/start    → write router presets, sync the
+ *                                          compaction headroom patch, spawn
+ *   GET   /local-models/compaction[?profile=] → per-model threshold coverage
+ *   POST  /local-models/compaction/sync → merge headroom overrides into the
+ *                                          profile's cordis.patch.yml
  *   POST  /local-models/settings        → {autostartRouter, autoUnloadMins,
  *                                          binPath, shortcuts} → settings.json
  *   POST  /local-models/runtime/check   → {binPath} → resolve + `<bin> --version`
@@ -33,6 +38,7 @@ import {
 	existsSync,
 	mkdirSync,
 	openSync,
+	copyFileSync,
 	readFileSync,
 	readSync,
 	readdirSync,
@@ -43,6 +49,7 @@ import {
 } from "node:fs";
 import { basename, join, dirname, resolve, sep, delimiter, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import process from "node:process";
 
@@ -180,6 +187,364 @@ export function compactionBudgetFor(contextWindow, opts = {}) {
 		recommendedHeadroom,
 	};
 }
+/** Provider key the router registers under: every router modelPolicy targets
+ * this provider with the profile id as the model. Single-mode registrations
+ * use per-model `local-<alias>` routes instead and are NOT auto-synced
+ * (their route only exists while that server runs) — see syncCompactionPatch. */
+export const COMPACTION_ROUTER_PROVIDER = "local-router";
+/** `provider`/`model` charset shared by routes and patch policies. */
+const POLICY_ID_RE = /^[a-zA-Z0-9_-]+$/;
+
+/** One router profile's compaction policy: the headroom override that lands
+ * its proactive threshold near 70% of the window instead of the core
+ * default's early trigger (32K on a 128K window = the compaction loop).
+ * Pure; sorted by model so generated YAML is deterministic. */
+export function desiredCompactionPolicies(profiles) {
+	const list = Array.isArray(profiles) ? profiles : [];
+	const out = [];
+	for (const p of list) {
+		if (!p || typeof p !== "object") continue;
+		const model = typeof p.id === "string" && p.id
+			? p.id
+			: slugProfile(typeof p.name === "string" ? p.name : "");
+		if (!POLICY_ID_RE.test(model)) continue;
+		const ctx = Number.isInteger(p.ctx) && p.ctx > 0 ? p.ctx : 8192;
+		out.push({
+			provider: COMPACTION_ROUTER_PROVIDER,
+			model,
+			headroomTokens: compactionBudgetFor(ctx).recommendedHeadroom,
+		});
+	}
+	out.sort((a, b) => a.model < b.model ? -1 : a.model > b.model ? 1 : 0);
+	return out;
+}
+
+/** Per-profile compaction plan: default-threshold math next to the on-disk
+ * override state, so the tab can name the models that would still loop.
+ * `existing` is readModelPolicies() output (null = patch state unknown).
+ * Pure. */
+export function compactionPlan(profiles, existing) {
+	const desired = desiredCompactionPolicies(profiles);
+	const have = new Map();
+	for (const e of Array.isArray(existing) ? existing : []) {
+		if (e && typeof e === "object" && POLICY_ID_RE.test(e.model ?? "")) {
+			have.set(policyKey(e.provider, e.model), e.headroomTokens);
+		}
+	}
+	return desired.map((d) => {
+		const p = (Array.isArray(profiles) ? profiles : []).find((q) =>
+			q && typeof q === "object" && ((q.id || slugProfile(q.name ?? "")) === d.model));
+		const ctx = p && Number.isInteger(p.ctx) && p.ctx > 0 ? p.ctx : 8192;
+		const budget = compactionBudgetFor(ctx);
+		const tuned = compactionBudgetFor(ctx, { headroomTokens: d.headroomTokens });
+		const coveredHeadroom = have.has(policyKey(d.provider, d.model))
+			? have.get(policyKey(d.provider, d.model))
+			: null;
+		return {
+			provider: d.provider,
+			model: d.model,
+			ctx,
+			maxTokens: budget.maxTokens,
+			thresholdTokens: budget.thresholdTokens,
+			tunedThresholdTokens: tuned.thresholdTokens,
+			recommendedHeadroom: d.headroomTokens,
+			coveredHeadroom,
+			status: coveredHeadroom === null ? "missing" : coveredHeadroom === d.headroomTokens ? "covered" : "stale",
+		};
+	});
+}
+
+// ---------------------------------------------------------------------------
+// preset-standard patch surgery (pure, exported for tests).
+//
+// The live compaction engines run inside the agent-preset scopes, so the
+// headroom override must ride a wholesale `config` on the `- id:
+// preset-standard` row of the profile's cordis.patch.yml — a patch on the
+// top-level (disabled) compaction-basic row is dead config. This surgery
+// touches ONLY the nested modelPolicies list and preserves everything else
+// (including the !!js expressions a YAML parser would choke on, which is why
+// this is line-based instead of parse-and-reserialize). Anything it does not
+// recognize is a thrown Error, never a half-written file.
+// ---------------------------------------------------------------------------
+
+/** Map key for one policy target. \u0000 separates the two ids so no two
+ * distinct provider/model pairs share a key. */
+function policyKey(provider, model) {
+	return provider + "\u0000" + model;
+}
+
+function patchLines(text) {
+	return String(text ?? "").replace(/\r\n?/g, "\n").split("\n");
+}
+
+function indentOf(line) {
+	const m = /^ */.exec(line);
+	return m[0].length;
+}
+
+function isBlankOrComment(line) {
+	const t = line.trim();
+	return t === "" || t.startsWith("#");
+}
+
+/** End of the block starting at `start` (indent `base`): first later line
+ * that is neither blank nor a comment and dedents to `base` or less. */
+function blockEnd(lines, start, base) {
+	for (let i = start + 1; i < lines.length; i++) {
+		if (isBlankOrComment(lines[i])) continue;
+		if (indentOf(lines[i]) <= base) return i;
+	}
+	return lines.length;
+}
+
+function listItemAt(lines, i) {
+	const m = /^(\s*)- id: (\S+)\s*(#.*)?$/.exec(lines[i]);
+	return m ? { indent: m[1].length, id: m[2] } : null;
+}
+
+function findItem(lines, start, end, base, wantId) {
+	for (let i = start; i < end; i++) {
+		if (isBlankOrComment(lines[i])) continue;
+		const item = listItemAt(lines, i);
+		if (item && item.indent === base && item.id === wantId) return i;
+	}
+	return -1;
+}
+
+/** Locate the nested compaction-basic item inside a preset-standard entry
+ * spanning [entryStart, entryEnd). Returns {item, nameLine, configLine} line
+ * indexes (configLine -1 when absent) or throws on unrecognized shape. */
+function locateNestedCompactionBasic(lines, entryStart, entryEnd) {
+	const entryIndent = indentOf(lines[entryStart]);
+	const group = findItem(lines, entryStart, entryEnd, entryIndent + 6, "compaction");
+	if (group < 0) throw new Error("preset-standard has no nested `- id: compaction` group — re-generate it from the installed preset file");
+	const groupEnd = blockEnd(lines, group, indentOf(lines[group]));
+	let configLine = -1;
+	for (let i = group + 1; i < groupEnd; i++) {
+		if (isBlankOrComment(lines[i])) continue;
+		const m = /^(\s*)config:\s*(#.*)?$/.exec(lines[i]);
+		if (m && m[1].length === indentOf(lines[group]) + 2) { configLine = i; break; }
+		if (indentOf(lines[i]) <= indentOf(lines[group])) break;
+	}
+	if (configLine < 0) throw new Error("nested compaction group has no `config:` list — re-generate preset-standard from the installed preset file");
+	const item = findItem(lines, configLine, groupEnd, indentOf(lines[configLine]) + 2, "compaction-basic");
+	if (item < 0) throw new Error("nested compaction group has no `- id: compaction-basic` — re-generate preset-standard from the installed preset file");
+	const itemEnd = blockEnd(lines, item, indentOf(lines[item]));
+	let nameLine = -1, cfgLine = -1;
+	for (let i = item + 1; i < itemEnd; i++) {
+		if (isBlankOrComment(lines[i])) continue;
+		if (indentOf(lines[i]) !== indentOf(lines[item]) + 2) {
+			if (indentOf(lines[i]) <= indentOf(lines[item])) break;
+			continue;
+		}
+		if (/^(\s*)name:\s/.test(lines[i]) && nameLine < 0) nameLine = i;
+		const cm = /^(\s*)config:\s*(#.*)?$/.exec(lines[i]);
+		if (cm && cfgLine < 0) cfgLine = i;
+		else if (/^(\s*)config:\s*\S/.test(lines[i])) {
+			throw new Error("nested compaction-basic has a non-map `config:` — edit it by hand, refusing to guess");
+		}
+	}
+	return { item, itemEnd, nameLine, configLine: cfgLine };
+}
+
+function pad(n) {
+	return " ".repeat(n);
+}
+
+/** Render the modelPolicies value (the `modelPolicies:` line plus its items)
+ * at base indent `base`. Policies carry only headroomTokens: under the core
+ * defaults the per-request reservation still comes from the adapter, and the
+ * existing on-disk entries this merges with carry the same single key. */
+function renderModelPolicies(base, policies) {
+	const out = [pad(base) + "modelPolicies:"];
+	if (policies.length === 0) {
+		out.push(pad(base + 2) + "[]");
+		return out;
+	}
+	for (const p of policies) {
+		out.push(pad(base + 2) + "- provider: " + p.provider);
+		out.push(pad(base + 4) + "model: " + p.model);
+		out.push(pad(base + 4) + "headroomTokens: " + p.headroomTokens);
+	}
+	return out;
+}
+
+function checkPolicy(p) {
+	if (!p || typeof p !== "object") throw new Error("compaction policy must be an object");
+	if (p.provider !== COMPACTION_ROUTER_PROVIDER || !POLICY_ID_RE.test(p.model ?? "")) {
+		throw new Error("bad compaction policy target: " + JSON.stringify(p));
+	}
+	if (!Number.isInteger(p.headroomTokens) || p.headroomTokens < 0) {
+		throw new Error("bad headroomTokens for " + p.model + ": " + String(p.headroomTokens));
+	}
+}
+
+/** Read the nested modelPolicies list from a profile patch text. Returns the
+ * list, [] when the engine entry exists but carries no policies, or null when
+ * there is no usable preset-standard entry at all (nothing to merge with).
+ * Lenient on purpose: diagnostics must never throw. Throws only on tabs. */
+export function readModelPolicies(patchText) {
+	if (typeof patchText !== "string" || patchText.includes("	")) return null;
+	const lines = patchLines(patchText);
+	let entry = -1;
+	for (let i = 0; i < lines.length; i++) {
+		if (isBlankOrComment(lines[i])) continue;
+		const item = listItemAt(lines, i);
+		if (item && item.id === "preset-standard") { entry = i; break; }
+	}
+	if (entry < 0) return null;
+	let loc;
+	try {
+		loc = locateNestedCompactionBasic(lines, entry, blockEnd(lines, entry, indentOf(lines[entry])));
+	} catch {
+		return null;
+	}
+	if (loc.configLine < 0) return [];
+	const cfgIndent = indentOf(lines[loc.configLine]);
+	let mpLine = -1, inlineEmpty = false;
+	for (let i = loc.configLine + 1; i < loc.itemEnd; i++) {
+		if (isBlankOrComment(lines[i])) continue;
+		if (indentOf(lines[i]) < cfgIndent + 2) break;
+		if (indentOf(lines[i]) !== cfgIndent + 2) continue;
+		const m = /^(\s*)modelPolicies:\s*(#.*)?$/.exec(lines[i]);
+		if (m) { mpLine = i; break; }
+		const e = /^(\s*)modelPolicies:\s*\[\]\s*(#.*)?$/.exec(lines[i]);
+		if (e) { inlineEmpty = true; mpLine = i; break; }
+		if (/^(\s*)modelPolicies:\s*\S/.test(lines[i])) return null;
+	}
+	if (mpLine < 0) return [];
+	if (inlineEmpty) return [];
+	const mpIndent = indentOf(lines[mpLine]);
+	const mpEnd = blockEnd(lines, mpLine, mpIndent);
+	const out = [];
+	let cur = null;
+	for (let i = mpLine + 1; i < mpEnd; i++) {
+		if (isBlankOrComment(lines[i])) continue;
+		const pm = /^(\s*)- provider:\s*(\S+)\s*$/.exec(lines[i]);
+		if (pm && pm[1].length === mpIndent + 2) {
+			cur = { provider: pm[2], model: null, headroomTokens: null };
+			out.push(cur);
+			continue;
+		}
+		if (cur && indentOf(lines[i]) === mpIndent + 4) {
+			const mm = /^\s*model:\s*(\S+)\s*$/.exec(lines[i]);
+			if (mm) cur.model = mm[1];
+			const hm = /^\s*headroomTokens:\s*(\S+)\s*$/.exec(lines[i]);
+			if (hm) cur.headroomTokens = Number(hm[1]);
+		}
+	}
+	return out.filter((e) => typeof e.provider === "string" && typeof e.model === "string");
+}
+
+/** Merge desired policies into a profile patch text (or build the
+ * preset-standard entry from the installed preset text when the patch has
+ * none). Returns {text, added, updated, unchanged, created}. Pure: no
+ * filesystem here, so every shape is unit-testable. Throws with an
+ * actionable message on anything unrecognized. */
+export function syncPresetStandardPatch(userPatchText, installedPresetText, policies) {
+	const list = Array.isArray(policies) ? policies : [];
+	for (const p of list) checkPolicy(p);
+	const desired = new Map(list.map((p) => [policyKey(p.provider, p.model), p]));
+	let lines, entry, created = false;
+	if (userPatchText === null || userPatchText === undefined) {
+		if (typeof installedPresetText !== "string" || !installedPresetText.trim()) {
+			throw new Error("no preset-standard entry and the installed preset file was not found — create the entry once from dsh-web-app/presets/standard.patch.yml, then sync maintains it");
+		}
+		if (installedPresetText.includes("	")) throw new Error("installed preset uses tabs — refusing to reindent");
+		const inst = patchLines(installedPresetText);
+		let instEntry = -1;
+		for (let i = 0; i < inst.length; i++) {
+			if (isBlankOrComment(inst[i])) continue;
+			const item = listItemAt(inst, i);
+			if (item && item.id === "preset-standard") { instEntry = i; break; }
+		}
+		if (instEntry < 0) throw new Error("installed preset has no preset-standard entry — refusing to invent one");
+		const instBase = indentOf(inst[instEntry]);
+		const instEnd = blockEnd(inst, instEntry, instBase);
+		lines = inst.slice(instEntry, instEnd).map((l) => {
+			if (isBlankOrComment(l) || l.trim() === "") return l.trim() === "" ? "" : l;
+			if (indentOf(l) < instBase) throw new Error("installed preset dedent failed — refusing to guess");
+			return l.slice(instBase);
+		});
+		entry = 0;
+		created = true;
+	} else {
+		if (typeof userPatchText !== "string" || userPatchText.includes("	")) {
+			throw new Error("profile patch uses tabs — edit the modelPolicies by hand");
+		}
+		lines = patchLines(userPatchText);
+		entry = -1;
+		for (let i = 0; i < lines.length; i++) {
+			if (isBlankOrComment(lines[i])) continue;
+			const item = listItemAt(lines, i);
+			if (item && item.id === "preset-standard") { entry = i; break; }
+		}
+		if (entry < 0) {
+			// Same build as the null-patch path; recursion keeps one code path.
+			const built = syncPresetStandardPatch(null, installedPresetText, policies);
+			const sep = lines.length > 0 && lines[lines.length - 1].trim() !== "" ? [""] : [];
+			const header = [
+				"# Compaction for local models: auto-synced modelPolicies (Start",
+				"# Router keeps this list covering every saved router profile — restart",
+				"# dsh web after a sync. Re-generate after any dsh upgrade touching",
+				"# dsh-web-app/presets/standard.patch.yml.",
+			];
+			return {
+				text: [...lines, ...sep, ...header, ...patchLines(built.text)].join("\n"),
+				added: built.added,
+				updated: built.updated,
+				unchanged: built.unchanged,
+				created: true,
+			};
+		}
+	}
+	const entryEnd = blockEnd(lines, entry, indentOf(lines[entry]));
+	const loc = locateNestedCompactionBasic(lines, entry, entryEnd);
+	const existing = readModelPolicies(lines.join("\n")) ?? [];
+	const have = new Map(existing.map((e) => [policyKey(e.provider, e.model), e.headroomTokens]));
+	const merged = new Map();
+	for (const e of existing) merged.set(policyKey(e.provider, e.model), { provider: e.provider, model: e.model, headroomTokens: e.headroomTokens });
+	const added = [], updated = [], unchanged = [];
+	for (const [key, p] of desired) {
+		if (!have.has(key)) { added.push(p.model); merged.set(key, { ...p }); }
+		else if (have.get(key) !== p.headroomTokens) { updated.push(p.model); merged.set(key, { ...p }); }
+		else unchanged.push(p.model);
+	}
+	const ordered = [...merged.values()].sort((a, b) =>
+		a.provider !== b.provider ? (a.provider < b.provider ? -1 : 1) : a.model < b.model ? -1 : a.model > b.model ? 1 : 0);
+	if (loc.configLine < 0) {
+		const anchor = loc.nameLine >= 0 ? loc.nameLine : loc.item;
+		const base = indentOf(lines[loc.item]) + 2;
+		const insert = [pad(base) + "config:", ...renderModelPolicies(base + 2, ordered)];
+		lines.splice(anchor + 1, 0, ...insert);
+	} else {
+		const cfgIndent = indentOf(lines[loc.configLine]);
+		let mpLine = -1, mpInline = false;
+		for (let i = loc.configLine + 1; i < loc.itemEnd; i++) {
+			if (isBlankOrComment(lines[i])) continue;
+			if (indentOf(lines[i]) < cfgIndent + 2) break;
+			if (indentOf(lines[i]) !== cfgIndent + 2) continue;
+			if (/^(\s*)modelPolicies:\s*(#.*)?$/.test(lines[i])) { mpLine = i; break; }
+			const e = /^(\s*)modelPolicies:\s*\[\]\s*(#.*)?$/.exec(lines[i]);
+			if (e) { mpLine = i; mpInline = true; break; }
+			if (/^(\s*)modelPolicies:\s*\S/.test(lines[i])) {
+				throw new Error("nested modelPolicies has an inline value — edit it by hand, refusing to guess");
+			}
+		}
+		const rendered = renderModelPolicies(cfgIndent + 2, ordered);
+		if (mpLine < 0) {
+			lines.splice(loc.configLine + 1, 0, ...rendered);
+		} else if (mpInline) {
+			lines.splice(mpLine, 1, ...rendered);
+		} else {
+			const mpEnd = blockEnd(lines, mpLine, indentOf(lines[mpLine]));
+			lines.splice(mpLine, mpEnd - mpLine, ...rendered);
+		}
+	}
+	let text = lines.join("\n");
+	if (!text.endsWith("\n")) text += "\n";
+	return { text, added, updated, unchanged, created };
+}
 /** Fixed-MTP ceiling. The tab offers 0-7 and the API clamps here: upstream
  * accepts any `--spec-draft-n-max` and clamps the effective depth to the
  * model's own nextn depth at load. Depth 3 is the measured 16 GiB sweet spot
@@ -1509,6 +1874,14 @@ function createManager() {
 		s.routerMax = ROUTER_MAX;
 		s.autostartRouter = readSettings().autostartRouter;
 		s.autoUnloadMins = readSettings().autoUnloadMins;
+		// Compaction coverage for the daily profile: which saved router models
+		// have a headroom override and which would still loop. Read-only here;
+		// the sync itself runs on router start (and on demand below).
+		try {
+			s.compaction = readCompactionState("web", cachedProfiles());
+		} catch {
+			s.compaction = { profile: "web", error: "unavailable", total: 0, covered: 0, stale: 0, missing: [] };
+		}
 		s.sleepIdleSecs = state.sleepIdleSecs;
 		s.logSize = 0;
 		try { s.logSize = statSync(LOG_PATH).size; } catch { /* no log yet */ }
@@ -1813,6 +2186,199 @@ function writeJsonAtomic(file, value) {
 	renameSync(tmp, file);
 }
 
+function writeTextAtomic(file, text) {
+	mkdirSync(dirname(file), { recursive: true });
+	const tmp = file + ".tmp-" + process.pid;
+	writeFileSync(tmp, text, "utf8");
+	renameSync(tmp, file);
+}
+
+// ---------------------------------------------------------------------------
+// Compaction patch sync (filesystem layer over the pure surgery above).
+//
+// The Start Router button runs this automatically so a newly saved profile
+// can never boot into the compaction loop: every saved router profile gets
+// a modelPolicies headroom override in the profile's cordis.patch.yml,
+// computed from its own ctx. Edits are idempotent (re-running changes
+// nothing), merge-only (entries for removed profiles are kept, never
+// deleted), and always backed up first. Composition applies at dsh boot, so
+// a sync reports needRestart — the running process keeps the old thresholds
+// until then.
+// ---------------------------------------------------------------------------
+
+/** Profile patch file for a dsh profile name. The name charset is the guard:
+ * anything else (including ".." or "/") is rejected instead of joined. */
+export function profilePatchFile(profileName) {
+	if (typeof profileName !== "string" || !/^[a-zA-Z0-9_-]{1,64}$/.test(profileName)) {
+		throw new Error("unknown dsh profile: " + String(profileName));
+	}
+	return join(dshHome(), "profiles", profileName, "cordis.patch.yml");
+}
+
+/** dsh profile names that have a patch file. Best-effort: an unreadable
+ * profiles dir is "no profiles", never a throw (status poll reads this). */
+export function listProfileNames(opts = {}) {
+	const root = join(dshHome(), "profiles");
+	const listDir = opts.listDir ?? readdirSync;
+	let entries;
+	try {
+		entries = listDir(root);
+	} catch {
+		return [];
+	}
+	return entries.filter((n) => /^[a-zA-Z0-9_-]{1,64}$/.test(n));
+}
+
+/** Locate the installed dsh-web-app preset this machine booted from, without
+ * hardcoding any one machine's layout. Sources tried in order: an explicitly
+ * injected path (tests), the resolvable package, then the npm-global
+ * `<prefix>/lib/node_modules/...` layout derived from the `dsh` binary on
+ * PATH and the usual global roots. Returns {path, source} or null. Only
+ * needed when the profile patch has no preset-standard entry yet (merge-only
+ * syncs never touch the installed file). */
+export function locateInstalledStandardPreset(opts = {}) {
+	const isFile = opts.isFile ?? ((p) => {
+		try {
+			return statSync(p).isFile();
+		} catch {
+			return false;
+		}
+	});
+	const exists = opts.exists ?? isFile;
+	const tail = join("@deepseek-ai", "dsh-web-app", "presets", "standard.patch.yml");
+	const tryPath = (p, source) => {
+		if (typeof p === "string" && p && exists(p)) return { path: p, source };
+		return null;
+	};
+	if (typeof opts.resolved === "string" && opts.resolved) {
+		return tryPath(opts.resolved, "resolve");
+	}
+	try {
+		const hit = tryPath(
+			createRequire(import.meta.url).resolve("@deepseek-ai/dsh-web-app/presets/standard.patch.yml"),
+			"resolve",
+		);
+		if (hit) return hit;
+	} catch { /* not importable from here — try the filesystem layouts */ }
+	const roots = [];
+	const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
+	for (const dir of String(pathEnv).split(delimiter)) {
+		const t = dir.trim();
+		if (!t) continue;
+		try {
+			if (isFile(join(t, "dsh"))) roots.push({ dir: join(dirname(t), "lib", "node_modules"), source: "npm-global" });
+		} catch { /* no dsh here */ }
+	}
+	const home = opts.home ?? homedir();
+	if (home) roots.push({ dir: join(home, ".npm-global", "lib", "node_modules"), source: "npm-global" });
+	for (const sys of opts.systemRoots ?? ["/usr/lib/node_modules", "/usr/local/lib/node_modules"]) {
+		roots.push({ dir: sys, source: "system" });
+	}
+	const seen = new Set();
+	for (const r of roots) {
+		for (const base of [join(r.dir, "@deepseek-ai", "dsh"), join(r.dir, "dsh")]) {
+			const candidate = join(base, "node_modules", tail);
+			if (seen.has(candidate)) continue;
+			seen.add(candidate);
+			const hit = tryPath(candidate, r.source);
+			if (hit) return hit;
+		}
+	}
+	return null;
+}
+
+/** On-disk compaction state for one profile: whether its patch covers the
+ * saved router profiles. Never throws — diagnostics must not break the poll. */
+export function readCompactionState(profileName, profiles) {
+	try {
+		const patchFile = profilePatchFile(profileName);
+		let text = null;
+		try {
+			text = readFileSync(patchFile, "utf8");
+		} catch (err) {
+			if (err?.code !== "ENOENT") throw err;
+		}
+		const existing = text === null ? null : readModelPolicies(text);
+		const plan = compactionPlan(profiles, existing);
+		return {
+			profile: profileName,
+			patchFile,
+			patchExists: text !== null,
+			// null = no usable preset-standard entry (unknown coverage);
+			// [] = entry present, no policies yet.
+			policies: existing,
+			plan,
+			covered: plan.filter((p) => p.status === "covered").length,
+			stale: plan.filter((p) => p.status === "stale").length,
+			missing: plan.filter((p) => p.status === "missing").map((p) => p.model),
+			total: plan.length,
+		};
+	} catch (err) {
+		return { profile: profileName, error: err?.message ?? String(err), total: 0, covered: 0, stale: 0, missing: [] };
+	}
+}
+
+/** Merge the desired policies into one profile's patch file. Idempotent,
+ * backup-first, atomic. Throws on unrecognized shape (never half-writes).
+ * `profiles` defaults to the saved store; `allowCreate: false` (the
+ * autostart sweep) skips patches without a preset-standard entry instead of
+ * building one; `dryRun` computes without writing. */
+export function syncCompactionPatch(profileName, opts = {}) {
+	const file = profilePatchFile(profileName);
+	const profiles = opts.profiles !== undefined ? opts.profiles : readProfiles();
+	const allowCreate = opts.allowCreate !== false;
+	const dryRun = opts.dryRun === true;
+	const policies = desiredCompactionPolicies(profiles);
+	let oldText = null;
+	try {
+		oldText = readFileSync(file, "utf8");
+	} catch (err) {
+		if (err?.code !== "ENOENT") throw new Error("cannot read " + file + ": " + (err?.message ?? String(err)));
+	}
+	const hasEntry = typeof oldText === "string" && readModelPolicies(oldText) !== null;
+	let installedText = null;
+	if (oldText === null || !hasEntry) {
+		if (!allowCreate) {
+			return {
+				ok: true, profile: profileName, patchFile: file, created: false, changed: false,
+				backup: null, added: [], updated: [], unchanged: [], skipped: "no preset-standard entry",
+				needRestart: false, policies,
+			};
+		}
+		const found = locateInstalledStandardPreset(opts.locate ?? {});
+		if (!found) {
+			throw new Error("no preset-standard entry in " + file + " and the installed preset file was not found — create the entry once from dsh-web-app/presets/standard.patch.yml, then sync maintains it");
+		}
+		installedText = readFileSync(found.path, "utf8");
+	}
+	const synced = syncPresetStandardPatch(oldText, installedText, policies);
+	if (synced.text === (oldText ?? "")) {
+		return {
+			ok: true, profile: profileName, patchFile: file, created: synced.created, changed: false,
+			backup: null, added: [], updated: [], unchanged: synced.unchanged, needRestart: false, policies,
+		};
+	}
+	if (dryRun) {
+		return {
+			ok: true, profile: profileName, patchFile: file, created: synced.created, changed: true,
+			backup: null, added: synced.added, updated: synced.updated, unchanged: synced.unchanged,
+			needRestart: true, policies, text: synced.text,
+		};
+	}
+	let backup = null;
+	if (oldText !== null) {
+		backup = file + ".bak-" + new Date().toISOString().replace(/[:.]/g, "-");
+		mkdirSync(dirname(file), { recursive: true });
+		copyFileSync(file, backup);
+	}
+	writeTextAtomic(file, synced.text);
+	return {
+		ok: true, profile: profileName, patchFile: file, created: synced.created, changed: true,
+		backup, added: synced.added, updated: synced.updated, unchanged: synced.unchanged,
+		needRestart: true, policies,
+	};
+}
+
 function writeProfiles(list) {
 	writeJsonAtomic(profilesFile(), list);
 	presetsCache = list;
@@ -2468,6 +3034,13 @@ export function apply(ctx) {
 			path: "/local-models/router/start",
 			handler: async (req, res) => {
 				if (req.method !== "POST") { sendJson(res, 405, { error: "POST required" }); return; }
+				let body = {};
+				try {
+					body = JSON.parse((await readBody(req)) || "{}");
+				} catch {
+					sendJson(res, 400, { error: "invalid JSON body" });
+					return;
+				}
 				let profiles;
 				try {
 					profiles = readProfiles();
@@ -2476,13 +3049,76 @@ export function apply(ctx) {
 					return;
 				}
 				if (profiles.length === 0) { sendJson(res, 400, { error: "save at least one profile first" }); return; }
+				// Compaction guard first: every saved router profile gets its
+				// headroom override synced into the profile patch, so the next
+				// dsh boot cannot compact-loop on it. Best-effort — a sync
+				// failure is reported, never a start failure. Opt out with
+				// { compactionSync: false }; target another dsh profile with
+				// { compactionProfile: "<name>" } (default "web").
+				let compactionSync = null;
+				if (body.compactionSync !== false) {
+					const target = typeof body.compactionProfile === "string" && body.compactionProfile
+						? body.compactionProfile
+						: "web";
+					try {
+						compactionSync = syncCompactionPatch(target, { profiles, allowCreate: true });
+					} catch (err) {
+						compactionSync = { ok: false, profile: target, error: err?.message ?? String(err) };
+					}
+				}
 				try {
 					mkdirSync(dataDir(), { recursive: true });
 					writeFileSync(ROUTER_PRESETS_FILE, generateRouterPresets(profiles), "utf8");
 					const result = await manager.startRouter(ROUTER_PRESETS_FILE);
-					sendJson(res, result.ok ? 200 : 409, { ok: result.ok, error: result.error, presets: profiles.length, iniPath: ROUTER_PRESETS_FILE });
+					sendJson(res, result.ok ? 200 : 409, { ok: result.ok, error: result.error, presets: profiles.length, iniPath: ROUTER_PRESETS_FILE, compactionSync });
+				} catch (err) {
+					sendJson(res, 500, { error: err?.message ?? String(err), compactionSync });
+				}
+			},
+		},
+		{
+			// Compaction coverage diagnostics: per-profile default threshold vs
+			// the on-disk override. Query ?profile=<name> (default "web").
+			kind: "exact",
+			path: "/local-models/compaction",
+			handler: async (req, res) => {
+				const url = new URL(req.url ?? "/", "http://x");
+				const target = url.searchParams.get("profile") || "web";
+				let profiles;
+				try {
+					profiles = readProfiles();
 				} catch (err) {
 					sendJson(res, 500, { error: err?.message ?? String(err) });
+					return;
+				}
+				try {
+					profilePatchFile(target); // name charset first: 400, not a state error
+					sendJson(res, 200, readCompactionState(target, profiles));
+				} catch (err) {
+					sendJson(res, 400, { error: err?.message ?? String(err) });
+				}
+			},
+		},
+		{
+			// On-demand compaction sync. Body { profile = "web", dryRun = false }:
+			// dryRun previews { added, updated, text } without writing.
+			kind: "exact",
+			path: "/local-models/compaction/sync",
+			handler: async (req, res) => {
+				if (req.method !== "POST") { sendJson(res, 405, { error: "POST required" }); return; }
+				let body;
+				try {
+					body = JSON.parse((await readBody(req)) || "{}");
+				} catch {
+					sendJson(res, 400, { error: "invalid JSON body" });
+					return;
+				}
+				const target = typeof body.profile === "string" && body.profile ? body.profile : "web";
+				try {
+					const report = syncCompactionPatch(target, { allowCreate: true, dryRun: body.dryRun === true });
+					sendJson(res, 200, report);
+				} catch (err) {
+					sendJson(res, 400, { error: err?.message ?? String(err) });
 				}
 			},
 		},
@@ -2610,6 +3246,20 @@ export function apply(ctx) {
 			note("starting router (" + profiles.length + " profiles)...");
 			mkdirSync(dataDir(), { recursive: true });
 			writeFileSync(ROUTER_PRESETS_FILE, generateRouterPresets(profiles), "utf8");
+			// Compaction guard, update-only: keep every profile patch that
+			// already carries a preset-standard entry covering the saved
+			// router models (never create entries here — boot must not invent
+			// composition; the tab's Start Router does the full sync).
+			for (const name of listProfileNames()) {
+				try {
+					const r = syncCompactionPatch(name, { profiles, allowCreate: false });
+					if (r.changed) {
+						note("compaction sync (" + name + "): +" + r.added.length + " ~" + r.updated.length + " (restart dsh to apply)");
+					}
+				} catch (err) {
+					note("compaction sync (" + name + ") skipped: " + (err?.message ?? String(err)));
+				}
+			}
 			const result = await manager.startRouter(ROUTER_PRESETS_FILE);
 			if (!result.ok) {
 				note("router failed to start: " + (result.error ?? "unknown error"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-local-models",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "dsh addon: a Local Models settings tab that starts and stops a llama-server child process living with the dsh host process.",
   "type": "module",
   "main": "lib/index.js",

package/skills/dsh-local-models-ops/SKILL.md

@@ -127,6 +127,12 @@ is wholesale, the row freezes: re-generate after any dsh upgrade that
 touches the preset file, or upstream changes to that preset are silently
 dropped. Only patch presets actually used (`standard` here); `ptc` /
 `cordis` / `minimal` need the same treatment if adopted.
+**Since 0.5.0 this manual path is the fallback: `POST
+/local-models/router/start` runs `syncCompactionPatch()` automatically
+(merge-only, idempotent, backup-first; `GET /local-models/compaction`
+for diagnostics, `POST /local-models/compaction/sync` on demand), so a
+newly saved profile can no longer boot uncovered — the remaining manual
+step is the `dsh web` restart that composition requires.**
 
 Shortcut with zero config edits: run the bigger window instead — the
 200K/250K profiles threshold at ~106K/158K under defaults.