dsh-switchman 1.11.0 → 1.11.2

package/host/context-trim/summarizer.js

@@ -225,13 +225,15 @@ function describeFailure(chunk) {
 }
 
 /** Side-model summary. llm: the dsh llm service (receiver-bound methods);
- * route: { provider, model } | null (null → caller skips); materialText:
- * renderMaterial output; options.systemPrompt overrides the default
+ * route: { provider, model, effort? } | null (null → caller skips); materialText:
  * compression prompt (the ladder distillation passes its own); deadlineMs:
  * hard budget. Returns the summary text, or null on ANY failure (caller
  * skips the fold cycle). */
 export async function summarizeWithModel(llm, route, materialText, options = {}) {
 	const fail = typeof options.onFail === "function" ? options.onFail : null;
+	// Effort-retry notice: fires BEFORE the low-pinned retry, whether or not
+	// the retry lands. Falls back to fail when the caller doesn't supply one.
+	const notice = typeof options.onNotice === "function" ? options.onNotice : null;
 	if (route === null || route === undefined) { fail?.("no-route"); return null; }
 	if (typeof llm?.prepareCall !== "function") { fail?.("no-prepare-call"); return null; }
 	const deadlineMs = Number.isFinite(options.deadlineMs) && options.deadlineMs > 0 ? options.deadlineMs : SUMMARY_TIMEOUT_MS;
@@ -240,11 +242,40 @@ export async function summarizeWithModel(llm, route, materialText, options = {})
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(new Error("trim summary deadline")), deadlineMs);
 	try {
-		const call = await llm.prepareCall(
-			{ provider: route.provider, model: route.model, maxTokens },
-			controller.signal,
-			(controls) => controls,
-		);
+		// Effort policy: inherit the route's effort verbatim when it carries
+		// one (session-inherited routes carry the session's own DSH-resolved
+		// effort; explicit trimSideModel configs may pin theirs), else pin
+		// "low" — summaries are auxiliary work. NEVER send without an effort,
+		// and never send "off": pi-ai maps both to thinking:{type:"disabled"}
+		// (profileOptions turns "off" back into an absent reasoning option),
+		// which newer Anthropic endpoints reject with 400. A DSH session run
+		// with thinking disabled resolves its effort to "off", so an inherited
+		// route can carry exactly that value — treat it like empty here.
+		// The effort rides the prepareCall proposal so it resolves into
+		// call.config, keeping stream options consistent with the prepared
+		// call (INVALID_PREPARED_CALL guard).
+		const requestedEffort = typeof route.effort === "string" && route.effort !== "" && route.effort !== "off" ? route.effort : "low";
+		let call;
+		try {
+			call = await llm.prepareCall(
+				{ provider: route.provider, model: route.model, maxTokens, reasoningEffort: requestedEffort },
+				controller.signal,
+				(controls) => controls,
+			);
+		} catch (prepareError) {
+			// An inherited session effort can exceed what the route's adapter
+			// supports: retry once pinned low before giving up (the outer
+			// catch then turns the failure into a skipped fold cycle).
+			const code = prepareError?.code ?? null;
+			const named = typeof prepareError?.message === "string" && prepareError.message.includes("UNSUPPORTED_REASONING_EFFORT");
+			if (requestedEffort === "low" || (code !== "UNSUPPORTED_REASONING_EFFORT" && !named)) throw prepareError;
+			(notice ?? fail)?.(`effort "${requestedEffort}" unsupported, retrying low`);
+			call = await llm.prepareCall(
+				{ provider: route.provider, model: route.model, maxTokens, reasoningEffort: "low" },
+				controller.signal,
+				(controls) => controls,
+			);
+		}
 		let text = "";
 		let finishKind = null;
 		// stream options MUST carry the prepared call config — the adapter

package/host/context-trim/trigger.js

@@ -132,7 +132,7 @@ export function evaluateTrigger(input) {
 	// Side-model folds (pressure + growth + ladder) share the cadence gates.
 	const lastFoldAt = Number.isFinite(input?.lastFoldAt) ? input.lastFoldAt : 0;
 	const hourly = Array.isArray(input?.foldsThisHour) ? input.foldsThisHour.filter((ts) => now - ts < 3_600_000).length : 0;
-	const maxFoldsPerHour = Number.isInteger(thresholds.maxFoldsPerHour) && thresholds.maxFoldsPerHour > 0 ? thresholds.maxFoldsPerHour : 16;
+	const maxFoldsPerHour = Number.isInteger(thresholds.maxFoldsPerHour) && thresholds.maxFoldsPerHour > 0 ? thresholds.maxFoldsPerHour : 30;
 	const hourlyBlocked = hourly >= maxFoldsPerHour;
 
 	if (foldable !== null && incrementTokens >= 1) {
@@ -187,7 +187,7 @@ export function evaluateTrigger(input) {
 		}
 		if (!hourlyBlocked && now - lastFoldAt >= FOLD_MIN_INTERVAL_MS) {
 			// Tier b — pressure: soft window threshold, side-model.
-			const pressurePercent = Number.isFinite(thresholds.pressurePercent) && thresholds.pressurePercent > 0 ? thresholds.pressurePercent : 60;
+			const pressurePercent = Number.isFinite(thresholds.pressurePercent) && thresholds.pressurePercent > 0 ? thresholds.pressurePercent : 65;
 			if (windowTokens !== null) {
 				const usagePct = (input.viewTokens / windowTokens) * 100;
 				if (usagePct >= pressurePercent) {
@@ -196,7 +196,7 @@ export function evaluateTrigger(input) {
 			}
 			// Tier a — growth gate: the primary cache-friendly heuristic.
 			const growthTokens = Number.isFinite(thresholds.growthTokens) && thresholds.growthTokens > 0 ? thresholds.growthTokens : 22_500;
-			const incrementGate = Number.isFinite(thresholds.incrementTokens) && thresholds.incrementTokens > 0 ? thresholds.incrementTokens : 50_000;
+			const incrementGate = Number.isFinite(thresholds.incrementTokens) && thresholds.incrementTokens > 0 ? thresholds.incrementTokens : 25_000;
 			// Growth anchor: the post-fold low when known (keeps the gate armed
 			// after folds that commit at high view points), else the pre-fold
 			// view for ledgers written before lastFoldLowTokens existed.

package/host/context-watch.js

@@ -53,7 +53,7 @@ import { appendFileSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { clearHandover, handoverOf, recordHandover } from "./handover-state.js";
 import { enumerateLiveSubagents, sessionRecordPath, sessionRecordsDir } from "./subagents.js";
-import { recentTrimPromptTokensOf } from "./context-trim/index.js";
+import { recentTrimModelOf, recentTrimPromptTokensOf } from "./context-trim/index.js";
 
 /** Tools whose result text is accounted against the per-turn read budget. */
 const ACCOUNT_TOOLS = new Set(["read", "glob", "grep", "bash"]);
@@ -154,8 +154,9 @@ export function measureNow(ctx, agent) {
 		// longer receives — high bias), while the bare view never counts the
 		// system/tool sections (low bias). max(view, wire) fixes both and puts
 		// the watermark tiers (soft/hard/force + read budget) on the SAME
-		// boundary as the fold engine — wmHardTokens 95k ≙ trim pressure 90k
-		// (c453b91) holds in units, not just in numbers. Strictly additive +
+		// boundary as the fold engine — wmHardTokens 95k ≈ trim pressure
+		// 97.5k (65% of the 150k window) — holds in units, not just in
+		// numbers. Strictly additive +
 		// fail-open: any trim failure falls back to the stored measure.
 		try {
 			const sessionId = agent?.session?.id ?? (typeof agent?.id === "string" ? agent.id : null);
@@ -240,6 +241,69 @@ function renderSubWatermark(level) {
 	);
 }
 
+/** Freshness TTL for resolved subagent model windows (same cadence as the
+ *  trim engine's windowCache: 10 minutes, negative results cached too). */
+const SUB_WINDOW_TTL_MS = 600_000;
+
+/** Synchronously read the resolved context window (tokens) of the model a
+ *  subagent session is running on, or null when unknown/stale. On a cache
+ *  miss it primes the resolution in the background and returns null — the
+ *  first render falls back to the static tiers (fail-open), later renders
+ *  see the scaled tiers. Resolution goes through ctx.get("llm").
+ *  resolveModelInfo, the same DSH channel the trim engine uses. */
+function subagentWindowTokens(ctx, state, sessionId) {
+	try {
+		const route = recentTrimModelOf(sessionId);
+		if (route === null) return null;
+		const key = `${route.provider}/${route.model}`;
+		const now = Date.now();
+		const entry = state.subWindow.get(key);
+		if (entry !== undefined && now - entry.at < SUB_WINDOW_TTL_MS) return entry.value;
+		if (entry === undefined || entry.priming !== true) {
+			// Occupy the slot so concurrent renders do not fan out resolutions;
+			// at=0 keeps the read path treating it as a miss until primed.
+			state.subWindow.set(key, { value: null, at: 0, priming: true });
+			void primeSubagentWindow(ctx, state, route, key);
+		}
+		return null;
+	} catch {
+		return null;
+	}
+}
+
+/** Async window resolution backing subagentWindowTokens; stores the raw
+ *  resolved window (null when unknown — negative-cached for the same TTL). */
+async function primeSubagentWindow(ctx, state, route, key) {
+	try {
+		const llm = ctx.get?.("llm", false);
+		const info = await llm?.resolveModelInfo?.({ provider: route.provider, model: route.model });
+		const windowTokens = info?.context?.contextWindow;
+		const value = Number.isFinite(windowTokens) && windowTokens > 0 ? windowTokens : null;
+		state.subWindow.set(key, { value, at: Date.now() });
+		if (state.subWindow.size > 200) state.subWindow.delete(state.subWindow.keys().next().value);
+	} catch {
+		state.subWindow.set(key, { value: null, at: Date.now() });
+	}
+}
+
+/** Pure subagent tier scaling (exported for tests): cap force at
+ *  windowTokens × ratio and shrink soft/hard by the same factor (floored at
+ *  1000/2000) so tier spacing and ordering survive the shrink. Tighten-only:
+ *  a null/non-positive window, a cap ≥ the input force, or a cap below 3000
+ *  returns the tiers unchanged (fail-open). */
+export function scaleSubagentTiers(th, windowTokens, ratio) {
+	const subTh = { ...th };
+	if (!Number.isFinite(windowTokens) || windowTokens <= 0) return subTh;
+	const cap = Math.floor(windowTokens * ratio);
+	if (cap < subTh.force && cap >= 3000) {
+		const factor = cap / subTh.force;
+		subTh.soft = Math.max(1000, Math.floor(subTh.soft * factor));
+		subTh.hard = Math.max(2000, Math.floor(subTh.hard * factor));
+		subTh.force = cap;
+	}
+	return subTh;
+}
+
 /** Whole live line for one assembly (the tail context); "" whenever anything
  * needed is missing or the session sits at the silent ok tier. */
 function renderWatermarkContext(ctx, config, state, agent) {
@@ -249,16 +313,25 @@ function renderWatermarkContext(ctx, config, state, agent) {
 		const th = readThresholds(config);
 		const used = measureNow(ctx, agent);
 		if (used === null) return "";
-		const level = levelOf(used, th);
-		if (level === "ok") return "";
 		if (!isRoot(ctx, agent)) {
-			// Subagents share the root soft/hard thresholds; the optional
-			// wmSubagentForceTokens override replaces only the force tier
-			// (enabled by the wmSubagentCap toggle, 0/0 = follow the root set).
+			// Subagent tiers: root baseline, optional static force override, then
+			// capped by the subagent's OWN model window (ratio × window), so a
+			// small-window child model gets proportionally earlier tiers instead
+			// of inheriting tiers sized for the root model. Scaling can only
+			// TIGHTEN (min), never loosen; soft/hard shrink by the same factor to
+			// preserve tier spacing. Window resolution is async, so the render
+			// path reads a primed cache and primes in the background on miss —
+			// first renders fall back to the static tiers (fail-open).
 			const subForce = readBool(config.wmSubagentCap, true) ? readNumber(config.wmSubagentForceTokens, 0) : 0;
-			const subTh = subForce > 0 ? { ...th, force: subForce } : th;
+			const subTh = scaleSubagentTiers(
+				subForce > 0 ? { ...th, force: subForce } : { ...th },
+				subagentWindowTokens(ctx, state, sessionId),
+				readNumber(config.wmSubagentWindowRatio, 0.75),
+			);
 			return renderSubWatermark(levelOf(used, subTh));
 		}
+		const level = levelOf(used, th);
+		if (level === "ok") return "";
 		if (state.paused.has(sessionId)) return PAUSED_LINE;
 		const live = handoverOf(sessionId);
 		const elapsed = Date.now() - (state.lastHandover.get(sessionId) ?? 0);
@@ -332,6 +405,7 @@ function applyContextWatch(ctx, config) {
 		handoverTool: null,
 		lastHandover: new Map(),
 		readUsed: new Map(),
+		subWindow: new Map(), // "provider/model" -> { value: number|null, at } — resolved subagent model windows (see subagentWindowTokens)
 	};
 	const warn = (message) => ctx.logger?.warn?.(`dsh-switchman: ${message}`);
 

package/host/dispatch.js

@@ -15,7 +15,14 @@
  * pushes the caller back to implicit dispatch — silently losing the lane's
  * route. The sanitation denies such calls with the exact corrected
  * arguments instead (exec.arguments is deep-frozen by the runtime, so a
- * deny is the only correction channel `tools/pre-execute` offers).
+ * deny is the only correction channel `tools/pre-execute` offers). The
+ * same pass covers the field-shape failures production logs show models
+ * repeating (a merged "provider/model" string with the provider field
+ * omitted, a bare model with the provider field omitted, a model still
+ * carrying its "provider/" prefix, and a provider-less
+ * list_subagent_models call) — every such call is rejected by DSH
+ * outright, so each deny carries the exact corrected fields and turns
+ * 2-4 blind retries into one immediate re-dispatch.
  *
  * Model-facing text is English and byte-stable for a given configuration
  * (the anchor line never varies with UI locale). All reads go through the
@@ -284,15 +291,242 @@ function annotationFixOf(args, config) {
 	);
 }
 
+/** Every configured {provider, model} route across all lanes and
+ *  modelRank, in config order. Unlike configuredRoutes (whose folded key
+ *  is first-wins per model segment — right for route MATCHING, where
+ *  duplicates would collapse), this keeps every entry: provider-candidate
+ *  hints must see all providers offering the same model id. */
+function allConfiguredRoutes(config) {
+	const routes = [];
+	const add = (route) => {
+		if (isModelRoute(route)) routes.push(route);
+	};
+	for (const lane of LANES) for (const route of readList(config[laneField(lane)])) add(route);
+	for (const entry of readList(config.modelRank)) add(entry);
+	return routes;
+}
+
+/** Distinct configured providers whose folded model key matches one bare
+ *  model id, in config order — completes a corrective hint for a
+ *  delegation or enumeration call that omitted the provider field. */
+function modelProviderMatches(config, model) {
+	const key = normalizeModelKey("", model);
+	if (key === "") return [];
+	const seen = new Set();
+	const providers = [];
+	for (const route of allConfiguredRoutes(config)) {
+		if (normalizeModelKey("", route.model) !== key || seen.has(route.provider)) continue;
+		seen.add(route.provider);
+		providers.push(route.provider);
+	}
+	return providers;
+}
+
+/** Canonical pool spelling for a folded model-id hit (caller casing
+ *  and annotation tail vary); the trimmed input when no pool route
+ *  folds to it. */
+function canonicalPoolModel(config, providers, model) {
+	const hit = allConfiguredRoutes(config).find(
+		(route) =>
+			providers.includes(route.provider) &&
+			normalizeModelKey("", route.model) === normalizeModelKey("", model),
+	);
+	return hit !== undefined ? hit.model : model;
+}
+
+/** Corrective deny reason for one delegation call whose provider/model
+ *  field SPLIT is malformed, or null to pass through. Covers the field
+ *  failures observed in production session logs (each burned 2-4 blind
+ *  retries before a manual fix):
+ *
+ *  - provider omitted, model a merged "provider/model" string: DSH rejects
+ *    EVERY such call with "`provider` and `model` must be supplied
+ *    together" before any route check, so denying with the split fields is
+ *    a strict improvement even when the split is not a configured route —
+ *    a deliberate exception to the annotated-copy rule that unknown ids
+ *    pass through (that rule protects calls DSH would ACCEPT; these can
+ *    never succeed);
+ *  - provider given, model still carrying that same "provider/" prefix:
+ *    DSH joins provider + "/" + model itself, so the resolved route
+ *    double-encodes the provider and misses the exact-match whitelist;
+ *  - provider omitted, model a bare id: resolved against the pool table —
+ *    exactly one configured provider → the pair; several → the candidate
+ *    list; none → pass through (DSH's own error already says what's wrong);
+ *  - provider given, model naming a DIFFERENT provider's configured route:
+ *    denied with that route's pair; anything else passes untouched. */
+function routeFixOf(args, config) {
+	const model = typeof args?.model === "string" ? args.model.trim() : "";
+	if (model === "") return null;
+	const providerGiven = typeof args?.provider === "string" && args.provider.trim() !== "";
+	const provider = providerGiven ? args.provider.trim() : "";
+
+	// Provider given, model still prefixed: the double-encoded route can
+	// never match the exact whitelist, so the correction is unconditional.
+	if (providerGiven && model.startsWith(`${provider}/`)) {
+		const fixed = model.slice(provider.length + 1).trim();
+		if (fixed === "" || fixed.includes("/")) return null;
+		return (
+			`[SWITCHMAN:POOLS] the model argument already carries the provider prefix — DSH joins provider + "/" + model itself, so this call resolves to the route "${provider}/${model}" and is rejected. ` +
+			`Re-dispatch with provider "${provider}", model "${fixed}", keeping every other argument unchanged.`
+		);
+	}
+
+	const cut = model.lastIndexOf("/");
+
+	// Provider given, model names another provider's configured route.
+	if (providerGiven && cut > 0) {
+		const prefix = model.slice(0, cut).trim();
+		const known =
+			prefix === ""
+				? undefined
+				: allConfiguredRoutes(config).find(
+					(route) =>
+						route.provider.toLowerCase() === prefix.toLowerCase() &&
+						normalizeModelKey("", route.model) === normalizeModelKey("", model.slice(cut + 1).trim()),
+				);
+		// No configured route under that prefix: not a shape we can correct
+		// — pass through for DSH's own rejection, without tripping the
+		// fail-open catch.
+		if (known === undefined) return null;
+		return (
+			`[SWITCHMAN:POOLS] the model argument embeds another provider's route — with provider "${provider}" this resolves to "${provider}/${model}", which no authorized route matches. ` +
+			`Re-dispatch with provider "${known.provider}", model "${known.model}", keeping every other argument unchanged.`
+		);
+	}
+
+	if (providerGiven) return null;
+
+	// Provider omitted, merged "provider/model" string: always rejected by
+	// DSH (both fields are required together), deny with the split fields.
+	if (cut > 0) {
+		// A merged copy of the already-prefixed id ("prov/prov/model") —
+		// the repeated head segment is the giveaway; recommend the inner
+		// pair directly. Other mid-slash shapes stay uncorrectable.
+		const segments = model.split("/");
+		const doubled =
+			segments.length === 3 &&
+			segments[0].trim().toLowerCase() === segments[1].trim().toLowerCase();
+		const providerFix = (doubled ? segments[0] : model.slice(0, cut)).trim();
+		const modelFix = stripTrailingAnnotations((doubled ? segments[2] : model.slice(cut + 1)).trim());
+		// Segments still malformed after the split (a mid-slash provider,
+		// a leading-slash or nested model) cannot be corrected into a call
+		// DSH would accept — pass through.
+		if (
+			providerFix === "" ||
+			modelFix === "" ||
+			providerFix.includes("/") ||
+			modelFix.includes("/")
+		)
+			return null;
+		const matched = allConfiguredRoutes(config).find(
+			(route) =>
+				route.provider.toLowerCase() === providerFix.toLowerCase() &&
+				normalizeModelKey("", route.model) === normalizeModelKey("", modelFix),
+		);
+		// Recommend the pool's canonical spelling on a folded hit so
+		// case-variant or annotated copies resolve on the first retry.
+		const shownProvider = matched !== undefined ? matched.provider : providerFix;
+		const shownModel = matched !== undefined ? matched.model : modelFix;
+		const note =
+			matched === undefined
+				? `If "${shownProvider}/${shownModel}" is not authorized for this session, the re-dispatch error will say so precisely.`
+				: `This is the configured pool route ${shownProvider}/${shownModel}.`;
+		return (
+			`[SWITCHMAN:POOLS] the model argument merges provider and model into one string — subagent calls take SEPARATE provider and model fields, and DSH rejects every call that omits either. ` +
+			`Re-dispatch with provider "${shownProvider}", model "${shownModel}", keeping every other argument unchanged. ${note}`
+		);
+	}
+
+	// A leading "/" (cut === 0) is malformed beyond folding: the pool
+	// matcher would silently strip it and recommend the malformed id back.
+	// Pass through and let DSH's own schema error surface.
+	if (cut === 0) return null;
+
+	// Provider omitted, bare model id: resolve the provider from the pool
+	// table; pass through when the id names no configured provider.
+	const providers = modelProviderMatches(config, model);
+	if (providers.length === 0) return null;
+	const shownModel = canonicalPoolModel(config, providers, model);
+	if (providers.length === 1) {
+		return (
+			`[SWITCHMAN:POOLS] the provider field is missing — subagent calls take SEPARATE provider and model fields, and DSH rejects every call that omits either. ` +
+			`The model id "${model}" is configured under exactly one provider. Re-dispatch with provider "${providers[0]}", model "${shownModel}", keeping every other argument unchanged.`
+		);
+	}
+	return (
+		`[SWITCHMAN:POOLS] the provider field is missing and the model id "${model}" is configured under several providers (${providers.join(", ")}). ` +
+		`Re-dispatch with one of those providers as the provider field, model "${shownModel}", keeping every other argument unchanged.`
+	);
+}
+
+/** Corrective deny reason for a malformed list_subagent_models call, or
+ *  null to pass through. DSH's own schema rejects {} and {model}-only
+ *  calls with a bare "`provider` must be non-empty"; production logs show
+ *  that error costing 2-4 blind probes (empty, empty, provider-only,
+ *  provider+model). One deny carrying the pool table's provider list
+ *  turns that into a single corrected call. provider-given calls always
+ *  pass. */
+function enumerationFixOf(args, config) {
+	const provider = typeof args?.provider === "string" ? args.provider.trim() : "";
+	if (provider !== "") return null;
+	const model = typeof args?.model === "string" ? args.model.trim() : "";
+	if (model === "") {
+		const providers = [...new Set(allConfiguredRoutes(config).map((route) => route.provider))];
+		const list = providers.length > 0 ? ` Providers configured on this session's pools: ${providers.join(", ")}.` : "";
+		return (
+			`[SWITCHMAN:POOLS] list_subagent_models requires a non-empty provider — a call without one is rejected, not a listing of everything. ` +
+			`Call it with {"provider":"<provider>"} to enumerate that provider's selectable models, then add "model" for one route's details.${list}`
+		);
+	}
+	const providers = modelProviderMatches(config, model);
+	if (providers.length === 0) return null;
+	const shownModel = canonicalPoolModel(config, providers, model);
+	if (providers.length === 1) {
+		return (
+			`[SWITCHMAN:POOLS] list_subagent_models requires a non-empty provider. The model id "${model}" is configured under exactly one provider — ` +
+			`call it with provider "${providers[0]}", model "${shownModel}" for that route's details.`
+		);
+	}
+	return (
+		`[SWITCHMAN:POOLS] list_subagent_models requires a non-empty provider. The model id "${model}" is configured under several providers (${providers.join(", ")}) — ` +
+		`call it with one of those providers as the provider field, model "${shownModel}".`
+	);
+}
+
+/** The assembling session's own route, from the DSH agent-loop's assemble
+ *  context (`agent.ts` passes `modelSelection` with every turn assembly;
+ *  older builds and non-agent assemblies omit it). Null when absent or
+ *  malformed — the session-route line then does not render (fail-open,
+ *  like every capability read in this file family). */
+function sessionRouteOf(context) {
+	const route = context === null || typeof context !== "object" ? undefined : context.modelSelection;
+	if (route === null || typeof route !== "object") return null;
+	const provider = typeof route.provider === "string" ? route.provider.trim() : "";
+	const model = typeof route.model === "string" ? route.model.trim() : "";
+	if (provider === "" || model === "") return null;
+	const effort = typeof route.reasoningEffort === "string" && route.reasoningEffort !== "" ? route.reasoningEffort : null;
+
+	return { provider, model, effort };
+}
+
+
 /** The `[SWITCHMAN:POOLS]` block: anchor line, one line per configured lane,
  *  then the guidance lines (byte-stable for a given configuration). Routes
  *  outside the session's DSH-authorized child models carry a ⚠not-authorized
  *  marker (after any @effort suffix) — teams mode only: with teamsMode OFF
  *  the whitelist is never read, `state.authorized` stays null, and neither
- *  the markers nor the drift guidance lines render. */
-function renderPoolsBlock(state) {
+ *  the markers nor the drift guidance lines render. When the assembling
+ *  context carries the session's own model selection, a `session route:`
+ *  line follows the anchor. */
+function renderPoolsBlock(state, sessionRoute = null) {
 	const configured = state.lanePools.filter((pool) => pool.routes.length > 0);
 	const lines = [`[SWITCHMAN:POOLS] configured=${configured.length}/6 enforce=${state.enforce}`];
+	if (sessionRoute !== null) {
+		lines.push(
+			`session route: ${sessionRoute.provider}/${sessionRoute.model}${sessionRoute.effort === null ? "" : `@${sessionRoute.effort}`}` +
+				` — implicit dispatch (omitting provider/model/effort) gives the child THIS route; when it differs from the lane entries, only an explicit dispatch lands a lane model.`,
+		);
+	}
 	let anyUnauthorized = false;
 	for (const pool of state.lanePools) {
 		if (pool.routes.length === 0) continue;
@@ -315,9 +549,11 @@ function renderPoolsBlock(state) {
 		`Lanes marked * are in manual order: dispatch follows the listed order exactly (the head is the first choice).`,
 		`effort: economy=medium mechanical=medium main=medium (high for complex tasks) hard=high vision=multimodal-capable model review=high; an unconfigured lane uses the system default model.`,
 		`Entries render as provider/model(TIER)@effort: (TIER) is the S/A/B/C capability grade and @effort a manually pinned reasoning effort — both are display-only annotations, NEVER parts of the model id.`,
-		`Decompose before dispatching: provider/model(TIER)@effort → provider=provider, model=model, reasoning_effort=effort (a pin overrides the lane default); a route without @effort carries no per-route pin — fall back to the lane's default effort above.`,
+		`Decompose into SEPARATE tool fields: provider/model(TIER)@effort → {"provider":"<provider>","model":"<model>","reasoning_effort":"<effort>"} (a pin overrides the lane default; a route without @effort carries no per-route pin — fall back to the lane's default effort above).`,
+		`The table cell is ONE display string, never a field value: "model":"provider/model" (provider field omitted) is rejected, and model NEVER carries a "provider/" prefix — DSH joins provider + "/" + model itself, so a prefixed model double-encodes the provider and misses the whitelist.`,
 		`Review delegations: anchor independence on the code AUTHOR's model, not the main session's (author = the agent that produced the diff: its explicit dispatch route, or the inherited session model when unspecified). Prefer a reviewer model different from the author's; also avoiding the session model is a bonus (its integration pass already covers that angle). If no pool entry differs from the author, same-model review is allowed — declare DOWNGRADED and state whether it is relative to the author or the session.`,
-		`Explicit provider/model/effort on subagent/workflow calls is validated against this session's DSH-authorized child models (DSH Settings: allow agents to choose subagent models) — NOT against this table; when denied, discover allowed routes via list_subagent_models, or dispatch implicitly by omitting all three fields (the child then uses configured defaults or inherits the parent route).`,
+		`Explicit lane dispatch is the DEFAULT for subagent/workflow: name provider+model+reasoning_effort decomposed from the lane row (validated against this session's DSH-authorized child models — DSH Settings: allow agents to choose subagent models — NOT against this table). Implicit dispatch (omitting all three fields) is a LAST-RESORT fallback, never a shortcut: use it only after an explicit attempt was denied or list_subagent_models confirmed no authorized route, and declare IMPLICIT-DOWNGRADED in your report when you do — the child then uses configured defaults or inherits the parent route, so the lane's model is lost.`,
+		`list_subagent_models verifies authorized routes before dispatching: {"provider":"<provider>"} lists that provider's models, {"provider":"<provider>","model":"<model>"} returns one route's details — {} and {"model"} alone are rejected (provider is required and non-empty).`,
 	);
 	if (anyUnauthorized) {
 		lines.push(
@@ -353,11 +589,11 @@ function applyDispatch(ctx, config) {
 		name: "switchman:dispatch",
 		order: 10400,
 		interpolate: false,
-		text: () => {
+		text: (context) => {
 			const state = readDispatchState(ctx, config);
 			const anyConfigured = state.lanePools.some((pool) => pool.routes.length > 0) || state.modelRank.length > 0;
 			if (!anyConfigured) return "";
-			return renderPoolsBlock(state);
+			return renderPoolsBlock(state, sessionRouteOf(context));
 		},
 	});
 
@@ -370,6 +606,13 @@ function applyDispatch(ctx, config) {
 	// named; model-less calls use the system default and pass through.
 	ctx.on("tools/pre-execute", (exec, next) => {
 		try {
+			if (exec?.name === "list_subagent_models") {
+				// Enumeration sanitation: DSH rejects provider-less calls with a
+				// bare "`provider` must be non-empty"; deny once with the pool
+				// table's provider list instead (fail-open wrapper below).
+				const fix = enumerationFixOf(exec.arguments, config);
+				return fix === null ? next() : { kind: "deny", reason: fix };
+			}
 			if (exec?.name !== "subagent" && exec?.name !== "subagent_fork") return next();
 			const args = exec.arguments;
 
@@ -380,7 +623,7 @@ function applyDispatch(ctx, config) {
 			// implicit dispatch, losing the lane's route. Deny with the
 			// exact corrected arguments instead — one immediate retry on
 			// the intended route.
-			const fix = annotationFixOf(args, config);
+			const fix = annotationFixOf(args, config) ?? routeFixOf(args, config);
 			if (fix !== null) return { kind: "deny", reason: fix };
 
 			// Enforce gate: unchanged semantics, now sharing the factored

package/host/routes.js

@@ -95,6 +95,12 @@ const NUMBER_FIELDS = [
 	"wmReadBudgetTokens",
 	"wmSubagentForceTokens",
 ];
+/** Watermark numbers with REAL bounds (host/config.js schema): rejected (not
+ *  clamped) on write, defaulted on read — NUMBER_FIELDS only rejects negatives,
+ *  which would let a 0 ratio silently disable subagent tier scaling. */
+const WM_BOUNDED_NUMBER_FIELDS = [
+	{ field: "wmSubagentWindowRatio", min: 0.1, max: 1, def: 0.75 },
+];
 /** Trim numbers carry their own schema bounds (host/config.js), so the
  *  shared NUMBER_FIELDS coercion (which only rejects negatives) is too
  *  loose — these validate against each field's declared min/max. This group
@@ -102,16 +108,16 @@ const NUMBER_FIELDS = [
  *  but never sent by the client fails every fenced write (and vice versa). */
 const TRIM_NUMBER_FIELDS = [
 	{ field: "trimGrowthTokens", min: 1000, max: Number.POSITIVE_INFINITY, def: 22500 },
-	{ field: "trimIncrementTokens", min: 1000, max: Number.POSITIVE_INFINITY, def: 50000 },
-	{ field: "trimPressurePercent", min: 5, max: 100, def: 60 },
+	{ field: "trimIncrementTokens", min: 1000, max: Number.POSITIVE_INFINITY, def: 25000 },
+	{ field: "trimPressurePercent", min: 5, max: 100, def: 65 },
 	{ field: "trimEmergencyPercent", min: 5, max: 100, def: 95 },
 	{ field: "trimWindowTokens", min: 0, max: Number.POSITIVE_INFINITY, def: 0 },
-	{ field: "trimProtectedTail", min: 0, max: 100, def: 6 },
-	{ field: "trimMaxFoldsPerHour", min: 1, max: 60, def: 6 },
+	{ field: "trimProtectedTail", min: 0, max: 100, def: 10 },
 	{ field: "trimLadderT2Tokens", min: 1000, max: Number.POSITIVE_INFINITY, def: 8000 },
 	{ field: "trimLadderT2MinBlocks", min: 2, max: 200, def: 3 },
 	{ field: "trimLadderT3Tokens", min: 1000, max: Number.POSITIVE_INFINITY, def: 6000 },
 	{ field: "trimLadderT3MinBlocks", min: 2, max: 200, def: 2 },
+	{ field: "trimMaxFoldsPerHour", min: 1, max: 60, def: 30 },
 ];
 const BOOLEAN_FIELDS = [
 	"wmAutoHandover",
@@ -144,10 +150,13 @@ const INTENT_NUMBER_FIELDS = [
 	{ field: "intentHistoryMaxChars", min: 200, max: 20000, def: 2400 },
 	{ field: "intentContextWindow", min: 1024, max: Number.POSITIVE_INFINITY, def: 200000 },
 ];
-/** Intent route references: unlike pool routes they round-trip the "unset"
- *  {provider:"", model:""} pair, so they validate against the loosened
- *  cleanIntentRoute (both keys must be strings; either may be empty). */
-const INTENT_ROUTE_FIELDS = ["intentClassifierRoute", "intentFallbackRoute", "trimSideModel", "trimFoldFallbackModel"];
+/** Intent route references round-trip the "unset" {provider:"", model:""}
+ *  pair, so they validate against the loosened cleanIntentRoute (both keys
+ *  must be strings; either may be empty); intent routes never carry effort. */
+const INTENT_ROUTE_FIELDS = ["intentClassifierRoute", "intentFallbackRoute"];
+/** Trim side routes additionally round-trip an optional effort pin — the
+ *  settings page's reasoning-effort select — via cleanTrimRoute below. */
+const TRIM_ROUTE_FIELDS = ["trimSideModel", "trimFoldFallbackModel"];
 /** Intent candidate list (route + optional effort/note per entry). */
 const INTENT_CANDIDATE_FIELDS = ["intentCandidates"];
 
@@ -304,6 +313,18 @@ function cleanIntentRoute(entry) {
 	const provider = typeof entry.provider === "string" ? entry.provider.trim() : null;
 	const model = typeof entry.model === "string" ? entry.model.trim() : null;
 	return provider === null || model === null ? null : { provider, model };
+	}
+
+/** Coerce one TRIM side route: like cleanIntentRoute, but a non-empty string
+ *  effort rides along — the trim summarizer pins reasoning effort on its side
+ *  model, and stripping it here made every settings save silently revert the
+ *  settings page's effort select to the default. Intent routes omit effort. */
+function cleanTrimRoute(entry) {
+	const route = cleanIntentRoute(entry);
+	if (route === null) return null;
+	const effort = typeof entry.effort === "string" ? entry.effort.trim() : "";
+	if (effort !== "") route.effort = effort;
+	return route;
 }
 
 /** Coerce one intent candidate: provider/model must be non-empty; effort/note
@@ -349,6 +370,7 @@ export function snapshotOf(config) {
 			? rawOf(config[field]).map(cleanEffortEntry).filter(Boolean)
 			: [];
 	for (const field of INTENT_ROUTE_FIELDS) values[field] = cleanIntentRoute(rawOf(config?.[field])) ?? { provider: "", model: "" };
+	for (const field of TRIM_ROUTE_FIELDS) values[field] = cleanTrimRoute(rawOf(config?.[field])) ?? { provider: "", model: "" };
 	for (const field of INTENT_CANDIDATE_FIELDS)
 		values[field] = mergeIntentCandidates(rawOf(config?.[field]));
 	values.intentClassifierKind = ENUM_FIELDS.intentClassifierKind.includes(rawOf(config?.intentClassifierKind))
@@ -372,6 +394,10 @@ export function snapshotOf(config) {
 		const raw = Number(rawOf(config?.[field]));
 		values[field] = Number.isFinite(raw) ? raw : 0;
 	}
+	for (const { field, def } of WM_BOUNDED_NUMBER_FIELDS) {
+		const raw = Number(rawOf(config?.[field]));
+		values[field] = Number.isFinite(raw) ? raw : def;
+	}
 	values.wmDenyMode = ENUM_FIELDS.wmDenyMode.includes(rawOf(config?.wmDenyMode))
 		? rawOf(config.wmDenyMode)
 		: "cap";
@@ -419,6 +445,11 @@ export function coerceValues(input) {
 		if (route === null) return null;
 		values[field] = route;
 	}
+	for (const field of TRIM_ROUTE_FIELDS) {
+		const route = cleanTrimRoute(input[field]);
+		if (route === null) return null;
+		values[field] = route;
+	}
 	for (const field of INTENT_CANDIDATE_FIELDS) {
 		if (!Array.isArray(input[field])) return null;
 		const candidates = input[field].map(cleanIntentCandidate);
@@ -454,6 +485,11 @@ export function coerceValues(input) {
 		if (!Number.isFinite(raw) || raw < 0) return null;
 		values[field] = raw;
 	}
+	for (const { field, min, max } of WM_BOUNDED_NUMBER_FIELDS) {
+		const raw = Number(input[field]);
+		if (!Number.isFinite(raw) || raw < min || raw > max) return null;
+		values[field] = raw;
+	}
 	if (!ENUM_FIELDS.wmDenyMode.includes(input.wmDenyMode)) return null;
 	values.wmDenyMode = input.wmDenyMode;
 	for (const field of BOOLEAN_FIELDS) {