dsh-switchman 1.11.1 → 1.11.2

package/client.js

@@ -198,6 +198,7 @@ window.__ModuleLoader__.load({
 			{ field: 'wmForceTokens', min: 3000, def: 150000 },
 			{ field: 'wmReadBudgetTokens', min: 200, def: 3000 },
 			{ field: 'wmSubagentForceTokens', min: 0, def: 0 },
+			{ field: 'wmSubagentWindowRatio', min: 0.1, def: 0.75 },
 		];
 
 		/** The three thresholds that must keep a strict ascending order. */
@@ -213,6 +214,10 @@ window.__ModuleLoader__.load({
 				label: 'wmSubagentForceLabel',
 				help: 'wmSubagentForceHelp',
 			},
+			wmSubagentWindowRatio: {
+				label: 'wmSubagentWindowRatioLabel',
+				help: 'wmSubagentWindowRatioHelp',
+			},
 		};
 
 		/** Intent-routing classifier kinds (design: intent-routing.md §2;
@@ -367,12 +372,16 @@ window.__ModuleLoader__.load({
 		/** Stable identity of one provider/model route. */
 		const routeKey = (route) => `${route.provider}\0${route.model}`;
 
-		/** One well-formed {provider, model} route, or null. */
+		/** One well-formed {provider, model[, effort]} route, or null. */
 		function sanitizeRoute(route) {
 			if (route === null || typeof route !== 'object') return null;
 			if (typeof route.provider !== 'string' || route.provider === '') return null;
 			if (typeof route.model !== 'string' || route.model === '') return null;
-			return { provider: route.provider, model: route.model };
+			// Trim side routes may carry an optional effort pin; keep it on the
+			// round-trip so a settings save never strips it (intent routes omit it).
+			const out = { provider: route.provider, model: route.model };
+			if (typeof route.effort === 'string' && route.effort !== '') out.effort = route.effort;
+			return out;
 		}
 
 		/** One well-formed rank entry ({provider, model[, tier]}), or null;
@@ -896,6 +905,9 @@ window.__ModuleLoader__.load({
 				wmSubagentForceLabel: '子智能体强制阈值',
 				wmSubagentForceHelp:
 					'仅覆盖子智能体的 force 档（soft/hard 与主会话共用）；0 = 跟随上方强制水位。',
+				wmSubagentWindowRatioLabel: '子智能体窗口比例',
+				wmSubagentWindowRatioHelp:
+					'按子智能体自身模型窗口缩放三档：force = min(静态档，窗口×比例)，soft/hard 同比收缩；只收紧不放宽。',
 				wmSubagentFollowForce: '跟随 force 档（0）',
 				wmCommands:
 					'命令：/ctx-pause 暂停水位干预 · /ctx-resume 恢复干预 · /ctx-handover 立即写交接文档并压缩。',
@@ -912,6 +924,7 @@ window.__ModuleLoader__.load({
 				trimSideModelLabel: '摘要模型',
 				trimSideModelHelp: '折叠摘要使用的模型路由；默认「跟随会话模型」。阶梯蒸馏同样使用该路由。',
 				trimFollowSession: '跟随会话模型',
+				trimEffortPinLow: '默认（pin low）',
 				trimFoldFallbackModelLabel: '折叠异常兜底模型',
 				trimFoldFallbackModelHelp: '摘要模型调用失败时改用该模型重试；仍失败则压力折叠退回机械折叠。尽量选择没有冷却、风控或并发限制的模型，避免与主会话共用同一账号。留空 = 无兜底。',
 				trimFallbackUnset: '未设置（失败时直接机械折叠）',
@@ -1160,6 +1173,9 @@ window.__ModuleLoader__.load({
 				wmSubagentForceLabel: 'Subagent force threshold',
 				wmSubagentForceHelp:
 					'Overrides only the subagent force tier (soft/hard are shared with the main session); 0 follows the force watermark above.',
+				wmSubagentWindowRatioLabel: 'Subagent window ratio',
+				wmSubagentWindowRatioHelp:
+					'Scale the subagent tiers to its own model window: force = min(static tier, window × ratio); soft/hard shrink by the same factor. Tightens only, never loosens.',
 				wmSubagentFollowForce: 'Follow the force tier (0)',
 				wmCommands:
 					'Commands: /ctx-pause suspends watermark actions · /ctx-resume resumes them · /ctx-handover writes the handover doc and compacts now.',
@@ -1179,6 +1195,7 @@ window.__ModuleLoader__.load({
 				trimSideModelHelp:
 					'Route for fold summaries; defaults to following the session model. Also used by ladder distillations.',
 				trimFollowSession: 'Follow session model',
+				trimEffortPinLow: 'Default (pin low)',
 				trimFoldFallbackModelLabel: 'Fold fallback model',
 				trimFoldFallbackModelHelp:
 					'When the summary route fails, the fold retries on this model before degrading a pressure fold to a mechanical one. Prefer a model with headroom on cooldowns, risk control, and concurrency limits — avoid sharing the pinned account with the main session. Empty = no fallback leg.',
@@ -1434,6 +1451,9 @@ window.__ModuleLoader__.load({
 				wmSubagentCapHelp: '開啟後子智能體可用下方獨立強制閾值；關閉則完全跟隨上方三檔水位。',
 				wmSubagentForceLabel: '子智能體強制閾值',
 				wmSubagentForceHelp: '僅覆蓋子智能體的 force 檔（soft/hard 與主會話共用）；0 = 跟隨上方強制水位。',
+				wmSubagentWindowRatioLabel: '子代理視窗比例',
+				wmSubagentWindowRatioHelp:
+					'按子代理自身模型視窗縮放三檔：force = min(靜態檔，視窗×比例)，soft/hard 同比收縮；只收緊不放寬。',
 				wmSubagentFollowForce: '跟隨 force 檔（0）',
 				wmCommands: '命令：/ctx-pause 暫停水位干預 · /ctx-resume 恢復干預 · /ctx-handover 立即寫交接文件並壓縮。',
 				trimSectionTitle: '上下文裁剪',
@@ -1449,6 +1469,7 @@ window.__ModuleLoader__.load({
 				trimSideModelLabel: '摘要模型',
 				trimSideModelHelp: '摺疊摘要使用的模型路由；預設「跟隨對話模型」。階梯蒸餾同樣使用該路由。',
 				trimFollowSession: '跟隨對話模型',
+				trimEffortPinLow: '預設（pin low）',
 				trimFoldFallbackModelLabel: '摺疊異常備援模型',
 				trimFoldFallbackModelHelp: '摘要模型呼叫失敗時改用該模型重試；仍失敗則壓力摺疊退回機械摺疊。盡量選擇沒有冷卻、風控或並行限制的模型，避免與主對話共用同一帳號。留空 = 無備援。',
 				trimFallbackUnset: '未設定（失敗時直接機械摺疊）',
@@ -1677,6 +1698,9 @@ window.__ModuleLoader__.load({
 				wmSubagentCapHelp: 'オンにすると、下の専用強制しきい値を使えます。オフなら上の 3 段階の水位に完全に従います。',
 				wmSubagentForceLabel: 'サブエージェント強制しきい値',
 				wmSubagentForceHelp: 'サブエージェントの force 段階のみを上書きします（soft/hard はメインセッションと共通）。0 なら上の強制水位に従います。',
+				wmSubagentWindowRatioLabel: 'サブエージェント窓比率',
+				wmSubagentWindowRatioHelp:
+					'サブエージェント自身のモデル窓に合わせて3段階を縮小：force = min(静的しきい値，窓×比率)。soft/hardも同率で縮小。引き締めのみ。',
 				wmSubagentFollowForce: 'force 段階に従う（0）',
 				wmCommands: 'コマンド：/ctx-pause で水位アクションを一時停止 · /ctx-resume で再開 · /ctx-handover で今すぐ引き継ぎ文書を書いて圧縮。',
 				trimSectionTitle: 'コンテキストトリム',
@@ -1771,6 +1795,7 @@ window.__ModuleLoader__.load({
 					'分類失敗時：前回ルート → フォールバック → 候補の先頭。空欄は候補の先頭。',
 				intentRouteUnset: '未設定',
 				intentEffortFollow: 'モデルのデフォルト',
+				trimEffortPinLow: 'デフォルト（pin low）',
 				intentDockAuto: '自動',
 				intentDockUnrouted: '未ルーティング',
 				intentDockUsing: '使用中',
@@ -1904,8 +1929,12 @@ window.__ModuleLoader__.load({
 				wmSubagentCapHelp: '켜면 서브에이전트가 아래 전용 강제 임계값을 사용합니다. 끄면 위 세 수위를 그대로 따릅니다.',
 				wmSubagentForceLabel: '서브에이전트 강제 임계값',
 				wmSubagentForceHelp: '서브에이전트의 force 단계만 덮어씁니다(soft/hard는 메인 세션과 공유). 0이면 위 강제 수위를 따릅니다.',
+				wmSubagentWindowRatioLabel: '서브에이전트 창 비율',
+				wmSubagentWindowRatioHelp:
+					'서브에이전트 자체 모델 창에 맞춰 3단계 축소: force = min(정적 기준, 창×비율). soft/hard도 같은 비율로 축소. 완화 없이 강화만.',
 				wmSubagentFollowForce: 'force 단계 따르기(0)',
 				wmCommands: '명령: /ctx-pause 수위 개입 일시 중지 · /ctx-resume 재개 · /ctx-handover 지금 핸드오버 문서를 작성하고 압축.',
+				trimEffortPinLow: '기본 (low 고정)',
 				trimSectionTitle: '컨텍스트 트림',
 				trimModeLabel: '트림 모드',
 				trimModeHelp:
@@ -2130,8 +2159,12 @@ window.__ModuleLoader__.load({
 				wmSubagentCapHelp: 'Subagents dürfen die eigene erzwungene Schwelle unten nutzen; aus = vollständig den drei Stufen oben folgen.',
 				wmSubagentForceLabel: 'Erzwungene Schwelle für Subagents',
 				wmSubagentForceHelp: 'Überschreibt nur die Force-Stufe der Subagents (soft/hard teilen sich mit der Haupt-Session); 0 folgt dem erzwungenen Wasserstand oben.',
+				wmSubagentWindowRatioLabel: 'Subagent-Fensterquote',
+				wmSubagentWindowRatioHelp:
+					'Skaliert die Stufen auf das eigene Modellfenster des Subagenten: force = min(statische Stufe, Fenster × Quote); soft/hard schrumpfen im selben Faktor. Verengt nur, lockert nie.',
 				wmSubagentFollowForce: 'Der Force-Stufe folgen (0)',
 				wmCommands: 'Befehle: /ctx-pause pausiert Wasserstand-Aktionen · /ctx-resume setzt sie fort · /ctx-handover schreibt das Übergabedokument jetzt und komprimiert sofort.',
+				trimEffortPinLow: 'Standard (pin low)',
 				trimSectionTitle: 'Kontext-Trim',
 				trimModeLabel: 'Trim-Modus',
 				trimModeHelp:
@@ -2359,8 +2392,12 @@ window.__ModuleLoader__.load({
 				wmSubagentCapHelp: 'Permite que los subagentes usen el umbral forzado propio de abajo; desactivado = seguir por completo los tres niveles de arriba.',
 				wmSubagentForceLabel: 'Umbral forzado de subagentes',
 				wmSubagentForceHelp: 'Solo sobrescribe el nivel forzado de los subagentes (soft/hard se comparten con la sesión principal); 0 sigue el nivel forzado de arriba.',
+				wmSubagentWindowRatioLabel: 'Ratio de ventana del subagente',
+				wmSubagentWindowRatioHelp:
+					'Escala los niveles a la ventana del propio modelo del subagente: force = min(nivel estático, ventana × ratio); soft/hard se reducen por el mismo factor. Solo restringe, nunca amplía.',
 				wmSubagentFollowForce: 'Seguir el nivel forzado (0)',
 				wmCommands: 'Comandos: /ctx-pause suspende las acciones del nivel · /ctx-resume las reanuda · /ctx-handover escribe el documento y compacta ahora.',
+				trimEffortPinLow: 'Predeterminado (pin low)',
 				trimSectionTitle: 'Recorte de contexto',
 				trimModeLabel: 'Modo de recorte',
 				trimModeHelp:
@@ -2589,8 +2626,12 @@ window.__ModuleLoader__.load({
 				wmSubagentCapHelp: 'Laisse les subagents utiliser le seuil force dédié ci-dessous ; désactivé = suivent intégralement les trois paliers ci-dessus.',
 				wmSubagentForceLabel: 'Seuil force des subagents',
 				wmSubagentForceHelp: 'Ne remplace que le palier force des subagents (soft/hard partagés avec la session principale) ; 0 suit la ligne d’eau force ci-dessus.',
+				wmSubagentWindowRatioLabel: 'Ratio de fenêtre du sous-agent',
+				wmSubagentWindowRatioHelp:
+					'Ajuste les paliers à la fenêtre propre du modèle du sous-agent : force = min(palier statique, fenêtre × ratio) ; soft/hard réduits du même facteur. Ne fait que resserrer, jamais relâcher.',
 				wmSubagentFollowForce: 'Suivre le palier force (0)',
 				wmCommands: 'Commandes : /ctx-pause suspend les actions de niveau d’eau · /ctx-resume les reprend · /ctx-handover écrit le document et compacte maintenant.',
+				trimEffortPinLow: 'Par défaut (pin low)',
 				trimSectionTitle: 'Rognage du contexte',
 				trimModeLabel: 'Mode de rognage',
 				trimModeHelp:
@@ -2819,8 +2860,12 @@ window.__ModuleLoader__.load({
 				wmSubagentCapHelp: 'Lascia i subagent usare la soglia force dedicata qui sotto; spento = seguono appieno le tre soglie sopra.',
 				wmSubagentForceLabel: 'Soglia force dei subagent',
 				wmSubagentForceHelp: 'Sostituisce solo la soglia force dei subagent (soft/hard restano condivise con la sessione principale); 0 segue la soglia force sopra.',
+				wmSubagentWindowRatioLabel: 'Rapporto finestra del subagente',
+				wmSubagentWindowRatioHelp:
+					'Ridimensiona i livelli alla finestra del modello del subagente: force = min(livello statico, finestra × rapporto); soft/hard si riducono dello stesso fattore. Solo restrizione, mai allentamento.',
 				wmSubagentFollowForce: 'Segui la soglia force (0)',
 				wmCommands: 'Comandi: /ctx-pause sospende le azioni da livello dell’acqua · /ctx-resume le riprende · /ctx-handover scrive il documento e compatta subito.',
+				trimEffortPinLow: 'Predefinito (pin low)',
 				trimSectionTitle: 'Riduzione del contesto',
 				trimModeLabel: 'Modalità di riduzione',
 				trimModeHelp:
@@ -3049,8 +3094,12 @@ window.__ModuleLoader__.load({
 				wmSubagentCapHelp: 'Deixa os subagents usar o limiar force dedicado abaixo; desligado = seguem integralmente os três limiares acima.',
 				wmSubagentForceLabel: 'Limiar force dos subagents',
 				wmSubagentForceHelp: 'Sobrepõe apenas o limiar force dos subagents (soft/hard são compartilhados com a sessão principal); 0 segue o limiar force acima.',
+				wmSubagentWindowRatioLabel: 'Razão de janela do subagente',
+				wmSubagentWindowRatioHelp:
+					'Escala os níveis para a janela do próprio modelo do subagente: force = min(nível estático, janela × razão); soft/hard encolhem pelo mesmo fator. Apenas aperta, nunca afrouxa.',
 				wmSubagentFollowForce: 'Seguir o limiar force (0)',
 				wmCommands: 'Comandos: /ctx-pause suspende as ações de nível de água · /ctx-resume as retoma · /ctx-handover escreve o documento e compacta agora.',
+				trimEffortPinLow: 'Padrão (pin low)',
 				trimSectionTitle: 'Corte de contexto',
 				trimModeLabel: 'Modo de corte',
 				trimModeHelp:
@@ -3279,8 +3328,12 @@ window.__ModuleLoader__.load({
 				wmSubagentCapHelp: 'Субагенты используют отдельный порог force ниже; выключено = полностью следуют трём линиям выше.',
 				wmSubagentForceLabel: 'Порог force субагентов',
 				wmSubagentForceHelp: 'Меняет только линию force субагентов (soft/hard общие с главной сессией); 0 — следовать линии force выше.',
+				wmSubagentWindowRatioLabel: 'Доля окна субагента',
+				wmSubagentWindowRatioHelp:
+					'Масштабирует уровни под собственное окно модели субагента: force = min(статический уровень, окно × доля); soft/hard сжимаются на тот же коэффициент. Только ужесточает, не смягчает.',
 				wmSubagentFollowForce: 'Следовать линии force (0)',
 				wmCommands: 'Команды: /ctx-pause приостанавливает действия по уровню воды · /ctx-resume возобновляет их · /ctx-handover записывает документ передачи и сжимает прямо сейчас.',
+				trimEffortPinLow: 'По умолчанию (pin low)',
 				trimSectionTitle: 'Обрезка контекста',
 				trimModeLabel: 'Режим обрезки',
 				trimModeHelp:
@@ -5856,6 +5909,7 @@ window.__ModuleLoader__.load({
 									(meta) => meta.model === route.model,
 								);
 								edit(field, {
+									...route,
 									provider: next,
 									model: kept ? route.model : '',
 								});
@@ -5880,18 +5934,31 @@ window.__ModuleLoader__.load({
 						disabled: !editable || route.provider === '',
 						'aria-label': `${label} · model`,
 					}, ...trimModelOptions(followMode, route, route.model)),
+					route.provider !== ''
+						? intentEffortSelect(
+							`${trimId}-${field}-effort`,
+							route,
+							route.effort,
+							(next) => edit(field, { ...route, effort: next }),
+							`${label} · effort`,
+							t('trimEffortPinLow'),
+						)
+						: null,
 				);
 			};
 			/** Reasoning-effort select for one intent route: the model's
 			 *  wire efforts when the catalog reports them, the EFFORTS
 			 *  fallback otherwise; '' = adapter default. A stored value
-			 *  missing from the list stays selectable. */
+			 *  missing from the list stays selectable. emptyLabel replaces
+			 *  the '' option label (trim rows pin low instead of following
+			 *  the model default). */
 			const intentEffortSelect = (
 				id,
 				route,
 				value,
 				onCommit,
 				ariaLabel,
+				emptyLabel,
 			) => {
 				const meta = catalogIndex.get(routeKey(route));
 				const wire =
@@ -5915,7 +5982,7 @@ window.__ModuleLoader__.load({
 						style: STYLE.effortSelect,
 						'aria-label': ariaLabel,
 					},
-					h('option', { value: '' }, t('intentEffortFollow')),
+					h('option', { value: '' }, emptyLabel ?? t('intentEffortFollow')),
 					...[...wire, ...pending].map((entry) =>
 						h('option', { value: entry.id }, entry.name ?? entry.id),
 					),

package/cordis.patch.yml

@@ -633,3 +633,32 @@
 - insert:
     - id: dsh-switchman-host
       name: dsh-switchman
+      config:
+        langScope: project
+        dispatchEnforce: advice
+        wmSoftTokens: 80000
+        wmHardTokens: 95000
+        wmForceTokens: 150000
+        wmReadBudgetTokens: 3000
+        wmDenyMode: cap
+        wmAutoHandover: true
+        wmSubagentCap: true
+        wmSubagentForceTokens: 0
+        wmSubagentWindowRatio: 0.75
+        teamsMode: true
+        syncWhitelist: true
+        trimEnabled: true
+        trimMode: auto
+        trimGrowthTokens: 22500
+        trimIncrementTokens: 25000
+        trimPressurePercent: 65
+        trimEmergencyPercent: 95
+        trimWindowTokens: 0
+        trimProtectedTail: 10
+        trimMaxFoldsPerHour: 30
+        trimLadderEnabled: true
+        trimLadderT2Tokens: 8000
+        trimLadderT2MinBlocks: 3
+        trimLadderT3Tokens: 6000
+        trimLadderT3MinBlocks: 2
+        surfaceFold: true

package/host/config.js

@@ -67,10 +67,14 @@ export const IntentCandidateSchema = z.object({
  *  ModelRouteSchema this accepts the "unset" `{provider:"", model:""}`
  *  pair the settings page round-trips — ModelRouteSchema's `.min(1)`
  *  would reject that exact declared default on every settings write.
- *  Consumers validate non-empty before trusting the route. */
+ *  Consumers validate non-empty before trusting the route. effort follows
+ *  the optional no-`.required()` style (schemastery passes undefined
+ *  through): the trim summarizer reads it as a reasoning-effort pin;
+ *  intent-layer routes leave it unset. */
 const IntentRouteSchema = z.object({
 	provider: z.string(),
 	model: z.string(),
+	effort: z.string(),
 });
 
 /** All dsh-switchman settings. Field names are the settings mutation paths. */
@@ -153,6 +157,14 @@ export const Config = z.object({
 	wmSubagentCap: z.boolean().default(true).volatile(),
 	/** Subagent hard cap; 0 = share wmForceTokens. */
 	wmSubagentForceTokens: z.number().min(0).default(0).volatile(),
+	/** Scale subagent watermark tiers to the subagent's own model window:
+	 * force = min(static force [or wmSubagentForceTokens], window × ratio);
+	 * soft/hard shrink by the same factor to preserve tier spacing. The ratio
+	 * can only TIGHTEN tiers, never loosen them; 1 = cap at the full model
+	 * window (still tightens when the window is smaller than the static
+	 * force tier). Resolution is async and cached per model route; until it
+	 * lands, the static tiers apply (fail-open). */
+	wmSubagentWindowRatio: z.number().min(0.1).max(1).default(0.75).volatile(),
 
 	// --- Teams mode: doctrine injection + whitelist sync -------------------
 	/** Agent Teams master switch. ON = inject the `[SWITCHMAN:TEAMS]` doctrine

package/host/context-trim/index.js

@@ -58,6 +58,7 @@ import { childSessionIdOf } from "../subagent-model.js";
 // it and the stored tally takes over.
 const trimViewBySession = new Map(); // sessionId -> { viewTokens, at, inject, lastNoneAt }
 const trimWireBySession = new Map(); // sessionId -> { promptTokens, at } — last sampled provider prompt of an accepted MAIN dispatch (side calls never write; a tiny inherited-id usage sample must not lower the watermark's wire floor)
+const capturedModelBySession = new Map(); // sessionId -> { provider, model, at } — last stream-captured model route, read by the watermark layer to scale subagent tiers to the session's own model window
 /** Freshness TTL for the in-memory view/injection registry (watermark and
  *  banner display only). NEVER a fold gate: gating folds on "did the surface
  *  channel ship recently" deadlocks resumed sessions (2026-11-05). The fold
@@ -112,6 +113,19 @@ export function recentTrimViewTokensOf(sessionId, maxAgeMs = TRIM_VIEW_MAX_AGE_M
 	}
 }
 
+/** Most recent captured model route ({provider, model}) for a session, or
+ * null when missing, stale, or malformed. The watermark layer reads this to
+ * look up the session's own model window (subagent tier scaling). */
+export function recentTrimModelOf(sessionId, maxAgeMs = TRIM_VIEW_MAX_AGE_MS) {
+	try {
+		const entry = capturedModelBySession.get(sessionId);
+		if (entry === undefined || Date.now() - entry.at > maxAgeMs) return null;
+		return typeof entry.provider === "string" && typeof entry.model === "string" ? { provider: entry.provider, model: entry.model } : null;
+	} catch {
+		return null;
+	}
+}
+
 /** Meter-duality bridge, wire domain (design §8): the same number the trim
  * pressure tiers evaluate in maybeFold — Math.max(outbound view estimate,
  * the last sampled provider prompt) — or null when the gate rejects or
@@ -234,7 +248,11 @@ function readRoute(config, key) {
 		let got = value;
 		if (value !== null && typeof value === "object" && typeof value.get === "function") got = value.get();
 		if (got !== null && typeof got === "object" && typeof got.provider === "string" && got.provider !== "" && typeof got.model === "string" && got.model !== "") {
-			return { provider: got.provider, model: got.model };
+			// Pass the configured effort through verbatim (IntentRouteSchema
+			// already carries the optional field); absent/empty just omits it.
+			return typeof got.effort === "string" && got.effort !== ""
+				? { provider: got.provider, model: got.model, effort: got.effort }
+				: { provider: got.provider, model: got.model };
 		}
 	} catch {
 		/* fall through */
@@ -576,6 +594,10 @@ export function applyContextTrim(ctx, config) {
 	 * copy — message objects are treated as immutable records). */
 	function captureOf(sessionId, messages, model, viewTokens) {
 		captures.set(sessionId, { messages: messages.slice(), model, viewTokens, at: Date.now() });
+		if (model !== null && typeof model === "object" && typeof model.provider === "string" && typeof model.model === "string") {
+			capturedModelBySession.set(sessionId, { provider: model.provider, model: model.model, at: Date.now() });
+			if (capturedModelBySession.size > 200) capturedModelBySession.delete(capturedModelBySession.keys().next().value);
+		}
 		// keep the capture map bounded (200 sessions)
 		if (captures.size > 200) {
 			const oldest = captures.keys().next().value;
@@ -673,7 +695,15 @@ export function applyContextTrim(ctx, config) {
 		} else if (view.applied > 0) {
 			epochResetDoneBySession.delete(sessionId);
 		}
-		const model = { provider: options.provider ?? null, model: options.model ?? null };
+		// Capture the session's own resolved reasoningEffort alongside
+		// provider/model: at stream-listener time DSH has already resolved the
+		// effective effort for this dispatch, so the side route can inherit it
+		// verbatim instead of re-deriving (and losing) it.
+		const model = {
+			provider: options.provider ?? null,
+			model: options.model ?? null,
+			effort: typeof options.reasoningEffort === "string" && options.reasoningEffort !== "" ? options.reasoningEffort : null,
+		};
 		captureOf(sessionId, rawSnapshot, model, viewTokens);
 		metrics.noteView(sessionId, viewTokens, model);
 		const priorEntry = trimViewBySession.get(sessionId);
@@ -694,7 +724,10 @@ export function applyContextTrim(ctx, config) {
 		if (explicit !== null) return explicit;
 		const model = metrics.of(sessionId)?.lastModel ?? null;
 		if (model !== null && typeof model.provider === "string" && model.provider !== "" && typeof model.model === "string" && model.model !== "") {
-			return { provider: model.provider, model: model.model };
+			// Inherit the session's own resolved effort when one was captured.
+			return typeof model.effort === "string" && model.effort !== ""
+				? { provider: model.provider, model: model.model, effort: model.effort }
+				: { provider: model.provider, model: model.model };
 		}
 		return null;
 	}
@@ -733,6 +766,7 @@ export function applyContextTrim(ctx, config) {
 			const summarize = (r, tag) => summarizeWithModel(llm, r, renderLadderMaterial(consumed), {
 				systemPrompt: LADDER_SYSTEM_PROMPT,
 				onFail: (why) => decisionLog(`session=${sessionId} summary-fail route=${tag} why=${why} blocks=${consumed.length} ~${approxTokens}t ladder=${decision.tier}`),
+				onNotice: (why) => decisionLog(`session=${sessionId} summary-retry route=${tag} why=${why} blocks=${consumed.length} ~${approxTokens}t ladder=${decision.tier}`),
 			});
 			let summary = route !== null ? await summarize(route, "side") : null;
 			if (summary === null && fallback !== null && !sameRoute(fallback, route)) summary = await summarize(fallback, "fallback");
@@ -779,6 +813,7 @@ export function applyContextTrim(ctx, config) {
 			const material = renderMaterial(capture.messages, startIdx, endIdx, refOf);
 			const summarize = (r, tag) => summarizeWithModel(llm, r, material, {
 				onFail: (why) => decisionLog(`session=${sessionId} summary-fail route=${tag} why=${why} msgs=${count} ~${approxTokens}t`),
+				onNotice: (why) => decisionLog(`session=${sessionId} summary-retry route=${tag} why=${why} msgs=${count} ~${approxTokens}t`),
 			});
 			summary = route !== null ? await summarize(route, "side") : null;
 			if (summary === null && fallback !== null && !sameRoute(fallback, route)) summary = await summarize(fallback, "fallback");

package/host/context-trim/metrics.js

@@ -67,8 +67,7 @@ export function createMetrics() {
 				cacheWriteTokens: null, // cache-write bucket of the last sample
 				outputTokens: null,
 				viewTokens: null, // view estimate noted by the listener pre-request
-				lastModel: null, // { provider, model } of the last stream
-				lastStreamAt: 0,
+				lastModel: null, // { provider, model, effort } of the last stream
 				totalStreams: 0,
 			};
 		}
@@ -87,8 +86,7 @@ export function createMetrics() {
 		noteView(sessionId, viewTokens, model) {
 			const record = recordOf(sessionId);
 			if (Number.isFinite(viewTokens)) record.viewTokens = Math.round(viewTokens);
-			if (model !== null && typeof model === "object") record.lastModel = { provider: model.provider ?? null, model: model.model ?? null };
-			record.lastStreamAt = Date.now();
+			if (model !== null && typeof model === "object") record.lastModel = { provider: model.provider ?? null, model: model.model ?? null, effort: typeof model.effort === "string" && model.effort !== "" ? model.effort : null };
 			record.totalStreams += 1;
 			return record;
 		},

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-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"]);
@@ -241,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) {
@@ -250,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);
@@ -333,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,6 +291,208 @@ 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
@@ -340,9 +549,11 @@ function renderPoolsBlock(state, sessionRoute = null) {
 		`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 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(
@@ -395,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;
 
@@ -405,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
@@ -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) {

package/host/teams.js

@@ -82,7 +82,8 @@ const TEAMS_SECTION_TEXT = [
 	"系统提示词前文的默认团队策略写的是「仅当用户明确要求时才创建 teammate」。该默认策略在当前 profile 下不适用：用户安装 dsh-switchman 即预先授权，你应当自主判断、自主触发，无需再询问用户。",
 	"",
 	"## 五、团队触发与协作纪律",
-	"- 需要多成员持久协作、共享任务板、消息往来的用 Agent Teams（满足任一即触发 spawn_teammate：可并行的多个独立子任务；量大且自包含；主上下文水位已高；需要角色分离）；一次性、无需共享状态的单点调查用 subagent。",
+	"- 派发通道优先级（取代前文「一次性、无需共享状态的单点调查用 subagent」的默认分工）：本会话工具目录里有 spawn_teammate/list_agents（Agent Teams 已启用）时，一切子任务委派默认走 Agent Teams——spawn_teammate 组队、team_task_* 落共享任务板、send_message/wait_agent 协作；subagent/subagent_fork 单智能体派发退为后备通道，仅在本条下一条所述的不可用场景使用。",
+	"- teams 不可用即降级，不重试：工具目录没有 spawn_teammate/list_agents（bundle 未生效或本会话不支持），或 spawn_teammate 报 provisioning failed / 创建失败时，直接改用 subagent/subagent_fork 派发并继续工作，不要反复重试 teams 通道。你自身是 teammate（非 Lead）时维持原规则：不 spawn_teammate，需要子委派时用 subagent。workflow 仅在用户明确要求工作流或脚本化大规模编排时使用，默认不主动使用。",
 	"- 写作域隔离：共享任务上写明互不重叠的 write_scopes；用 team_task_* 维护任务板与依赖顺序；Lead 汇总最终 diff、复核关键改动并运行测试；用 wait_agent 等到必需的 teammate 完成，绝不在结果未回前下最终结论。",
 	"- 子智能体消息通道：subagent/workflow 返回的子会话 id 只能经 child_message 桥接送达——send_message 只解析 teammate 名字，对子会话 id 必报 active teammate「…」not found；该报错不代表子会话死亡，先改用 child_message，不要据此重派或判定死亡。",
 ].join("\n");

package/host/tool-args-sanitize.js

@@ -0,0 +1,106 @@
+/** Transparent tool-argument sanitation layer (`tools/pre-execute`).
+ *
+ * Production session logs (4 days, 5961 tool calls, 300 failures) show a
+ * recurring failure class where the model emits a composite argument in the
+ * wrong JSON shape and the tool's own validation rejects it — the retry loop
+ * then often repeats the SAME shape (worst observed: 8 identical failures in
+ * a row). Two shapes dominate:
+ *
+ * 1. Stringified JSON composites: `view_range: "[100, 145]"` (a JSON string
+ *    instead of the native array; 24 failures), `input: "{...}"` for
+ *    cordis_inspect_query (3). The deterministic fix is one JSON.parse.
+ * 2. Empty string for an enum-ish field: `read` with `encoding: ""`
+ *    (26 failures) — the tool wants the field absent, not blank.
+ *
+ * This layer coerces those shapes BEFORE the tool implementations validate
+ * (better-edit's requireViewRange / normalizeEncoding, or the native
+ * defineTool INVALID_ARGS check) and before guards/approvals observe the
+ * arguments, so the call succeeds transparently instead of burning a retry.
+ *
+ * Conservative by construction:
+ * - ONLY whitelisted field names are touched (observed-broken plus same-shape
+ *   kin); content-bearing string fields like `command` are never parsed.
+ * - A stringified value is replaced only when JSON.parse yields a value that
+ *   satisfies the field's structural assertion. Anything else keeps the
+ *   original string so the tool's own [TO MODEL] error reaches the model
+ *   unchanged — sanitation must never swallow or rewrite a real error.
+ * - Any internal error fails open (next()), never denies, never throws.
+ */
+
+/** Structural assertions for whitelisted fields (tool-level code validates
+ *  the contents; we only gate the composite SHAPE). */
+const isPairRange = (value) =>
+	Array.isArray(value) && value.length === 2 &&
+	value.every((item) => Number.isInteger(item) && item > 0);
+const isPlainArray = (value) => Array.isArray(value);
+const isPlainObject = (value) =>
+	value !== null && typeof value === "object" && !Array.isArray(value);
+
+/** Field-name whitelist → structural assertion. Field names are narrow enough
+ *  to stand alone (view_range/edits: str_replace_editor; windows: read;
+ *  input: cordis_inspect_query) — no tool-name gate, so future tools reusing
+ *  the same names get the same tolerance. */
+const SHAPE_FIELDS = {
+	view_range: isPairRange,
+	windows: isPlainArray,
+	edits: isPlainArray,
+	input: isPlainObject,
+};
+
+/** Fields where an empty string means "not provided" (tool default applies). */
+const EMPTY_UNSET_FIELDS = ["encoding"];
+
+/** Coerce known broken argument shapes. Returns `{ args, fixes }` when at
+ *  least one coercion applied, `null` when the arguments are clean (or not a
+ *  plain object). Pure: never mutates the input object. */
+export function sanitizeToolArgs(args) {
+	if (args === null || typeof args !== "object" || Array.isArray(args))
+		return null;
+	const out = { ...args };
+	const fixes = [];
+	for (const [field, assert] of Object.entries(SHAPE_FIELDS)) {
+		const value = out[field];
+		if (typeof value !== "string") continue;
+		const trimmed = value.trim();
+		if (!trimmed.startsWith("[") && !trimmed.startsWith("{")) continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			continue;
+		}
+		if (!assert(parsed)) continue;
+		out[field] = parsed;
+		fixes.push(`${field}: stringified JSON -> ${Array.isArray(parsed) ? "array" : "object"}`);
+	}
+	for (const field of EMPTY_UNSET_FIELDS) {
+		if (out[field] === "") {
+			delete out[field];
+			fixes.push(`${field}: "" -> unset`);
+		}
+	}
+	return fixes.length > 0 ? { args: out, fixes } : null;
+}
+
+/** Mount the sanitation layer (one `tools/pre-execute` listener). Runs before
+ *  guards and before every tool implementation's own validation; replaces
+ *  `exec.arguments` wholesale (lossless plain JSON) when a known shape was
+ *  coerced, then always calls next(). */
+export function applyToolArgsSanitize(ctx, config) {
+	const warn = (message) => ctx.logger.warn(`dsh-switchman: ${message}`);
+	ctx.on("tools/pre-execute", (exec, next) => {
+		try {
+			const result = sanitizeToolArgs(exec?.arguments);
+			if (result !== null) {
+				exec.arguments = result.args;
+				ctx.logger.debug(
+					`dsh-switchman: sanitized ${exec?.name ?? "?"} arguments (${result.fixes.join("; ")})`,
+				);
+			}
+			return next();
+		} catch (error) {
+			warn(`tool-args sanitation failed open: ${error?.message ?? error}`);
+			return next();
+		}
+	});
+}

package/index.js

@@ -25,6 +25,12 @@
  * ctx_handover agent tool, and the /ctx-pause, /ctx-resume,
  * /ctx-handover commands.
  *
+ * The tool-argument sanitation layer (host/tool-args-sanitize.js) is a
+ * `tools/pre-execute` waterfall listener that transparently coerces known
+ * broken argument shapes — stringified-JSON composites ("[100, 145]" instead
+ * of [100, 145]) and empty-string enum fields (encoding: "") — before the
+ * tool implementations validate them, eliminating a recurring class of
+ * self-correcting tool-call retries observed in production session logs.
  * Teams mode mounts two more layers: host/teams.js carries the team clauses
  * extracted from the cordis.patch.yml suffix in a `[SWITCHMAN:TEAMS]` section
  * (order 10250, injected only while teamsMode is ON) plus the deferred ON
@@ -81,6 +87,9 @@ import { applyIntent } from "./host/intent.js";
 // Client-bridge routes (config snapshot/fenced write + model catalog for the
 // restricted browser half, which has no configForms/remote services).
 import { applyRoutes } from "./host/routes.js";
+// Tool-argument sanitation (transparent coercion of stringified-JSON and
+// empty-string argument shapes before tool validation).
+import { applyToolArgsSanitize } from "./host/tool-args-sanitize.js";
 
 /** Cordis plugin name. */
 const name = "dsh-switchman";
@@ -211,6 +220,7 @@ function apply(ctx, config) {
 	applyIntent(ctx, config);
 	applySubagentModel(ctx);
 	applyRoutes(ctx, config);
+	applyToolArgsSanitize(ctx, config);
 }
 
 export { apply, inject, name };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dsh-switchman",
-	"version": "1.11.1",
+	"version": "1.11.2",
 	"description": "Autonomous Agent Teams doctrine for the four shipped DeepSeek Harness presets, plus language preferences, dispatch pools with model ranking, and context watermark control.",
 	"license": "MIT",
 	"keywords": [