dsh-switchman 1.11.1 → 1.11.3

package/README.md

@@ -154,7 +154,7 @@ All keys live in Settings → dsh-switchman; defaults from `host/config.js`:
 
 ## How it works
 
-- The host half (`index.js` + `host/`) injects the byte-stable system-prompt sections (language / lanes / watermark protocol / teams) plus the live watermark line through the tail runtime-context snapshot (a channel that appends instead of rewriting the prompt head, so the provider prompt cache stays intact), the read-budget plus enforce double gate, and four slash commands (the ctx trio + `/vision`). A saved setting takes effect at the very next prompt assembly — no restart.
+- The host half (`index.js` + `host/`) injects the byte-stable system-prompt sections (language / lanes / watermark protocol / teams / PTC guard) plus the live watermark line through the tail runtime-context snapshot (a channel that appends instead of rewriting the prompt head, so the provider prompt cache stays intact), the read-budget plus enforce double gate, and four slash commands (the ctx trio + `/vision`). A saved setting takes effect at the very next prompt assembly — no restart. In PTC sessions (programmatic tool calls) the PTC guard renders as the final section and restates that every named tool must be invoked inside a `run_code` program (`await tools.name(args)`), making `unknown tool` rejections much less likely when doctrines or skill catalogs name tools directly (a prompt-level mitigation, not a hard guarantee).
 - The client half (`client.js`) renders the settings page, the ⚡ badge and ◇ model marker in the session header, and the live handover indicator; config snapshots are read and written through the Host route family.
 - The "Switchman Dispatch Center" entry in the home sidebar opens that same settings page as a center panel in one click; the original settings entry stays.
 - `cordis.patch.yml` keeps the factory preset plugin list fully intact and only extends the persona suffix; the Agent Teams tools themselves come from the factory bundle and switch on automatically with teams mode.
@@ -162,7 +162,7 @@ All keys live in Settings → dsh-switchman; defaults from `host/config.js`:
 ## Maintenance notes
 
 - After a DSH upgrade, if the factory preset plugin list changed, re-sync `cordis.patch.yml` from the new `presets/*.patch.yml` (keeping the doctrine suffix and the compaction arbitration — `auto: false` on the `compaction-basic` rows), then reinstall.
-- Protocol lines (`[SWITCHMAN:LANG|POOLS|WATERMARK|TEAMS]`) are deliberately English and byte-stable — don't localize them.
+- Protocol lines (`[SWITCHMAN:LANG|POOLS|WATERMARK|TEAMS|PTC]`) are deliberately English and byte-stable — don't localize them.
 - `npm pack --dry-run` should keep the audited 60-file / ~380 kB tarball shape (~1.26 MB unpacked). `docs/` stays out of the package (it is not in `package.json files`), while the 11 `README.*` translations are always shipped by npm.
 - **Zero runtime dependencies — a hard invariant.** Host-plane packages (`@deepseek-ai/schemastery`, cordis, …) are declared as `peerDependencies` only, and the running DSH satisfies them from its own copy. An ordinary `dependencies` entry is physically installed into the profile workspace (`<profile>/node_modules/…`), where it shadows the host's copy for every other profile-resident plugin — this is exactly what crashed the dshmarket plugin market while 1.7.0 carried schemastery as a dependency (two schemastery instances in one process; the market's schemas no longer matched the host's). `scripts/validate.mjs` fails if a `dependencies` entry ever reappears, so installing, updating, or removing dsh-switchman can never touch what dshmarket or any other community bundle resolves at runtime.
 

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}`);