dsh-switchman 1.11.0 → 1.11.2

package/client.js

@@ -194,10 +194,11 @@ window.__ModuleLoader__.load({
 		 * Host-side default (also the fallback for malformed stored values). */
 		const WM_NUMBER_FIELDS = [
 			{ field: 'wmSoftTokens', min: 1000, def: 80000 },
-			{ field: 'wmHardTokens', min: 2000, def: 120000 },
+			{ field: 'wmHardTokens', min: 2000, def: 95000 },
 			{ 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;
@@ -271,12 +276,12 @@ window.__ModuleLoader__.load({
 		 *  write (and vice versa). */
 		const TRIM_NUMBER_FIELDS = [
 			{ field: 'trimGrowthTokens', min: 1000, def: 22500 },
-			{ field: 'trimIncrementTokens', min: 1000, def: 50000 },
-			{ field: 'trimPressurePercent', min: 5, max: 100, def: 60 },
+			{ field: 'trimIncrementTokens', min: 1000, def: 25000 },
+			{ field: 'trimPressurePercent', min: 5, max: 100, def: 65 },
 			{ field: 'trimEmergencyPercent', min: 5, max: 100, def: 95 },
 			{ field: 'trimWindowTokens', min: 0, def: 0 },
-			{ field: 'trimProtectedTail', min: 0, max: 100, def: 6 },
-			{ field: 'trimMaxFoldsPerHour', min: 1, max: 60, def: 6 },
+			{ field: 'trimProtectedTail', min: 0, max: 100, def: 10 },
+			{ field: 'trimMaxFoldsPerHour', min: 1, max: 60, def: 30 },
 			{ field: 'trimLadderT2Tokens', min: 1000, def: 8000 },
 			{ field: 'trimLadderT2MinBlocks', min: 2, max: 200, def: 3 },
 			{ field: 'trimLadderT3Tokens', min: 1000, def: 6000 },
@@ -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

@@ -99,7 +99,7 @@
             - 禁止复活死会话：子智能体达 cap 终止后，用自包含 prompt 新派一个，不 resume 旧壳。
             - 广搜先问：首次整项目范围的搜索先向用户澄清范围，定点检索不受此限。
             - 大额派发先估成本：预计 ≥3 个成员或总消耗 >100k token 时，先报规模与预估请用户确认。
-            - 子路由两通道：显式传 provider/model/effort 任一字段会经 DSH 会话级授权白名单校验（设置页「允许 Agent 为子智能体选择模型」勾选的授权列表，与泳道池无关）；被拒时用 list_subagent_models 查实际可用路由再派，或改为完全不传三字段走隐式继承（不受校验，子智能体用默认值或继承主会话路由）。泳道池只是偏好排序，授权边界以 DSH 设置为准，不试图改写它。
+            - 子路由两通道：派发 subagent/workflow 默认显式传 provider/model/effort（按泳道表逐字段拆填，经 DSH 会话级授权白名单校验——设置页「允许 Agent 为子智能体选择模型」的授权列表，与泳道池无关）；隐式继承（完全不传三字段）不是省事通道，仅当显式尝试被拒且 list_subagent_models 确认无可用路由后才可兜底，并在回报中声明 IMPLICIT-DOWNGRADED——隐式拿到的是主会话路由，泳道模型丢失。泳道池只是偏好排序，授权边界以 DSH 设置为准，不试图改写它。
 
             ## 三、分级验证（质量下限，不可省）
             - 改动 >20 行或涉及多个调用点：交 tester 验证。
@@ -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. */
@@ -130,7 +134,8 @@ export const Config = z.object({
 	/** Soft watermark: advisory banner + delegation nudge (tokens). */
 	wmSoftTokens: z.number().min(1000).default(80000).volatile(),
 	/** Hard watermark: read budget tightens, wrap-up advised (tokens). 95k
-	 *  aligns with the trim pressure line (60% of the 150k window): past
+	 *  sits just under the trim pressure line (65% of the 150k window ≈
+	 *  97.5k): past
 	 *  this point the fold engine is already folding, so per-call read
 	 *  budgets must tighten at the SAME boundary — agent sessions grow in
 	 *  PULSES (one large file read = tens of thousands of tokens injected
@@ -152,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
@@ -247,10 +260,10 @@ export const Config = z.object({
 	trimGrowthTokens: z.number().min(1000).default(22500).volatile(),
 	/** Growth gate companion: the contiguous compressible increment must
 	 *  also reach this many estimated tokens (chars/4 heuristic). */
-	trimIncrementTokens: z.number().min(1000).default(50000).volatile(),
+	trimIncrementTokens: z.number().min(1000).default(25000).volatile(),
 	/** Pressure tier (tier b): fold when view usage reaches this percent of
 	 *  the context window (requires a resolvable window; otherwise skipped). */
-	trimPressurePercent: z.number().min(1).max(100).default(60).volatile(),
+	trimPressurePercent: z.number().min(1).max(100).default(65).volatile(),
 	/** Emergency tier (tier c): forced MECHANICAL fold (no side-model call)
 	 *  at this percent of the window; cooldown-gated. */
 	trimEmergencyPercent: z.number().min(1).max(100).default(95).volatile(),
@@ -260,22 +273,24 @@ export const Config = z.object({
 	 *  trimIncrementTokens proportionally makes the growth tier unreachable
 	 *  (a 30k window can never accumulate a 50k increment; observed live:
 	 *  growth fired once while emergency fired 17 times). Rule of thumb:
-	 *  increment ≈ window/3, growth ≈ increment × 0.45.]
+	 *  increment ≈ window/6, growth ≈ window × 0.15 (~25k/22.5k at 150k,
+	 *  2026-11-09 steady-growth recalibration — one fold per ~22.5k of new
+	 *  work instead of one every ~2 minutes; pressure pins the 50-100k band
+	 *  ceiling).]
 	 *  Effective-window cap for the tier math: tier points are computed
 	 *  against min(model-resolved window, cap). 0 = auto (cap follows
 	 *  wmForceTokens, so folds always fire ahead of the handover tier). */
 	trimWindowTokens: z.number().min(0).default(0).volatile(),
 	/** Last N messages of a history are never folded (the live tail the
 	 *  next model call reasons over). */
-	trimProtectedTail: z.number().min(0).max(100).default(6).volatile(),
+	trimProtectedTail: z.number().min(0).max(100).default(10).volatile(),
 	/** Side-model fold cadence cap per rolling hour (emergency mechanical
-	 *  folds are exempt; they have their own cooldown). 16 covers continuous
-	 *  full-rate generation: at ~170 tok/s output a session grows ~612k
-	 *  raw tokens/hour ⇒ 12.2 folds/hour of pure T1 demand (one 50k
-	 *  increment fold every ~4.9 min), leaving 12 starved and zero ladder
-	 *  share; 16 fits the T1 demand plus 2-3 ladder folds plus headroom
-	 *  (observed live: at 12, growth consumed the whole budget). */
-	trimMaxFoldsPerHour: z.number().min(1).max(60).default(16).volatile(),
+	 *  folds are exempt; they have their own cooldown). 30 sits just above
+	 *  the pure T1 demand of continuous full-rate generation (~27 folds/hour
+	 *  at the 22.5k growth cadence and ~170 tok/s output), so it only bites
+	 *  on runaway churn; at the old cap of 16 growth consumed the whole
+	 *  budget and the ladder starved. */
+	trimMaxFoldsPerHour: z.number().min(1).max(60).default(30).volatile(),
 	/** Route for the side-model summarizer (L3). Empty = inherit the
 	 *  session's current model. */
 	trimSideModel: IntentRouteSchema.default({ provider: "", model: "" }).volatile(),

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
@@ -121,9 +135,10 @@ export function recentTrimViewTokensOf(sessionId, maxAgeMs = TRIM_VIEW_MAX_AGE_M
  * system/tool sections (a session-shape-dependent mass — live decision-log
  * pairs drift −5k…+6k between view and wire in steady state), so a
  * view-only watermark tightens every protective tier late by exactly that
- * mass, and the wmHardTokens-95k ≙ trim-pressure-90k alignment (c453b91)
- * is silently defeated. The wire half comes from accepted MAIN dispatches
- * only (noteTrimWireTokens below). Same sticky gate as the view bridge;
+ * mass, and the wmHardTokens-95k ≈ trim-pressure-97.5k adjacency (65%
+ * of the 150k window) is silently defeated. The wire half comes from
+ * accepted MAIN dispatches only (noteTrimWireTokens below). Same sticky
+ * gate as the view bridge;
  * fail-open — null means the caller falls back to the stored tally. */
 export function recentTrimPromptTokensOf(sessionId, maxAgeMs = TRIM_VIEW_MAX_AGE_MS) {
 	try {
@@ -233,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 */
@@ -477,11 +496,11 @@ export function applyContextTrim(ctx, config) {
 	};
 	const thresholdsNow = () => ({
 		growthTokens: readNumber(config, "trimGrowthTokens", 22_500),
-		incrementTokens: readNumber(config, "trimIncrementTokens", 50_000),
-		pressurePercent: readNumber(config, "trimPressurePercent", 60),
+		incrementTokens: readNumber(config, "trimIncrementTokens", 25_000),
+		pressurePercent: readNumber(config, "trimPressurePercent", 65),
 		emergencyPercent: readNumber(config, "trimEmergencyPercent", 95),
-		protectedTail: Math.max(0, Math.round(readNumber(config, "trimProtectedTail", 6))),
-		maxFoldsPerHour: readNumber(config, "trimMaxFoldsPerHour", 16),
+		protectedTail: Math.max(0, Math.round(readNumber(config, "trimProtectedTail", 10))),
+		maxFoldsPerHour: readNumber(config, "trimMaxFoldsPerHour", 30),
 		ladderT2Tokens: readNumber(config, "trimLadderT2Tokens", 8_000),
 		ladderT2MinBlocks: readNumber(config, "trimLadderT2MinBlocks", 3),
 		ladderT3Tokens: readNumber(config, "trimLadderT3Tokens", 6_000),
@@ -575,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;
@@ -672,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);
@@ -693,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;
 	}
@@ -732,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");
@@ -778,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");
@@ -1145,14 +1181,19 @@ export function applyContextTrim(ctx, config) {
 			// Fallback fold check on the stream path: the agent/status idle event
 			// may not reach a globally-registered listener on every host topology,
 			// so each stream end also runs a throttled (60 s/session) check. The
-			// trigger's own cadence gates still guard over-folding.
+			// trigger's own cadence gates still guard over-folding. After the fold
+			// check, chain a surface sweep: fold blocks commit mid-run even for
+			// sessions whose dispatches are host-frozen (subagent children see
+			// exactly ONE idle — at task end — so without this their wire ships
+			// raw history until they finish; the sweep is the only relief channel
+			// that reaches frozen dispatches). Same 60 s cadence, fail-open.
 			try {
 				if (enabledNow() && modeNow() === "auto" && wrappedSession !== null) {
 					const nowMs = Date.now();
 					if (nowMs - (lastStreamCheckAt.get(wrappedSession) ?? 0) >= 60_000) {
 						lastStreamCheckAt.set(wrappedSession, nowMs);
 						if (lastStreamCheckAt.size > 200) lastStreamCheckAt.delete(lastStreamCheckAt.keys().next().value);
-						void maybeFold(wrappedSession, "stream");
+						void maybeFold(wrappedSession, "stream").finally(() => surfacePass.sweep(wrappedSession, "stream"));
 					}
 				}
 			} catch {

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;
 		},
@@ -110,18 +108,26 @@ export function createMetrics() {
 }
 
 /** Wrap a stream result so each chunk flows through a (failing-open)
- * sampler before being yielded. Returns the original value untouched when
- * it is not an async iterable (non-stream fallbacks must pass through). */
-export function wrapStreamForMetrics(result, onChunk) {
+ * sampler before being yielded. An optional completion callback runs when
+ * iteration finishes or is closed; non-stream fallbacks pass through untouched. */
+export function wrapStreamForMetrics(result, onChunk, onFinally = null) {
 	if (result === null || typeof result !== "object" || typeof result[Symbol.asyncIterator] !== "function") return result;
 	async function* sampled() {
-		for await (const chunk of result) {
+		try {
+			for await (const chunk of result) {
+				try {
+					onChunk(chunk);
+				} catch {
+					/* sampling must never break the stream */
+				}
+				yield chunk;
+			}
+		} finally {
 			try {
-				onChunk(chunk);
+				onFinally?.();
 			} catch {
-				/* sampling must never break the stream */
+				/* completion callbacks must never break the stream */
 			}
-			yield chunk;
 		}
 	}
 	return sampled();