dsh-switchman 1.11.4 → 1.11.5

package/README.de.md

@@ -33,7 +33,7 @@ Die Session-Kopfzeile zeigt sofort, was los ist: das ⚡-Abzeichen „autonomes
 
 **7. `/vision`: reine Textmodelle kriegen trotzdem Bilder.** Kann das Hauptmodell keine Bilder lesen, lehnt DSH Bildnachrichten an der Tür ab. Bild einfügen, `/vision was ist an diesem Bild falsch` eintippen — das Bild geht an ein Modell aus dem Vision-Pool, das Urteil kommt in die laufende Session zurück. Über dem Eingabefeld steht vorab „das aktuelle Modell kann keine Bilder lesen“; wird der direkte Bildversand abgelehnt, wird die Nachricht automatisch als `/vision` umgeschrieben und erneut gesendet — kein manueller zweiter Versuch. Ohne konfigurierten Vision-Pool verweigert der Befehl und weist auf die Einstellungen.
 
-**8. Intent-Routing: das passende Modell stellt sich von selbst ein.** Auf der Einstellungsseite gibt es eine neue Gruppe „Intent-Routing“: einen Hauptschalter (standardmäßig aus — zum Einschalten sind ein Klassifikator und mindestens ein Kandidat nötig), die Small-Model-Route des Klassifikators (Provider + Modell + optionaler Aufwand — TypeSafe-Jev-artige Entscheidungsmodelle wie allgemeine Chatmodelle funktionieren gleichermaßen, die Ausgabe wird tolerant geparst), eine Dreifachwahl des Klassifikatortyps (auto / decision / chat), eine eigene Kandidatenliste (je Kandidat Provider + Modell + optionaler Aufwand + eine Zeile Fähigkeitsbeschreibung), das Cache-Fenster in Sekunden (Standard 300, abgestimmt auf die Prompt-Caches der Anbieter von rund 5 Minuten), die Umschalt-Vertrauensschwelle (Standard 80), das Klassifikations-Timeout (Standard 60000 ms), die Anzahl der Verlaufsnachrichten (Standard 6) samt Zeichenbudget (Standard 2400) und ein optionales Fallback-Modell. In der Modellauswahl erscheint unter der Gruppe „Auto · Switchman“ der Eintrag „Auto“ (der Client rendert ihn lokalisiert — auf Deutsch „Automatisch (Intent-Routing)“); ist er gewählt, stuft der Klassifikator jede Nutzernachricht ein und der Entscheid gilt für die jeweilige Runde: Bei zu geringem Vertrauen oder noch offenem Cache-Fenster bleibt das aktuelle Modell in Verwendung (sein Cache wird weitergenutzt); gewechselt wird erst, wenn das Vertrauen hoch genug ist oder das aktuelle Modell nicht unter den Kandidaten steht. Der Wechsel geschieht still auf der Aufrufebene — keine „Modell gewechselt“-Nachricht landet in der Session. Über dem Eingabefeld sitzt ein Status-Chip (bei aktivem Routing zeigt er das aktuelle Routing-Modell und das Vertrauen der letzten Entscheidung); Kandidaten und Schwellen stehen jederzeit auf der Einstellungsseite.
+**8. Intent-Routing: das passende Modell stellt sich von selbst ein.** Auf der Einstellungsseite gibt es eine neue Gruppe „Intent-Routing“: einen Hauptschalter (standardmäßig aus — zum Einschalten sind ein Klassifikator und mindestens ein Kandidat nötig), die Small-Model-Route des Klassifikators (Provider + Modell + optionaler Aufwand — TypeSafe-Jev-artige Entscheidungsmodelle wie allgemeine Chatmodelle funktionieren gleichermaßen, die Ausgabe wird tolerant geparst), eine Dreifachwahl des Klassifikatortyps (auto / decision / chat), eine eigene Kandidatenliste (je Kandidat Provider + Modell + optionaler Aufwand + eine Zeile Fähigkeitsbeschreibung), das Cache-Fenster in Sekunden (Standard 300, abgestimmt auf die Prompt-Caches der Anbieter von rund 5 Minuten), die Umschalt-Vertrauensschwelle (Standard 80), das Klassifikations-Timeout (Standard 60000 ms), die Anzahl der Verlaufsnachrichten (Standard 6) samt Zeichenbudget (Standard 2400) und ein optionales Fallback-Modell (mit unabhängigem optionalem Effort-Pin; ohne Pin gilt der Standard des ausgewählten Fallback-Modells, unabhängig vom Klassifikator). In der Modellauswahl erscheint unter der Gruppe „Auto · Switchman“ der Eintrag „Auto“ (der Client rendert ihn lokalisiert — auf Deutsch „Automatisch (Intent-Routing)“); ist er gewählt, stuft der Klassifikator jede Nutzernachricht ein und der Entscheid gilt für die jeweilige Runde: Bei zu geringem Vertrauen oder noch offenem Cache-Fenster bleibt das aktuelle Modell in Verwendung (sein Cache wird weitergenutzt); gewechselt wird erst, wenn das Vertrauen hoch genug ist oder das aktuelle Modell nicht unter den Kandidaten steht. Der Wechsel geschieht still auf der Aufrufebene — keine „Modell gewechselt“-Nachricht landet in der Session. Über dem Eingabefeld sitzt ein Status-Chip (bei aktivem Routing zeigt er das aktuelle Routing-Modell und das Vertrauen der letzten Entscheidung); Kandidaten und Schwellen stehen jederzeit auf der Einstellungsseite.
 
 Auch mit nur einem Modell lohnt sich die Installation — Wasserstandskontrolle und gestufte Verifikation hängen nicht von der Modellzahl ab; lange Single-Model-Sessions profitieren genauso.
 
@@ -129,8 +129,8 @@ Alle Schlüssel liegen unter Einstellungen → dsh-switchman; Defaults aus `host
 | `trimWindowTokens` | `0` | Effektives Fensterlimit für die Stufenberechnung: gerechnet gegen min(Modellfenster, Limit). `0` = folgt `wmForceTokens`. |
 | `trimProtectedTail` | `10` | Die letzten N Nachrichten werden nie gefaltet. |
 | `trimMaxFoldsPerHour` | `30` | Fold-Takt-Obergrenze pro rollierender Stunde für Nebenmodell-Folds (Notfall-Folds ausgenommen). |
-| `trimSideModel` | nicht gesetzt | Route des zusammenfassenden Nebenmodells. Leer = das aktuelle Session-Modell erben. |
-| `trimFoldFallbackModel` | nicht gesetzt | Route, mit der der Fold den Zusammenfassungs-Versuch wiederholt; scheitert auch sie, degradiert ein Pressure-Fold zu mechanischem Folding. Leer = kein Fallback. Route mit Spielraum bei Cooldowns, Risikokontrolle und Concurrency wählen. |
+| `trimSideModel` | nicht gesetzt | Route des Zusammenfassungs-Nebenmodells. Leer = Provider/Modell der Session folgen, aber den Effort des Aufrufs nicht übernehmen; auch Ladder-Distillationen nutzen diese Route. Der Effort für Zusammenfassungen lässt sich separat festlegen; ohne Pin wird anhand der Modellmetadaten die niedrigste aktivierte Reasoning-Stufe gewählt, bei Modellen mit nur Ein/Aus off. Wird Reasoning nicht unterstützt oder sind keine Metadaten verfügbar, wird kein Effort gesendet und das Modell-/Adapter-Standardverhalten bleibt maßgeblich. |
+| `trimFoldFallbackModel` | nicht gesetzt | Route, mit der der Fold den Zusammenfassungs-Versuch wiederholt; scheitert auch sie, degradiert ein Pressure-Fold zu mechanischem Folding. Leer = kein Fallback. Das Effort des manuell gewählten Fold-Fallback-Modells ist unabhängig; ohne Pin gilt dieselbe Metadaten-Empfehlung wie beim Zusammenfassungsmodell, ohne Metadaten der Modellstandard. Route mit Spielraum bei Cooldowns, Risikokontrolle und Concurrency wählen. |
 | `trimStateDir` | nicht gesetzt | Überschreibt das Fold-Zustandsverzeichnis. Leer = `<dshHome>/.dsh-switchman/state/trim/`. |
 | `surfaceFold` | `true` | Liefert committete Folds auf die Session-Oberfläche aus (Shadow-Price-Messereignis + `surfaceOp`-Replace-Ereignispaar). OFF behält die rein gesplicte View. |
 

package/README.es.md

@@ -33,7 +33,7 @@ La cabecera de la sesión da un feedback visual claro: la insignia ⚡ «equipo
 
 **7. `/vision`: hasta un modelo de solo texto puede con las imágenes.** Cuando el modelo principal no sabe leer imágenes, DSH rechaza en la puerta de entrada los mensajes con imágenes. Adjunta la imagen y escribe `/vision ¿qué está mal en esta imagen?` — la imagen se entrega a un modelo del pool multimodal para leerla, y la conclusión vuelve a la sesión actual. Sobre el cuadro de entrada aparece por adelantado el aviso «el modelo actual no sabe leer imágenes»; si un envío directo de imagen es rechazado, se reescribe una vez de forma automática a `/vision` y se reenvía, sin rehacer nada a mano; con el pool multimodal sin configurar, el comando se niega y da indicaciones de configuración.
 
-**8. Enrutado por intención: el modelo adecuado se elige solo.** La página de ajustes estrena un grupo «Enrutado por intención»: un interruptor maestro (apagado por defecto; para activarlo hacen falta un clasificador y al menos un candidato), la ruta de modelo pequeño del clasificador (provider + model + effort opcional — valen tanto modelos de decisión tipo TypeSafe Jev como modelos de chat genéricos, y la salida se interpreta con tolerancia), un selector de tipo de clasificador a tres bandas (auto / decision / chat), una lista de candidatos independiente (cada candidato: provider + model + effort opcional + una nota de capacidades de una línea), la ventana de caché en segundos (300 por defecto, alineada con las cachés de prompt de los proveedores, unos 5 minutos), el umbral de confianza para el cambio (80 por defecto), el timeout de clasificación (60000 ms por defecto), el número de mensajes del historial (6 por defecto) y el presupuesto de caracteres (2400 por defecto), y un modelo de respaldo opcional. En el selector de modelos aparece una entrada «Auto» dentro del grupo «Auto · Switchman» (el cliente la muestra localizada — «Automático (enrutado por intención)» en español); elegida, cada mensaje del usuario pasa por el clasificador para decidir el mejor candidato y la decisión queda fijada por ese turno: si la confianza no llega o la ventana de caché sigue abierta, se mantiene el modelo actual (reaprovechando su caché); solo se cambia cuando la confianza sobra o el modelo actual no está entre los candidatos. El cambio ocurre en silencio en la capa de llamada — no se inserta ningún mensaje de «modelo cambiado» en la sesión. Sobre el cuadro de entrada hay un chip de estado (con enrutado automático muestra el modelo en ruta y la confianza de la última decisión); los candidatos y los umbrales se consultan siempre en la página de ajustes.
+**8. Enrutado por intención: el modelo adecuado se elige solo.** La página de ajustes estrena un grupo «Enrutado por intención»: un interruptor maestro (apagado por defecto; para activarlo hacen falta un clasificador y al menos un candidato), la ruta de modelo pequeño del clasificador (provider + model + effort opcional — valen tanto modelos de decisión tipo TypeSafe Jev como modelos de chat genéricos, y la salida se interpreta con tolerancia), un selector de tipo de clasificador a tres bandas (auto / decision / chat), una lista de candidatos independiente (cada candidato: provider + model + effort opcional + una nota de capacidades de una línea), la ventana de caché en segundos (300 por defecto, alineada con las cachés de prompt de los proveedores, unos 5 minutos), el umbral de confianza para el cambio (80 por defecto), el timeout de clasificación (60000 ms por defecto), el número de mensajes del historial (6 por defecto) y el presupuesto de caracteres (2400 por defecto), y un modelo de respaldo opcional (con un pin de effort opcional e independiente; si no se fija, se usa el valor predeterminado del modelo de respaldo seleccionado, separado del effort del clasificador). En el selector de modelos aparece una entrada «Auto» dentro del grupo «Auto · Switchman» (el cliente la muestra localizada — «Automático (enrutado por intención)» en español); elegida, cada mensaje del usuario pasa por el clasificador para decidir el mejor candidato y la decisión queda fijada por ese turno: si la confianza no llega o la ventana de caché sigue abierta, se mantiene el modelo actual (reaprovechando su caché); solo se cambia cuando la confianza sobra o el modelo actual no está entre los candidatos. El cambio ocurre en silencio en la capa de llamada — no se inserta ningún mensaje de «modelo cambiado» en la sesión. Sobre el cuadro de entrada hay un chip de estado (con enrutado automático muestra el modelo en ruta y la confianza de la última decisión); los candidatos y los umbrales se consultan siempre en la página de ajustes.
 
 ¿Solo tienes un modelo? Sigue mereciendo la instalación — el control del nivel de agua y la verificación por niveles no dependen de cuántos modelos tengas, y una sesión larga con un solo modelo se beneficia igual.
 
@@ -129,8 +129,8 @@ Todas las claves viven en Ajustes → dsh-switchman; los valores por defecto sal
 | `trimWindowTokens` | `0` | Límite de ventana efectivo para el cálculo de niveles: se calcula sobre min(ventana del modelo, límite). `0` = sigue a `wmForceTokens`. |
 | `trimProtectedTail` | `10` | Los últimos N mensajes nunca se pliegan. |
 | `trimMaxFoldsPerHour` | `30` | Tope de cadencia de folds por hora móvil para el modelo secundario (los de emergencia quedan exentos). |
-| `trimSideModel` | sin definir | Ruta del modelo secundario que escribe los resúmenes. Vacía = heredar el modelo actual de la sesión. |
-| `trimFoldFallbackModel` | sin definir | Ruta de reintento cuando falla el modelo secundario de resúmenes; un fold de presión degrada entonces a mecánico. Vacía = sin respaldo. Elige una ruta con margen en cooldowns, control de riesgo y concurrencia. |
+| `trimSideModel` | sin definir | Ruta del modelo secundario que escribe los resúmenes. Vacía = seguir el provider/model de la sesión, sin heredar el effort de esa llamada; la destilación ladder también usa esta ruta. El effort del resumen admite un pin manual independiente; si no se fija, los metadatos del modelo recomiendan el nivel de reasoning habilitado más bajo; si el modelo solo tiene interruptor sí/no, se elige off. Si no admite reasoning o faltan metadatos, no se envía effort y se conserva el comportamiento predeterminado del modelo/adaptador. |
+| `trimFoldFallbackModel` | sin definir | Ruta de reintento cuando falla el modelo secundario de resúmenes; un fold de presión degrada entonces a mecánico. Vacía = sin respaldo. El modelo de respaldo de fold elegido manualmente tiene un pin de effort independiente; si no se fija, usa la misma recomendación por metadatos que el modelo de resumen, y si faltan metadatos, el valor predeterminado del modelo. Elige una ruta con margen en cooldowns, control de riesgo y concurrencia. |
 | `trimStateDir` | sin definir | Anula el directorio del estado de folds. Vacía = `<dshHome>/.dsh-switchman/state/trim/`. |
 | `surfaceFold` | `true` | Envía los folds confirmados a la superficie de la sesión (par de eventos de medición shadow-price + replace con `surfaceOp`). Apagado conserva la vista de solo empalme. |
 

package/README.fr.md

@@ -33,7 +33,7 @@ L'en-tête de session donne un retour immédiat : un badge ⚡ « équipe autono
 
 **7. `/vision` : même un modèle purement textuel peut travailler avec des images.** Quand le modèle principal ne sait pas lire les images, DSH refuse les messages avec image dès l'entrée. Collez l'image, tapez `/vision où est l'erreur sur cette image`, et l'image est confiée à un modèle du pool multimodal pour lecture ; les conclusions reviennent dans la session courante. Un avertissement apparaît tôt au-dessus du champ de saisie — « le modèle courant ne sait pas lire les images » ; si un envoi d'image ordinaire est refusé, le brouillon est réécrit une fois en `/vision` et renvoyé tout seul, sans rien retaper ; sans pool multimodal configuré, la commande refuse et donne les indications de configuration.
 
-**8. Routage par intention : le bon modèle se choisit tout seul.** La page de réglages accueille un nouveau groupe « Routage par intention » : un interrupteur général (désactivé par défaut ; l'activer exige un classifieur et au moins un candidat), la route du petit modèle classifieur (provider + model + effort facultatif — les modèles de décision type TypeSafe Jev comme les modèles de conversation génériques conviennent, et la sortie est analysée avec tolérance), un choix du type de classifieur à trois options (auto / decision / chat), une liste de candidats indépendante (chaque candidat : provider + model + effort facultatif + une note de capacité d'une ligne), la fenêtre de cache en secondes (300 par défaut, calée sur les caches de prompt des fournisseurs, environ 5 minutes), le seuil de confiance du basculement (80 par défaut), le timeout de classification (60000 ms par défaut), le nombre de messages d'historique (6 par défaut) et le budget de caractères (2400 par défaut), et un modèle de repli facultatif. Le sélecteur de modèles gagne une entrée « Auto » dans le groupe « Auto · Switchman » (le client la rend localisée — « Automatique (routage par intention) » en français) ; une fois choisie, chaque message utilisateur passe par le classifieur pour désigner le meilleur candidat, et la décision est verrouillée pour ce tour : si la confiance manque ou que la fenêtre de cache est encore ouverte, le modèle courant reste en place (son cache est réutilisé) ; on ne bascule que lorsque la confiance est suffisante ou que le modèle courant ne fait pas partie des candidats. Le basculement se fait en silence à la couche d'appel — aucun message « modèle changé » n'est inséré dans la session. Au-dessus du champ de saisie figure une pastille d'état (en routage automatique, elle montre le modèle routé courant et la confiance de la dernière décision) ; candidats et seuils restent consultables dans la page de réglages.
+**8. Routage par intention : le bon modèle se choisit tout seul.** La page de réglages accueille un nouveau groupe « Routage par intention » : un interrupteur général (désactivé par défaut ; l'activer exige un classifieur et au moins un candidat), la route du petit modèle classifieur (provider + model + effort facultatif — les modèles de décision type TypeSafe Jev comme les modèles de conversation génériques conviennent, et la sortie est analysée avec tolérance), un choix du type de classifieur à trois options (auto / decision / chat), une liste de candidats indépendante (chaque candidat : provider + model + effort facultatif + une note de capacité d'une ligne), la fenêtre de cache en secondes (300 par défaut, calée sur les caches de prompt des fournisseurs, environ 5 minutes), le seuil de confiance du basculement (80 par défaut), le timeout de classification (60000 ms par défaut), le nombre de messages d'historique (6 par défaut) et le budget de caractères (2400 par défaut), et un modèle de repli facultatif (avec un pin d'effort facultatif et indépendant ; sans pin, l'effort par défaut du modèle de repli sélectionné s'applique, indépendamment de celui du classifieur). Le sélecteur de modèles gagne une entrée « Auto » dans le groupe « Auto · Switchman » (le client la rend localisée — « Automatique (routage par intention) » en français) ; une fois choisie, chaque message utilisateur passe par le classifieur pour désigner le meilleur candidat, et la décision est verrouillée pour ce tour : si la confiance manque ou que la fenêtre de cache est encore ouverte, le modèle courant reste en place (son cache est réutilisé) ; on ne bascule que lorsque la confiance est suffisante ou que le modèle courant ne fait pas partie des candidats. Le basculement se fait en silence à la couche d'appel — aucun message « modèle changé » n'est inséré dans la session. Au-dessus du champ de saisie figure une pastille d'état (en routage automatique, elle montre le modèle routé courant et la confiance de la dernière décision) ; candidats et seuils restent consultables dans la page de réglages.
 
 Un seul modèle ? Ça vaut quand même l'installation — le contrôle du niveau d'eau et la vérification par paliers se moquent du nombre de modèles, et une longue session mono-modèle en profite tout autant.
 
@@ -129,8 +129,8 @@ Toutes les clés vivent dans Réglages → dsh-switchman ; les valeurs par défa
 | `trimWindowTokens` | `0` | Plafond de fenêtre effectif pour le calcul des paliers : calculé sur min(fenêtre du modèle, plafond). `0` = suit `wmForceTokens`. |
 | `trimProtectedTail` | `10` | Les N derniers messages ne sont jamais repliés. |
 | `trimMaxFoldsPerHour` | `30` | Plafond de cadence des folds par heure glissante pour le modèle annexe (les folds d'urgence en sont exemptés). |
-| `trimSideModel` | non définie | Route du modèle annexe qui écrit les résumés. Vide = hériter du modèle courant de la session. |
-| `trimFoldFallbackModel` | non définie | Route de relance quand le modèle annexe de résumé échoue ; un fold de pression dégrade alors en mécanique. Vide = pas de repli. Choisir une route avec de la marge sur cooldowns, contrôle de risque et concurrence. |
+| `trimSideModel` | non définie | Route du modèle annexe qui écrit les résumés. Vide = suivre le provider/model de la session, sans hériter de l'effort de cet appel ; les distillations ladder utilisent aussi cette route. L'effort du résumé peut être fixé séparément ; sans pin, les métadonnées du modèle déterminent le niveau de reasoning activé le plus bas ; pour un modèle limité à un interrupteur on/off, choisir off. Si le reasoning n'est pas pris en charge ou si les métadonnées sont indisponibles, aucun effort n'est envoyé et le comportement par défaut du modèle/de l'adaptateur s'applique. |
+| `trimFoldFallbackModel` | non définie | Route de relance quand le modèle annexe de résumé échoue ; un fold de pression dégrade alors en mécanique. Vide = pas de repli. Le modèle de repli du fold choisi manuellement a un pin d'effort indépendant ; sans pin, appliquer la même recommandation par métadonnées que pour le modèle de résumé, et en l'absence de métadonnées, le défaut du modèle. Choisir une route avec de la marge sur cooldowns, contrôle de risque et concurrence. |
 | `trimStateDir` | non défini | Redéfinit le répertoire d'état des folds. Vide = `<dshHome>/.dsh-switchman/state/trim/`. |
 | `surfaceFold` | `true` | Expédie les folds validés sur la surface de session (paire d'événements : mesure shadow-price + remplacement `surfaceOp`). Désactivé, la vue reste en splice seul. |
 

package/README.it.md

@@ -33,7 +33,7 @@ L'intestazione della sessione dà un riscontro immediato: badge ⚡ «Squadra au
 
 **7. `/vision`: anche i modelli solo testo trattano le immagini.** Quando il modello principale non sa leggere le immagini, DSH rifiuta al varco i messaggi che le contengono. Alleghi l'immagine e digiti `/vision dov'è l'errore in questa immagine`: l'immagine viene affidata alla lettura di un modello del pool multimodale, e la conclusione torna nella sessione corrente. Sopra la casella di input compare in anticipo l'avviso «il modello corrente non supporta la lettura delle immagini»; se un invio diretto dell'immagine viene rifiutato, il messaggio viene riscritto una volta in `/vision` e reinviato da solo, senza dover rifare tutto a mano; senza pool multimodale configurato, il comando rifiuta e indica come configurarlo.
 
-**8. Instradamento per intent: il modello giusto si sceglie da sé.** La pagina delle impostazioni si arricchisce di un gruppo «Instradamento per intent»: un interruttore principale (spento per predefinito; per attivarlo servono un classificatore e almeno un candidato), la route del piccolo modello classificatore (provider + model + effort facoltativo — vanno bene sia i modelli decisionali tipo TypeSafe Jev sia i modelli di chat generici, e l'output viene letto con tolleranza), una scelta a tre vie del tipo di classificatore (auto / decision / chat), una lista di candidati indipendente (per ogni candidato: provider + model + effort facoltativo + una nota di capacità di una riga), la finestra di cache in secondi (300 per predefinito, allineata alle cache di prompt dei provider, circa 5 minuti), la soglia di confidenza per il cambio (80 per predefinito), il timeout di classificazione (60000 ms per predefinito), il numero di messaggi di cronologia (6 per predefinito) e il budget di caratteri (2400 per predefinito), più un modello di fallback facoltativo. Nel selettore dei modelli compare una voce «Auto» nel gruppo «Auto · Switchman» (il client la renderizza localizzata — «Automatico (instradamento per intent)» in italiano); una volta scelta, ogni messaggio dell'utente passa dal classificatore per eleggere il candidato migliore e la decisione resta fissata per quel turno: se la confidenza non basta o la finestra di cache è ancora aperta, resta il modello corrente (riusandone la cache); si cambia solo quando la confidenza è sufficiente o il modello corrente non è tra i candidati. Il cambio avviene in silenzio al livello di chiamata — nessun messaggio «modello cambiato» finisce nella sessione. Sopra la casella di input c'è una chip di stato (con instradamento automatico mostra il modello di instradamento corrente e la confidenza dell'ultima decisione); candidati e soglie si consultano sempre nella pagina delle impostazioni.
+**8. Instradamento per intent: il modello giusto si sceglie da sé.** La pagina delle impostazioni si arricchisce di un gruppo «Instradamento per intent»: un interruttore principale (spento per predefinito; per attivarlo servono un classificatore e almeno un candidato), la route del piccolo modello classificatore (provider + model + effort facoltativo — vanno bene sia i modelli decisionali tipo TypeSafe Jev sia i modelli di chat generici, e l'output viene letto con tolleranza), una scelta a tre vie del tipo di classificatore (auto / decision / chat), una lista di candidati indipendente (per ogni candidato: provider + model + effort facoltativo + una nota di capacità di una riga), la finestra di cache in secondi (300 per predefinito, allineata alle cache di prompt dei provider, circa 5 minuti), la soglia di confidenza per il cambio (80 per predefinito), il timeout di classificazione (60000 ms per predefinito), il numero di messaggi di cronologia (6 per predefinito) e il budget di caratteri (2400 per predefinito), più un modello di fallback facoltativo (con un pin di effort facoltativo e indipendente; se non fissato, si usa l'effort predefinito del modello di fallback selezionato, separato da quello del classificatore). Nel selettore dei modelli compare una voce «Auto» nel gruppo «Auto · Switchman» (il client la renderizza localizzata — «Automatico (instradamento per intent)» in italiano); una volta scelta, ogni messaggio dell'utente passa dal classificatore per eleggere il candidato migliore e la decisione resta fissata per quel turno: se la confidenza non basta o la finestra di cache è ancora aperta, resta il modello corrente (riusandone la cache); si cambia solo quando la confidenza è sufficiente o il modello corrente non è tra i candidati. Il cambio avviene in silenzio al livello di chiamata — nessun messaggio «modello cambiato» finisce nella sessione. Sopra la casella di input c'è una chip di stato (con instradamento automatico mostra il modello di instradamento corrente e la confidenza dell'ultima decisione); candidati e soglie si consultano sempre nella pagina delle impostazioni.
 
 Un solo modello? Vale comunque la pena installarlo — il controllo del livello dell'acqua e la verifica a livelli non guardano a quanti modelli hai, e ne giovancono allo stesso modo le sessioni lunghe con un modello unico.
 
@@ -129,8 +129,8 @@ Tutte le chiavi stanno in Impostazioni → dsh-switchman; i valori predefiniti v
 | `trimWindowTokens` | `0` | Limite di finestra effettivo per il calcolo delle soglie: calcolato su min(finestra del modello, limite). `0` = segue `wmForceTokens`. |
 | `trimProtectedTail` | `10` | Gli ultimi N messaggi non vengono mai ripiegati. |
 | `trimMaxFoldsPerHour` | `30` | Tetto di cadenza dei fold per ora mobile per il modello secondario (quelli di emergenza ne sono esenti). |
-| `trimSideModel` | non impostata | Route del modello secondario che scrive i riassunti. Vuota = eredita il modello attuale della sessione. |
-| `trimFoldFallbackModel` | non impostata | Route di ripiego quando il modello secondario dei riassunti fallisce; un fold di pressione degrada quindi a meccanico. Vuota = nessun fallback. Scegli una route con margine su cooldown, risk control e concorrenza. |
+| `trimSideModel` | non impostata | Route del modello secondario che scrive i riassunti. Vuota = seguire il provider/model della sessione, senza ereditare l'effort della chiamata; anche le ladder distillation usano questa route. L'effort del riepilogo si può fissare separatamente; senza pin, i metadati del modello scelgono il livello reasoning abilitato più basso; per i modelli con solo interruttore on/off, scegliere off. Se reasoning non è supportato o i metadati non sono disponibili, non si invia effort e si mantiene il comportamento predefinito del modello/adattatore. |
+| `trimFoldFallbackModel` | non impostata | Route di ripiego quando il modello secondario dei riassunti fallisce; un fold di pressione degrada quindi a meccanico. Vuota = nessun fallback. Il modello di fallback del fold scelto manualmente ha un pin di effort indipendente; senza pin, usa la stessa raccomandazione basata sui metadati del modello di riepilogo e, se mancano metadati, il valore predefinito del modello. Scegli una route con margine su cooldown, risk control e concorrenza. |
 | `trimStateDir` | non impostata | Sostituisce la directory dello stato dei fold. Vuota = `<dshHome>/.dsh-switchman/state/trim/`. |
 | `surfaceFold` | `true` | Spedisce i fold confermati sulla superficie della sessione (coppia di eventi: misurazione shadow-price + replace `surfaceOp`). OFF mantiene la vista a solo splice. |
 

package/README.ja.md

@@ -33,7 +33,7 @@ dsh-switchman は [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-har
 
 **7. `/vision`：テキスト専用モデルでも画像を扱える。** 主力モデルが画像を読めないとき、DSH は画像付きメッセージを入口で拒否する。画像を貼って `/vision この画像のどこが悪い` と打てば、画像は vision プールのモデルへ渡され、結論は現在のセッションに戻る。入力欄の上には「現在のモデルは画像を読めません」の事前表示が出る。画像を直接送って拒否されたら、自動で `/vision` に書き換えて再送するので手直しは不要。vision プールが未設定ならコマンドは拒否し、設定への案内を出す。
 
-**8. 意図ルーティング：最適なモデルを自動で選ぶ。** 設定ページに「意図認識」グループが増える：マスタートグル（既定オフ、有効化には分類器と候補が最低1つ必要）、分類器用の小型モデルルート（provider + model + 任意の effort。TypeSafe Jev 系の決定モデルも汎用対話モデルも使え、出力は寛容にパースされる）、分類器タイプの3択（auto / decision / chat）、独立した候補モデルリスト（各候補に provider + model + 任意の effort + 一行の能力説明）、キャッシュウィンドウ秒数（既定 300、ベンダーの prompt cache 約5分に合わせる）、切替信頼度しきい値（既定 80）、分類タイムアウト（既定 60000ms）、履歴メッセージ件数（既定 6）と文字数予算（既定 2400）、任意のフォールバックモデル。モデルセレクターの「Auto · Switchman」グループの下に「Auto」エントリが現れる（クライアントは「自動（意図認識）」とローカライズして表示）；選んでおくとユーザーメッセージごとに分類器が最適な候補を判定し、判断はそのターンの間固定される：信頼度が足りない、またはまだキャッシュウィンドウ内なら現在のモデルをそのまま使い（キャッシュを再利用）、信頼度が十分高い、または現在のモデルが候補にないときだけ切り替わる。切替は呼び出し層で静かに行われ、「モデルを切り替えました」のメッセージをセッションに差し込まない。入力欄の上には状態 chip（自動ルーティング中は現在のルーティング先モデルと最後の判断の信頼度を表示）。候補としきい値はいつでも設定ページで確認できる。
+**8. 意図ルーティング：最適なモデルを自動で選ぶ。** 設定ページに「意図認識」グループが増える：マスタートグル（既定オフ、有効化には分類器と候補が最低1つ必要）、分類器用の小型モデルルート（provider + model + 任意の effort。TypeSafe Jev 系の決定モデルも汎用対話モデルも使え、出力は寛容にパースされる）、分類器タイプの3択（auto / decision / chat）、独立した候補モデルリスト（各候補に provider + model + 任意の effort + 一行の能力説明）、キャッシュウィンドウ秒数（既定 300、ベンダーの prompt cache 約5分に合わせる）、切替信頼度しきい値（既定 80）、分類タイムアウト（既定 60000ms）、履歴メッセージ件数（既定 6）と文字数予算（既定 2400）、任意のフォールバックモデル（任意の effort を独立して固定でき、未設定なら選択したフォールバックモデルのデフォルトを使用。分類器の effort とは別）。モデルセレクターの「Auto · Switchman」グループの下に「Auto」エントリが現れる（クライアントは「自動（意図認識）」とローカライズして表示）；選んでおくとユーザーメッセージごとに分類器が最適な候補を判定し、判断はそのターンの間固定される：信頼度が足りない、またはまだキャッシュウィンドウ内なら現在のモデルをそのまま使い（キャッシュを再利用）、信頼度が十分高い、または現在のモデルが候補にないときだけ切り替わる。切替は呼び出し層で静かに行われ、「モデルを切り替えました」のメッセージをセッションに差し込まない。入力欄の上には状態 chip（自動ルーティング中は現在のルーティング先モデルと最後の判断の信頼度を表示）。候補としきい値はいつでも設定ページで確認できる。
 
 モデルが1つでも入れる価値はある——水位制御と段階的検証はモデルの数と無関係で、単一モデルの長いセッションも同じく恩恵を受ける。
 
@@ -129,8 +129,8 @@ bash <インストールディレクトリ>/skills/db-query/scripts/setup.sh
 | `trimWindowTokens` | `0` | ティア計算の実効ウィンドウ上限：min(モデルウィンドウ, 上限) で計算。`0` = `wmForceTokens` に追従。 |
 | `trimProtectedTail` | `10` | 最後の N メッセージは決して fold されない。 |
 | `trimMaxFoldsPerHour` | `30` | ローリング1時間あたりのサイドモデル fold ペース上限（緊急段は対象外）。 |
-| `trimSideModel` | 未設定 | サマリを書くサイドモデルのルート。空欄 = セッションの現在モデルを継承。 |
-| `trimFoldFallbackModel` | 未設定 | サマリのサイドモデルが失敗したときに折り畳みが再試行するルート。プレッシャー段でも失敗すると機械折り畳みに縮退。空欄 = フォールバックなし。クールダウン・リスク制御・同時実行に余裕のあるルートを推奨。 |
+| `trimSideModel` | 未設定 | サマリ用サイドモデルのルート。空欄 = セッションの provider/model に追従（呼び出しの effort は継承しない）；ladder distillation もこのルートを使用。サマリの effort は別途手動固定でき、未設定ならモデルメタデータから有効な reasoning レベルの最小値を選ぶ。オン/オフのみのモデルは off。reasoning 非対応またはメタデータが利用できない場合は effort を送らず、モデル/アダプターのデフォルトに委ねる。 |
+| `trimFoldFallbackModel` | 未設定 | サマリのサイドモデルが失敗したときに折り畳みが再試行するルート。プレッシャー段でも失敗すると機械折り畳みに縮退。空欄 = フォールバックなし。手動選択した fold フォールバックモデルの effort 固定は独立。未設定ならサマリモデルと同じメタデータ基準で推奨し、メタデータがなければそのモデルのデフォルトを使用。クールダウン・リスク制御・同時実行に余裕のあるルートを推奨。 |
 | `trimStateDir` | 未設定 | fold 状態ディレクトリの上書き。空欄 = `<dshHome>/.dsh-switchman/state/trim/`。 |
 | `surfaceFold` | `true` | コミット済みの fold をセッション表面へ出荷します（shadow-price 計量イベント + `surfaceOp` replace イベントのペア）。OFF はスプライスのみの view を維持。 |
 

package/README.ko.md

@@ -33,7 +33,7 @@ dsh-switchman은 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harn
 
 **7. `/vision`: 텍스트 전용 모델도 이미지를 다룬다.** 주력 모델이 이미지를 못 읽으면 DSH는 이미지 포함 메시지를 입구에서 거절한다. 이미지를 붙이고 `/vision 이 이미지 어디가 잘못됐어`라고 입력하면 이미지는 vision 풀 모델에게 넘어가고 결론이 현재 세션으로 돌아온다. 입력창 위에는 '현재 모델은 이미지를 읽을 수 없음' 안내가 미리 뜬다. 이미지를 직접 보내다 거절되면 자동으로 `/vision`으로 고쳐 다시 보낸다 — 손으로 다시 할 필요 없다. vision 풀이 비어 있으면 명령은 거절하고 설정 안내를 준다.
 
-**8. 의도 라우팅: 알맞은 모델을 자동으로 고른다.** 설정 페이지에 '의도 인식' 그룹이 추가된다: 마스터 토글(기본 꺼짐, 켜려면 분류기와 후보 최소 1개 필요), 분류기용 소형 모델 라우트(provider + model + 선택적 effort. TypeSafe Jev 계열 결정 모델도 범용 대화 모델도 지원하며 출력은 관대하게 파싱된다), 분류기 유형 3택(auto / decision / chat), 독립 후보 모델 목록(후보마다 provider + model + 선택적 effort + 한 줄 능력 설명), 캐시 창 초(기본 300, 벤더 prompt cache 약 5분에 맞춤), 전환 신뢰도 임계값(기본 80), 분류 타임아웃(기본 60000ms), 히스토리 메시지 수(기본 6)와 문자 예산(기본 2400), 선택적 폴백 모델. 모델 선택기의 'Auto · Switchman' 그룹 아래에 'Auto' 항목이 나타난다(클라이언트는 '자동(의도 인식)'으로 현지화해 그린다). 선택해 두면 사용자 메시지마다 분류기가 가장 알맞은 후보를 판정하고 같은 턴 안에서는 결정이 고정된다: 신뢰도가 부족하거나 아직 캐시 창 안이면 현재 모델을 그대로 쓰고(캐시 재사용), 신뢰도가 충분히 높거나 현재 모델이 후보에 없을 때만 전환한다. 전환은 호출 계층에서 조용히 끝나며 세션에 '모델이 전환되었습니다' 메시지를 끼워 넣지 않는다. 입력창 위에는 상태 chip이 뜬다(자동 라우팅 중에는 현재 라우팅 모델과 마지막 판정 신뢰도 표시). 후보와 임계값은 언제든 설정 페이지에서 볼 수 있다.
+**8. 의도 라우팅: 알맞은 모델을 자동으로 고른다.** 설정 페이지에 '의도 인식' 그룹이 추가된다: 마스터 토글(기본 꺼짐, 켜려면 분류기와 후보 최소 1개 필요), 분류기용 소형 모델 라우트(provider + model + 선택적 effort. TypeSafe Jev 계열 결정 모델도 범용 대화 모델도 지원하며 출력은 관대하게 파싱된다), 분류기 유형 3택(auto / decision / chat), 독립 후보 모델 목록(후보마다 provider + model + 선택적 effort + 한 줄 능력 설명), 캐시 창 초(기본 300, 벤더 prompt cache 약 5분에 맞춤), 전환 신뢰도 임계값(기본 80), 분류 타임아웃(기본 60000ms), 히스토리 메시지 수(기본 6)와 문자 예산(기본 2400), 선택적 폴백 모델(선택적 effort를 별도로 고정할 수 있으며, 미설정 시 선택한 폴백 모델의 기본 effort를 사용하고 분류기 effort와는 독립적). 모델 선택기의 'Auto · Switchman' 그룹 아래에 'Auto' 항목이 나타난다(클라이언트는 '자동(의도 인식)'으로 현지화해 그린다). 선택해 두면 사용자 메시지마다 분류기가 가장 알맞은 후보를 판정하고 같은 턴 안에서는 결정이 고정된다: 신뢰도가 부족하거나 아직 캐시 창 안이면 현재 모델을 그대로 쓰고(캐시 재사용), 신뢰도가 충분히 높거나 현재 모델이 후보에 없을 때만 전환한다. 전환은 호출 계층에서 조용히 끝나며 세션에 '모델이 전환되었습니다' 메시지를 끼워 넣지 않는다. 입력창 위에는 상태 chip이 뜬다(자동 라우팅 중에는 현재 라우팅 모델과 마지막 판정 신뢰도 표시). 후보와 임계값은 언제든 설정 페이지에서 볼 수 있다.
 
 모델이 하나뿐이어도 설치할 가치가 있다 — 수위 제어와 단계별 검증은 모델 수와 무관하고, 단일 모델의 긴 세션도 같은 혜택을 본다.
 
@@ -129,8 +129,8 @@ bash <설치-디렉터리>/skills/db-query/scripts/setup.sh
 | `trimWindowTokens` | `0` | 티어 계산의 유효 윈도우 상한: min(모델 윈도우, 상한)으로 계산. `0` = `wmForceTokens`를 따름. |
 | `trimProtectedTail` | `10` | 마지막 N개 메시지는 절대 fold되지 않는다. |
 | `trimMaxFoldsPerHour` | `30` | 롤링 1시간당 사이드 모델 fold 케이던스 상한(비상 단계는 제외). |
-| `trimSideModel` | 미설정 | 요약을 쓰는 사이드 모델 라우트. 비어 있으면 세션의 현재 모델을 상속. |
-| `trimFoldFallbackModel` | 미설정 | 요약 사이드 모델 실패 시 폴드가 재시도하는 라우트. 프레셔 단계에서도 실패하면 기계 폴드로 강등. 비어 있으면 폴백 없음. 쿨다운·리스크 컨트롤·동시 실행에 여유가 있는 라우트 권장. |
+| `trimSideModel` | 미설정 | 요약 side model 라우트. 비어 있으면 세션 provider/model을 따르며 호출의 effort는 상속하지 않음. ladder distillation도 이 라우트를 사용. 요약 effort는 별도로 수동 고정할 수 있으며, 고정하지 않으면 모델 메타데이터에서 사용 가능한 reasoning 단계 중 가장 낮은 단계를 선택. 켜기/끄기만 지원하는 모델은 off. reasoning 미지원 또는 메타데이터 없음이면 effort를 보내지 않아 모델/어댑터 기본 동작을 따름. |
+| `trimFoldFallbackModel` | 미설정 | 요약 side model 실패 시 폴드가 재시도하는 라우트. 프레셔 단계에서도 실패하면 기계 폴드로 강등. 비어 있으면 폴백 없음. 수동으로 선택한 폴드 폴백 모델의 effort는 독립적으로 고정할 수 있으며, 미설정 시 요약 모델과 동일한 메타데이터 추천을 따르고 메타데이터가 없으면 해당 모델 기본값을 사용. 쿨다운·리스크 컨트롤·동시 실행에 여유가 있는 라우트 권장. |
 | `trimStateDir` | 미설정 | fold 상태 디렉터리 재정의. 비어 있으면 `<dshHome>/.dsh-switchman/state/trim/`. |
 | `surfaceFold` | `true` | 커밋된 fold를 세션 표면으로 발송(shadow-price 계량 이벤트 + `surfaceOp` replace 이벤트 쌍). OFF는 스플라이스 전용 view를 유지. |
 

package/README.md

@@ -33,7 +33,7 @@ The session header gives at-a-glance feedback: the ⚡ "autonomous team" badge a
 
 **7. `/vision`: text-only models can still handle images.** When the main model can't read images, DSH rejects image-bearing messages at the gate. Paste the image, type `/vision what's wrong with this image`, and the image goes to a vision-pool model; the verdict comes back into the current session. A heads-up "current model can't read images" appears above the input box; when a direct image send is rejected, the message is rewritten as `/vision` and resent automatically — no manual redo; with no vision pool configured the command refuses and points to the settings.
 
-**8. Intent routing: the right model picks itself.** A new "Intent Routing" group on the settings page: a master switch (off by default — enabling requires a classifier and at least one candidate), the classifier's small-model route (provider + model + optional effort — TypeSafe Jev-style decision models and general chat models both work, with tolerant output parsing), a classifier type three-way choice (auto / decision / chat), an independent candidate list (each candidate: provider + model + optional effort + a one-line capability note), cache window seconds (default 300, aligned to the ~5-minute prompt caches vendors provide), a switch confidence threshold (default 80), a classification timeout (default 60000 ms), history message count (default 6) and character budget (default 2400), plus an optional fallback model. The model picker gains an "Auto" entry under the "Auto · Switchman" group (the client renders it localized — "Auto (intent routing)" in English); once selected, every user message is classified to pick the best-fitting candidate and the decision is locked for that turn: when confidence is lacking or the cache window is still open, the current model stays (its cache keeps being reused); switching happens only when confidence is high enough or the current model isn't among the candidates. The switch completes silently at the call layer — no "model switched" message is inserted into the session. A status chip sits above the input box (during auto routing it shows the current routed model and the last decision's confidence); candidates and thresholds can always be checked on the settings page.
+**8. Intent routing: the right model picks itself.** A new "Intent Routing" group on the settings page: a master switch (off by default — enabling requires a classifier and at least one candidate), the classifier's small-model route (provider + model + optional effort — TypeSafe Jev-style decision models and general chat models both work, with tolerant output parsing), a classifier type three-way choice (auto / decision / chat), an independent candidate list (each candidate: provider + model + optional effort + a one-line capability note), cache window seconds (default 300, aligned to the ~5-minute prompt caches vendors provide), a switch confidence threshold (default 80), a classification timeout (default 60000 ms), history message count (default 6) and character budget (default 2400), plus an optional fallback model route with its own independent reasoning-effort pin; leaving that pin unset uses the selected fallback model's default. The model picker gains an "Auto" entry under the "Auto · Switchman" group (the client renders it localized — "Auto (intent routing)" in English); once selected, every user message is classified to pick the best-fitting candidate and the decision is locked for that turn: when confidence is lacking or the cache window is still open, the current model stays (its cache keeps being reused); switching happens only when confidence is high enough or the current model isn't among the candidates. The switch completes silently at the call layer — no "model switched" message is inserted into the session. A status chip sits above the input box (during auto routing it shows the current routed model and the last decision's confidence); candidates and thresholds can always be checked on the settings page.
 
 Worth installing even with a single model — watermark control and tiered verification don't care how many models you have, and long single-model sessions benefit just the same.
 
@@ -76,7 +76,7 @@ Worth installing even with a single model — watermark control and tiered verif
    - **Capability ranking + enforcement mode** — the union of selected models across the six pools, ranked by capability, strongest first (the shot anchors glm-5.3 at S and glm-5.3-flash at A), reorderable and removable; enforcement mode advice / force (force = out-of-pool models rejected outright).
    - **Agent teams** — the two toggles for team mode and whitelist sync, both off by default; in the shot they're on, with a sync status line beneath the toggle.
    - **Context watermark** — the three thresholds (80000 / 120000 / 150000 in the shot), the single-read budget (3000), hard-tier behavior (throttle-pass / block), the auto-handover toggle, and subagent independent caps all live here. Bottom command row: `/ctx-pause` pause intervention · `/ctx-resume` resume · `/ctx-handover` write the handover doc and compact now (it steers the session to an idle boundary before compacting — the result can take a few minutes).
-   - **Intent Routing** — the master switch, the classifier's small-model route, the classifier type (auto / decision / chat), the independent candidate list (each with a one-line capability note), cache window / confidence threshold / classification timeout / history budget, and an optional fallback model. Once enabled, the model picker gains the localized "Auto (intent routing)" entry, and a status chip above the input box shows the routed model and confidence.
+   - **Intent Routing** — the master switch, the classifier's small-model route, the classifier type (auto / decision / chat), the independent candidate list (each with a one-line capability note), cache window / confidence threshold / classification timeout / history budget, and an optional fallback model with its own optional effort pin (empty = use that model's default). Once enabled, the model picker gains the localized "Auto (intent routing)" entry, and a status chip above the input box shows the routed model and confidence.
 
 4. **Verify** — the ⚡ "autonomous team" badge appears in the session header (with ◇ beside it showing the session's current model); or simply ask the model "what's the heading of the last section of your system prompt" — the answer should mention the dsh-switchman doctrine.
 
@@ -100,9 +100,9 @@ Everything below is the full set of defaults after a fresh install (authoritativ
 
 **Agent Teams**: `teamsMode` = off; `syncWhitelist` = off (the two toggles are independent of each other).
 
-**Intent routing** (unavailable by default; needs a classifier + at least one candidate + the master switch on): `intentEnabled` = off (while off, the Auto entry stays hidden and sessions already on Auto fall through the fallback chain); the classifier route is unset; the classifier type is `chat`; the candidate list is empty (the preset categories join routing only once given a model); cache window `300` s / switch confidence threshold `80` / classification timeout `60000` ms; history `6` messages / `2400` characters; `intentContextWindow` = `200000`.
+**Intent routing** (unavailable by default; needs a classifier + at least one candidate + the master switch on): `intentEnabled` = off (while off, the Auto entry stays hidden and sessions already on Auto fall through the fallback chain); the classifier route is unset; the classifier type is `chat`; the candidate list is empty (the preset categories join routing only once given a model); cache window `300` s / switch confidence threshold `80` / classification timeout `60000` ms; history `6` messages / `2400` characters; optional `intentFallbackRoute` is unset, and its own effort is model-default when later configured; `intentContextWindow` = `200000`.
 
-**Context trim**: `trimEnabled` = on; `trimMode` = `auto` (fully automatic); growth gate `22500` tokens + increment `25000` tokens; pressure `65%` / emergency `95%`; protected tail `10` messages; fold cadence cap `30` per hour; side model unset (inherits the session model); **ladder folding on** — T2 distills accumulated T1 summaries (8000-token mass, ≥3 blocks), T3 distills T2 (6000-token mass, ≥2 blocks); the engine never shows the model a water level, percentage, or progress number — details in the "Automatic context trim" section below and [docs/ladder-fold.md](./docs/ladder-fold.md).
+**Context trim**: `trimEnabled` = on; `trimMode` = `auto` (fully automatic); growth gate `22500` tokens + increment `25000` tokens; pressure `65%` / emergency `95%`; protected tail `10` messages; fold cadence cap `30` per hour; side model unset (follows the session provider/model, not the session call's effort); without an explicit effort pin, use the lowest enabled reasoning level from model metadata, choose `off` for toggle-only models, and omit effort when reasoning is unsupported or metadata is unavailable (model default). Ladder distillation shares that route and policy; a configured fold-fallback route has an independent effort pin with the same model-aware default. **Ladder folding on** — T2 distills accumulated T1 summaries (8000-token mass, ≥3 blocks), T3 distills T2 (6000-token mass, ≥2 blocks); the engine never shows the model a water level, percentage, or progress number — details in the "Automatic context trim" section below and [docs/ladder-fold.md](./docs/ladder-fold.md).
 
 **Out-of-the-box notes**: ① intent routing being unavailable out of the box is by design — three steps to switch it on (classifier, candidates, the master switch); ② Auto's effective window is 200000 out of the box — the guardrail guarantees 0.8×window ≥ force (150000), so the core compaction line (160000) always sits after the smooth-handover line (150000); ③ the most tangible out-of-the-box effect is the watermark trio: 80k nudges delegation / 95k tightens reading / 150k backs up and hands over automatically — no configuration needed.
 
@@ -129,8 +129,8 @@ All keys live in Settings → dsh-switchman; defaults from `host/config.js`:
 | `trimWindowTokens` | `0` | Effective-window cap for tier math: tiers are computed against min(model window, cap). `0` = follow `wmForceTokens`. |
 | `trimProtectedTail` | `10` | The last N messages are never folded. |
 | `trimMaxFoldsPerHour` | `30` | Side-model fold cadence cap per rolling hour (emergency folds are exempt). |
-| `trimSideModel` | unset | Route for the summary side model. Empty = inherit the session's current model. |
-| `trimFoldFallbackModel` | unset | Route the fold retries on when the summary side model fails; a pressure fold then degrades to a mechanical one. Empty = no fallback leg. Pick a route with headroom on cooldowns, risk control, and concurrency limits. |
+| `trimSideModel` | unset | Route for the summary side model. Empty follows the session provider/model only, not its effort. The independent effort pin defaults to the lowest enabled reasoning level from model metadata; toggle-only models use `off`, while unsupported reasoning or missing metadata omits the effort and leaves the model default. Ladder distillations share the route and policy. |
+| `trimFoldFallbackModel` | unset | Route used when a summary call fails; a pressure fold then degrades to mechanical if the retry also fails. Its effort pin is independent; when unset, use the same model-aware recommendation as the summary route. Empty = no fallback leg. |
 | `trimStateDir` | unset | Fold-state directory override. Empty = `<dshHome>/.dsh-switchman/state/trim/`. |
 | `surfaceFold` | `true` | Ship committed folds onto the session surface (shadow-price + `surfaceOp` replace event pair). OFF keeps the splice-only view. |
 

package/README.pt.md

@@ -33,7 +33,7 @@ O cabeçalho da sessão dá um retorno imediato: badge ⚡ “Equipe autônoma
 
 **7. `/vision`: até modelo somente texto lida com imagens.** Quando o modelo principal não sabe ler imagens, o DSH recusa na entrada as mensagens que as trazem. Você anexa a imagem e digita `/vision onde está o erro nesta imagem`: a imagem é entregue à leitura de um modelo do pool multimodal, e a conclusão volta para a sessão atual. Acima da caixa de entrada aparece antes o aviso “o modelo atual não suporta leitura de imagens”; se um envio direto da imagem for recusado, a mensagem é reescrita uma vez para `/vision` e reenviada sozinha, sem precisar refazer à mão; sem pool multimodal configurado, o comando recusa e indica como configurar.
 
-**8. Roteamento por intenção: o modelo certo se escolhe sozinho.** A página de configurações ganha um grupo “Roteamento por intenção”: uma chave mestra (desligada por padrão; para ligar são precisos um classificador e pelo menos um candidato), a rota do modelo pequeno do classificador (provider + model + effort opcional — servem tanto modelos de decisão tipo TypeSafe Jev quanto modelos de conversa genéricos, e a saída é interpretada com tolerância), uma escolha do tipo de classificador em três opções (auto / decision / chat), uma lista de candidatos independente (cada candidato: provider + model + effort opcional + uma nota de capacidade de uma linha), a janela de cache em segundos (300 por padrão, alinhada com os caches de prompt dos provedores, cerca de 5 minutos), o limiar de confiança para a troca (80 por padrão), o timeout de classificação (60000 ms por padrão), a contagem de mensagens do histórico (6 por padrão) e o orçamento de caracteres (2400 por padrão), além de um modelo de fallback opcional. No seletor de modelos aparece uma entrada “Auto” no grupo “Auto · Switchman” (o cliente a renderiza localizada — “Automático (roteamento por intenção)” em português); escolhida, cada mensagem do usuário passa pelo classificador para eleger o melhor candidato, e a decisão fica travada por aquele turno: se a confiança não alcança ou a janela de cache ainda está aberta, o modelo atual permanece (reaproveitando o cache); só troca quando a confiança é suficiente ou o modelo atual não está entre os candidatos. A troca acontece em silêncio na camada de chamada — nenhuma mensagem de “modelo trocado” entra na sessão. Acima da caixa de entrada há um chip de status (no roteamento automático, ele mostra o modelo roteado atual e a confiança da última decisão); candidatos e limiares ficam sempre visíveis na página de configurações.
+**8. Roteamento por intenção: o modelo certo se escolhe sozinho.** A página de configurações ganha um grupo “Roteamento por intenção”: uma chave mestra (desligada por padrão; para ligar são precisos um classificador e pelo menos um candidato), a rota do modelo pequeno do classificador (provider + model + effort opcional — servem tanto modelos de decisão tipo TypeSafe Jev quanto modelos de conversa genéricos, e a saída é interpretada com tolerância), uma escolha do tipo de classificador em três opções (auto / decision / chat), uma lista de candidatos independente (cada candidato: provider + model + effort opcional + uma nota de capacidade de uma linha), a janela de cache em segundos (300 por padrão, alinhada com os caches de prompt dos provedores, cerca de 5 minutos), o limiar de confiança para a troca (80 por padrão), o timeout de classificação (60000 ms por padrão), a contagem de mensagens do histórico (6 por padrão) e o orçamento de caracteres (2400 por padrão), além de um modelo de fallback opcional (com um pin de effort opcional e independente; se não for fixado, usa-se o effort padrão do modelo de fallback selecionado, separado do effort do classificador). No seletor de modelos aparece uma entrada “Auto” no grupo “Auto · Switchman” (o cliente a renderiza localizada — “Automático (roteamento por intenção)” em português); escolhida, cada mensagem do usuário passa pelo classificador para eleger o melhor candidato, e a decisão fica travada por aquele turno: se a confiança não alcança ou a janela de cache ainda está aberta, o modelo atual permanece (reaproveitando o cache); só troca quando a confiança é suficiente ou o modelo atual não está entre os candidatos. A troca acontece em silêncio na camada de chamada — nenhuma mensagem de “modelo trocado” entra na sessão. Acima da caixa de entrada há um chip de status (no roteamento automático, ele mostra o modelo roteado atual e a confiança da última decisão); candidatos e limiares ficam sempre visíveis na página de configurações.
 
 Só um modelo? Ainda vale a pena instalar — o controle do nível de água e a verificação em níveis não ligam para quantos modelos você tem, e sessões longas de modelo único se beneficiam do mesmo jeito.
 
@@ -129,8 +129,8 @@ Todas as chaves ficam em Configurações → dsh-switchman; os padrões vêm de
 | `trimWindowTokens` | `0` | Limite de janela efetivo para o cálculo dos níveis: calculado sobre min(janela do modelo, limite). `0` = segue `wmForceTokens`. |
 | `trimProtectedTail` | `10` | As últimas N mensagens nunca são dobradas. |
 | `trimMaxFoldsPerHour` | `30` | Teto de cadência de folds por hora rolante para o modelo secundário (os de emergência ficam fora). |
-| `trimSideModel` | não definida | Rota do modelo secundário que escreve os resumos. Vazia = herdar o modelo atual da sessão. |
-| `trimFoldFallbackModel` | não definida | Rota de nova tentativa quando o modelo secundário de resumos falha; um fold de pressão degrada então para mecânico. Vazia = sem fallback. Escolha uma rota com folga em cooldowns, controle de risco e concorrência. |
+| `trimSideModel` | não definida | Rota do modelo secundário que escreve os resumos. Vazia = seguir o provider/model da sessão, sem herdar o effort da chamada; a ladder distillation também usa esta rota. O effort do resumo aceita um pin manual independente; se não fixado, os metadados do modelo recomendam o nível de reasoning habilitado mais baixo; se o modelo só tiver interruptor sim/não, escolhe-se off. Se não houver suporte a reasoning ou os metadados não estiverem disponíveis, nenhum effort é enviado e prevalece o comportamento padrão do modelo/adaptador. |
+| `trimFoldFallbackModel` | não definida | Rota de nova tentativa quando o modelo secundário de resumos falha; um fold de pressão degrada então para mecânico. Vazia = sem fallback. O modelo de fallback do fold escolhido manualmente tem um pin de effort independente; sem pin, usa a mesma recomendação por metadados do modelo de resumo e, sem metadados, o padrão do modelo. Escolha uma rota com folga em cooldowns, controle de risco e concorrência. |
 | `trimStateDir` | não definido | Sobrepõe o diretório do estado de folds. Vazio = `<dshHome>/.dsh-switchman/state/trim/`. |
 | `surfaceFold` | `true` | Envia os folds confirmados para a superfície da sessão (par de eventos: medição shadow-price + replace com `surfaceOp`). OFF mantém a view apenas com splices. |
 

package/README.ru.md

@@ -33,7 +33,7 @@ dsh-switchman — плагин для [DeepSeek Harness](https://github.com/deep
 
 **7. `/vision`: картинки по зубам даже чисто текстовой модели.** Когда главная модель не читает изображения, DSH прямо на входе отклоняет сообщения с картинками. Прикрепите картинку и введите `/vision что не так на этой картинке` — изображение будет отдано на чтение модели из мультимодального пула, а вывод вернётся в текущую сессию. Над полем ввода заранее подсказывают: «текущая модель не умеет читать изображения»; если прямая отправка картинки отклонена, она один раз автоматически переоформляется в `/vision` и уходит повторно — вручную ничего переписывать не нужно; если мультимодальный пул не настроен, команда откажется и подскажет, что настроить.
 
-**8. Маршрутизация по намерению: нужная модель выбирается сама.** На странице настроек появляется раздел «Маршрутизация по намерению»: главный переключатель (по умолчанию выключен; для включения нужны классификатор и хотя бы один кандидат), маршрут маленькой модели-классификатора (provider + model + необязательный effort — подходят и решающие модели типа TypeSafe Jev, и обычные разговорные, вывод парсится нестрого), выбор типа классификатора из трёх (auto / decision / chat), независимый список моделей-кандидатов (для каждого: provider + model + необязательный effort + одна строка описания способностей), окно кэша в секундах (по умолчанию 300, подогнано под промпт-кэши поставщиков ~5 минут), порог уверенности для переключения (по умолчанию 80), тайм-аут классификации (по умолчанию 60000 мс), количество сообщений истории (по умолчанию 6) и символьный бюджет (по умолчанию 2400), а также необязательная запасная модель. В селекторе моделей под группой «Auto · Switchman» появляется вход «Auto» (клиент отрисовывает его локализованно — «Авто (маршрутизация по намерению)» на русском); после выбора классификатор оценивает каждое сообщение пользователя, и решение фиксируется на этот ход: если уверенности не хватает или окно кэша ещё открыто, текущая модель остаётся (её кэш переиспользуется); переключение происходит, только когда уверенность высока или текущей модели нет среди кандидатов. Смена проходит бесшумно на уровне вызова — в сессию не вставляется сообщение «модель переключена». Над полем ввода — чип состояния (при автороутинге он показывает текущую модель маршрута и уверенность последнего решения); кандидаты и пороги всегда можно посмотреть на странице настроек.
+**8. Маршрутизация по намерению: нужная модель выбирается сама.** На странице настроек появляется раздел «Маршрутизация по намерению»: главный переключатель (по умолчанию выключен; для включения нужны классификатор и хотя бы один кандидат), маршрут маленькой модели-классификатора (provider + model + необязательный effort — подходят и решающие модели типа TypeSafe Jev, и обычные разговорные, вывод парсится нестрого), выбор типа классификатора из трёх (auto / decision / chat), независимый список моделей-кандидатов (для каждого: provider + model + необязательный effort + одна строка описания способностей), окно кэша в секундах (по умолчанию 300, подогнано под промпт-кэши поставщиков ~5 минут), порог уверенности для переключения (по умолчанию 80), тайм-аут классификации (по умолчанию 60000 мс), количество сообщений истории (по умолчанию 6) и символьный бюджет (по умолчанию 2400), а также необязательная запасная модель (с отдельной необязательной фиксацией effort; если он не задан, используется effort по умолчанию выбранной запасной модели, независимо от effort классификатора). В селекторе моделей под группой «Auto · Switchman» появляется вход «Auto» (клиент отрисовывает его локализованно — «Авто (маршрутизация по намерению)» на русском); после выбора классификатор оценивает каждое сообщение пользователя, и решение фиксируется на этот ход: если уверенности не хватает или окно кэша ещё открыто, текущая модель остаётся (её кэш переиспользуется); переключение происходит, только когда уверенность высока или текущей модели нет среди кандидатов. Смена проходит бесшумно на уровне вызова — в сессию не вставляется сообщение «модель переключена». Над полем ввода — чип состояния (при автороутинге он показывает текущую модель маршрута и уверенность последнего решения); кандидаты и пороги всегда можно посмотреть на странице настроек.
 
 Всего одна модель? Всё равно стоит поставить — контроль уровня воды и многоуровневая проверка от числа моделей не зависят, и длинная сессия на одной модели выигрывает от них ничуть не меньше.
 
@@ -129,8 +129,8 @@ bash <install-dir>/skills/db-query/scripts/setup.sh
 | `trimWindowTokens` | `0` | Эффективный лимит окна для расчёта уровней: считается от min(окно модели, лимит). `0` = следует за `wmForceTokens`. |
 | `trimProtectedTail` | `10` | Последние N сообщений никогда не сворачиваются. |
 | `trimMaxFoldsPerHour` | `30` | Потолок частоты fold-ов боковой модели за скользящий час (аварийные не в счёт). |
-| `trimSideModel` | не задан | Маршрут боковой модели, пишущей резюме. Пусто = унаследовать текущую модель сессии. |
-| `trimFoldFallbackModel` | не задан | Маршрут повторной попытки, если боковая модель резюме не сработала; pressure-fold затем деградирует до механического. Пусто = без резерва. Выбирайте маршрут с запасом по кулдаунам, риск-контролю и параллелизму. |
+| `trimSideModel` | не задан | Маршрут боковой модели, пишущей резюме. Пусто = следовать provider/model сессии, не наследуя effort вызова; этот маршрут также используют ladder distillation. Effort резюме можно закрепить отдельно; без фиксации метаданные модели определяют минимальный доступный уровень reasoning, а для моделей только с переключателем вкл./выкл. выбирается off. Если reasoning не поддерживается или метаданные недоступны, effort не отправляется и сохраняется поведение модели/адаптера по умолчанию. |
+| `trimFoldFallbackModel` | не задан | Маршрут повторной попытки, если боковая модель резюме не сработала; pressure-fold затем деградирует до механического. Пусто = без резерва. У вручную выбранной запасной модели fold-а независимый effort; если он не задан, применяется та же рекомендация по метаданным, что для модели резюме, а при отсутствии метаданных — умолчание самой модели. Выбирайте маршрут с запасом по кулдаунам, риск-контролю и параллелизму. |
 | `trimStateDir` | не задан | Переопределяет каталог состояния fold-ов. Пусто = `<dshHome>/.dsh-switchman/state/trim/`. |
 | `surfaceFold` | `true` | Доставляет зафиксированные fold-ы на поверхность сессии (пара событий: учёт shadow-price + replace с `surfaceOp`). OFF оставляет view только со сплайсами. |
 

package/README.zh-TW.md

@@ -33,7 +33,7 @@ dsh-switchman 是一個 [DeepSeek Harness](https://github.com/deepseek-ai/deepse
 
 **7. `/vision`：純文字模型也能處理圖。** 主力模型讀不了圖時，DSH 會在入口直接拒掉帶圖訊息。貼上圖、輸入 `/vision 這張圖錯在哪`，圖片會被交給多模態池的模型去讀，結論回到目前對話。輸入框上方會提前提示「目前模型不支援讀圖」；直接傳圖被拒時，自動改寫成 `/vision` 重送一次，不用手動重來；多模態池沒設時指令會拒絕並給出設定指引。
 
-**8. 意圖識別自動選模型：訊息進來，模型自動落位。** 設定頁新增【意圖識別】分組：主開關（預設關閉，開啟需設定分類器並至少一個候選）、分類器小模型路由（provider + model + 可選 effort，TypeSafe Jev 類決策模型與通用對話模型都支援，輸出寬容解析）、分類器類型三選（auto / decision / chat）、獨立候選模型清單（每個候選 provider + model + 可選 effort + 一句能力描述）、快取視窗秒數（預設 300，對齊廠商 prompt cache 約 5 分鐘）、切換信心閾值（預設 80）、分類逾時（預設 60000ms）、歷史訊息則數（預設 6）與字元預算（預設 2400）、可選備援模型。模型選擇器出現「Auto · Switchman」分組下的「Auto」入口（用戶端渲染為在地化的「自動（意圖識別）」）；選中後每條使用者訊息先由分類器判定最合適的候選，同一輪鎖定決策：信心不足或仍在快取視窗內時優先沿用目前模型（快取續用），信心足夠高或目前模型不在候選裡才切換；切換在呼叫層靜默完成，不往對話裡插「模型已切換」。輸入框上方有狀態 chip（自動路由時顯示目前路由模型與上次決策信心），候選與閾值隨時回設定頁查看。
+**8. 意圖識別自動選模型：訊息進來，模型自動落位。** 設定頁新增【意圖識別】分組：主開關（預設關閉，開啟需設定分類器並至少一個候選）、分類器小模型路由（provider + model + 可選 effort，TypeSafe Jev 類決策模型與通用對話模型都支援，輸出寬容解析）、分類器類型三選（auto / decision / chat）、獨立候選模型清單（每個候選 provider + model + 可選 effort + 一句能力描述）、快取視窗秒數（預設 300，對齊廠商 prompt cache 約 5 分鐘）、切換信心閾值（預設 80）、分類逾時（預設 60000ms）、歷史訊息則數（預設 6）與字元預算（預設 2400）、可選備援模型（可獨立固定可選 effort；未固定時使用所選備援模型的預設 effort，與分類器 effort 分開）。模型選擇器出現「Auto · Switchman」分組下的「Auto」入口（用戶端渲染為在地化的「自動（意圖識別）」）；選中後每條使用者訊息先由分類器判定最合適的候選，同一輪鎖定決策：信心不足或仍在快取視窗內時優先沿用目前模型（快取續用），信心足夠高或目前模型不在候選裡才切換；切換在呼叫層靜默完成，不往對話裡插「模型已切換」。輸入框上方有狀態 chip（自動路由時顯示目前路由模型與上次決策信心），候選與閾值隨時回設定頁查看。
 
 只有一個模型也值得裝——水位控制和分級驗證與模型數量無關，單模型長對話同樣受益。
 
@@ -129,8 +129,8 @@ bash <安裝目錄>/skills/db-query/scripts/setup.sh
 | `trimWindowTokens` | `0` | 視窗上限：壓力與緊急檔按 min(模型視窗, 上限) 計算。`0` = 跟隨 `wmForceTokens`。 |
 | `trimProtectedTail` | `10` | 最後 N 則訊息永不折疊。 |
 | `trimMaxFoldsPerHour` | `30` | 每滾動小時 side model 折疊的節奏上限（緊急級豁免）。 |
-| `trimSideModel` | 未設定 | 寫摘要的 side model 路由。留空 = 繼承對話目前模型。 |
-| `trimFoldFallbackModel` | 未設定 | 摘要 side model 失敗時摺疊改用的重試路由；壓力檔仍失敗則退回機械摺疊。留空 = 無備援。盡量選擇冷卻、風控與並行餘量充足的路由。 |
+| `trimSideModel` | 未設定 | 寫摘要的 side model 路由。留空 = 跟隨對話目前 provider/model，不繼承呼叫的 effort；ladder distillation 也使用此路由。摘要 effort 可獨立手動固定；未固定時依模型 metadata 建議最低啟用的 reasoning 層級，僅有開/關選項時選 off。不支援 reasoning 或 metadata 不可用時不傳 effort，沿用模型/配接器預設行為。 |
+| `trimFoldFallbackModel` | 未設定 | 摘要 side model 失敗時摺疊改用的重試路由；壓力檔仍失敗則退回機械摺疊。留空 = 無備援。手動選擇的折疊備援模型可獨立固定 effort；未設定時依與摘要模型相同的模型 metadata 規則建議，metadata 缺失則使用該模型預設值。盡量選擇冷卻、風控與並行餘量充足的路由。 |
 | `trimStateDir` | 未設定 | 折疊狀態目錄覆蓋。留空 = `<dshHome>/.dsh-switchman/state/trim/`。 |
 | `surfaceFold` | `true` | 把已提交的 fold 送上對話表面（shadow-price 計量事件 + `surfaceOp` replace 事件對）。關閉則維持僅拼接的 view。 |
 

package/README.zh.md

@@ -33,7 +33,7 @@ dsh-switchman 是一个 [DeepSeek Harness](https://github.com/deepseek-ai/deepse
 
 **7. `/vision`：纯文本模型也能处理图。** 主力模型读不了图时，DSH 会在入口直接拒掉带图消息。贴上图、输入 `/vision 这张图错在哪`，图片会被交给多模态池的模型去读，结论回到当前会话。输入框上方会提前提示「当前模型不支持读图」；直接发图被拒时，自动改写成 `/vision` 重发一次，不用手动重来；多模态池没配时命令会拒绝并给出配置指引。
 
-**8. 意图识别自动选模型：消息进来，模型自动落位。** 设置页新增【意图识别】分组：主开关（默认关闭，开启需配置分类器并至少一个候选）、分类器小模型路由（provider + model + 可选 effort，TypeSafe Jev 类决策模型与通用对话模型都支持，输出宽容解析）、分类器类型三选（auto / decision / chat）、独立候选模型列表（每个候选 provider + model + 可选 effort + 一句能力描述）、缓存窗口秒数（默认 300，对齐厂商 prompt cache 约 5 分钟）、切换置信度阈值（默认 80）、分类超时（默认 60000ms）、历史消息条数（默认 6）与字符预算（默认 2400）、可选兜底模型。模型选择器出现「Auto · Switchman」分组下的「Auto」入口（客户端渲染为本地化的「自动（意图识别）」）；选中后每条用户消息先由分类器判定最合适的候选，同一轮锁定决策：置信度不足或仍在缓存窗口内时优先沿用当前模型（缓存续用），置信度足够高或当前模型不在候选里才切换；切换在调用层静默完成，不往会话里插「模型已切换」。输入框上方有状态 chip（自动路由时显示当前路由模型与上次决策置信度），候选与阈值随时回设置页查看。
+**8. 意图识别自动选模型：消息进来，模型自动落位。** 设置页新增【意图识别】分组：主开关（默认关闭，开启需配置分类器并至少一个候选）、分类器小模型路由（provider + model + 可选 effort，TypeSafe Jev 类决策模型与通用对话模型都支持，输出宽容解析）、分类器类型三选（auto / decision / chat）、独立候选模型列表（每个候选 provider + model + 可选 effort + 一句能力描述）、缓存窗口秒数（默认 300，对齐厂商 prompt cache 约 5 分钟）、切换置信度阈值（默认 80）、分类超时（默认 60000ms）、历史消息条数（默认 6）与字符预算（默认 2400）、可选兜底模型（可单独固定可选 effort；未固定时使用所选兜底模型的默认 effort，与分类器 effort 独立）。模型选择器出现「Auto · Switchman」分组下的「Auto」入口（客户端渲染为本地化的「自动（意图识别）」）；选中后每条用户消息先由分类器判定最合适的候选，同一轮锁定决策：置信度不足或仍在缓存窗口内时优先沿用当前模型（缓存续用），置信度足够高或当前模型不在候选里才切换；切换在调用层静默完成，不往会话里插「模型已切换」。输入框上方有状态 chip（自动路由时显示当前路由模型与上次决策置信度），候选与阈值随时回设置页查看。
 
 只有一个模型也值得装——水位控制和分级验证与模型数量无关，单模型长会话同样受益。
 
@@ -129,8 +129,8 @@ bash <安装目录>/skills/db-query/scripts/setup.sh
 | `trimWindowTokens` | `0` | 窗口上限：压力与紧急档按 min(模型窗口, 上限) 计算。`0` = 跟随 `wmForceTokens`。 |
 | `trimProtectedTail` | `10` | 最后 N 条消息永不折叠。 |
 | `trimMaxFoldsPerHour` | `30` | 每滚动小时 side model 折叠的节奏上限（紧急档豁免）。 |
-| `trimSideModel` | 未设置 | 写摘要的 side model 路由。留空 = 继承会话当前模型。 |
-| `trimFoldFallbackModel` | 未设置 | 摘要 side model 失败时折叠改用的重试路由；压力档仍失败则退回机械折叠。留空 = 无兜底。尽量选择冷却、风控与并发余量充足的路由。 |
+| `trimSideModel` | 未设置 | 写摘要的 side model 路由。留空 = 跟随会话当前 provider/model，不继承调用的 effort；ladder distillation 也使用此路由。摘要 effort 可单独手动固定；未固定时按模型元数据推荐最低启用的 reasoning 档，只有开/关选项时选 off。不支持 reasoning 或元数据不可用时不发送 effort，保留模型/适配器默认行为。 |
+| `trimFoldFallbackModel` | 未设置 | 摘要 side model 失败时折叠改用的重试路由；压力档仍失败则退回机械折叠。留空 = 无兜底。手动选择的折叠兜底模型有独立 effort 固定值；未设置时按摘要模型相同的模型元数据规则推荐，元数据缺失则使用该模型默认值。尽量选择冷却、风控与并发余量充足的路由。 |
 | `trimStateDir` | 未设置 | 折叠状态目录覆盖。留空 = `<dshHome>/.dsh-switchman/state/trim/`。 |
 | `surfaceFold` | `true` | 把已提交的 fold 送上会话表面（shadow-price 计量事件 + `surfaceOp` replace 事件对）。关闭则保持仅拼接的 view。 |
 

package/client.js

@@ -373,14 +373,13 @@ window.__ModuleLoader__.load({
 		const routeKey = (route) => `${route.provider}\0${route.model}`;
 
 		/** One well-formed {provider, model[, effort]} route, or null. */
-		function sanitizeRoute(route) {
+		function sanitizeRoute(route, allowEffort = false) {
 			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;
-			// 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).
+			// Preserve effort only for settings routes that expose a dedicated pin.
 			const out = { provider: route.provider, model: route.model };
-			if (typeof route.effort === 'string' && route.effort !== '') out.effort = route.effort;
+			if (allowEffort && typeof route.effort === 'string' && route.effort !== '') out.effort = route.effort;
 			return out;
 		}
 
@@ -532,10 +531,10 @@ window.__ModuleLoader__.load({
 				trimLadderEnabled: bool('trimLadderEnabled', true),
 				surfaceFold: bool('surfaceFold', true),
 				trimSideModel:
-					sanitizeRoute(value?.trimSideModel) ??
+					sanitizeRoute(value?.trimSideModel, true) ??
 					({ provider: '', model: '' }),
 					trimFoldFallbackModel:
-						sanitizeRoute(value?.trimFoldFallbackModel) ??
+					sanitizeRoute(value?.trimFoldFallbackModel, true) ??
 						({ provider: '', model: '' }),
 				trimStateDir: string('trimStateDir'),
 				...Object.fromEntries(
@@ -565,7 +564,7 @@ window.__ModuleLoader__.load({
 					INTENT_NUMBER_FIELDS.map((spec) => [spec.field, number(spec)]),
 				),
 				intentFallbackRoute:
-					sanitizeRoute(value?.intentFallbackRoute) ??
+					sanitizeRoute(value?.intentFallbackRoute, true) ??
 					({ provider: '', model: '' }),
 			};
 		}
@@ -619,8 +618,8 @@ window.__ModuleLoader__.load({
 				trimEnabled: values.trimEnabled,
 				trimLadderEnabled: values.trimLadderEnabled,
 				surfaceFold: values.surfaceFold,
-				trimSideModel: routeKey(values.trimSideModel),
-				trimFoldFallbackModel: routeKey(values.trimFoldFallbackModel),
+				trimSideModel: `${routeKey(values.trimSideModel)}\0${values.trimSideModel.effort ?? ''}`,
+				trimFoldFallbackModel: `${routeKey(values.trimFoldFallbackModel)}\0${values.trimFoldFallbackModel.effort ?? ''}`,
 				trimStateDir: values.trimStateDir,
 				...Object.fromEntries(
 					TRIM_NUMBER_FIELDS.map(({ field }) => [field, values[field]]),
@@ -645,7 +644,7 @@ window.__ModuleLoader__.load({
 				...Object.fromEntries(
 					INTENT_NUMBER_FIELDS.map(({ field }) => [field, values[field]]),
 				),
-				intentFallbackRoute: routeKey(values.intentFallbackRoute),
+				intentFallbackRoute: `${routeKey(values.intentFallbackRoute)}\0${values.intentFallbackRoute.effort ?? ''}`,
 			});
 		}
 
@@ -923,11 +922,11 @@ window.__ModuleLoader__.load({
 				surfaceFoldLabel: '把折叠写入会话表面',
 				surfaceFoldHelp: '追加宿主风格的替换事件，让折叠在冻结派发下也能到达线上。建议保持开启。',
 				trimSideModelLabel: '摘要模型',
-				trimSideModelHelp: '折叠摘要使用的模型路由；默认「跟随会话模型」。阶梯蒸馏同样使用该路由。',
+				trimSideModelHelp: '折叠摘要使用的模型路由；默认「跟随会话模型」。阶梯蒸馏同样使用该路由。未手动指定思考等级时，按模型元数据自动选择最低开启档；只有开／关思考时取关闭。模型不支持思考或元数据不可用时，不发送思考等级并沿用模型默认。',
 				trimFollowSession: '跟随会话模型',
-				trimEffortPinLow: '默认（pin low）',
+				trimEffortRecommended: '自动（按模型推荐规则）',
 				trimFoldFallbackModelLabel: '折叠异常兜底模型',
-				trimFoldFallbackModelHelp: '摘要模型调用失败时改用该模型重试；仍失败则压力折叠退回机械折叠。尽量选择没有冷却、风控或并发限制的模型，避免与主会话共用同一账号。留空 = 无兜底。',
+				trimFoldFallbackModelHelp: '摘要模型调用失败时改用该模型重试；仍失败则压力折叠退回机械折叠。思考等级可单独指定；留空时按该模型的推荐规则自动选择。尽量选择没有冷却、风控或并发限制的模型，避免与主会话共用同一账号。留空 = 无兜底。',
 				trimFallbackUnset: '未设置（失败时直接机械折叠）',
 				trimStateDirLabel: '账本目录',
 				trimStateDirHelp: '留空 = 默认的裁剪状态目录。',
@@ -1022,7 +1021,7 @@ window.__ModuleLoader__.load({
 				intentHistoryMaxCharsHelp: '对话摘录的总字符上限（200–20000）。',
 				intentFallbackRouteLabel: '兜底模型',
 				intentFallbackRouteHelp:
-					'分类失败时依次：上一轮实际路由 → 兜底模型 → 候选第一位；留空用候选第一位。',
+					'分类失败时依次：上一轮实际路由 → 兜底模型 → 候选第一位；留空用候选第一位。可选固定思考等级；不指定时使用兜底模型默认等级。',
 				intentRouteUnset: '未设置',
 				intentEffortFollow: '跟随模型默认',
 				intentDockAuto: '自动',
@@ -1194,13 +1193,12 @@ window.__ModuleLoader__.load({
 				surfaceFoldHelp:
 					'Append host-style replace events so folds reach the wire even on frozen dispatches. Leave on.',
 				trimSideModelLabel: 'Summarizer model',
-				trimSideModelHelp:
-					'Route for fold summaries; defaults to following the session model. Also used by ladder distillations.',
+				trimSideModelHelp: 'Route for fold summaries; defaults to following the session model. Also used by ladder distillations. Without a pinned effort, choose the lowest enabled level from model metadata; for a thinking on/off-only model, choose off. If reasoning is unsupported or metadata is unavailable, omit the effort and keep the model default.',
 				trimFollowSession: 'Follow session model',
-				trimEffortPinLow: 'Default (pin low)',
+				trimEffortRecommended: 'Automatic (model recommendation)',
 				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.',
+					'When the summary route fails, the fold retries on this model before degrading a pressure fold to a mechanical one. Its effort can be pinned separately; if unset, the model recommendation is used. 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.',
 				trimFallbackUnset: 'Unset (failed folds go straight to mechanical)',
 				trimStateDirLabel: 'Ledger directory',
 				trimStateDirHelp: 'Empty = the default per-host trim state directory.',
@@ -1305,7 +1303,7 @@ window.__ModuleLoader__.load({
 					'Total character cap of the conversation excerpt (200–20000).',
 				intentFallbackRouteLabel: 'Fallback model',
 				intentFallbackRouteHelp:
-					'On classification failure: last routed model → fallback → first candidate; empty = first candidate.',
+					'On classification failure: last routed model → fallback → first candidate; empty = first candidate. Optionally pin a thinking effort; when unset, the fallback model default is used.',
 				intentRouteUnset: 'Not set',
 				intentEffortFollow: 'model default',
 				intentDockAuto: 'Auto',
@@ -1470,11 +1468,11 @@ window.__ModuleLoader__.load({
 				surfaceFoldLabel: '把摺疊寫入會話表面',
 				surfaceFoldHelp: '追加宿主風格的替換事件，讓摺疊在凍結派發下也能到達線上。建議保持開啟。',
 				trimSideModelLabel: '摘要模型',
-				trimSideModelHelp: '摺疊摘要使用的模型路由；預設「跟隨對話模型」。階梯蒸餾同樣使用該路由。',
+				trimSideModelHelp: '摺疊摘要使用的模型路由；預設「跟隨對話模型」。階梯蒸餾同樣使用該路由。未手動指定思考等級時，依模型中繼資料自動選擇最低啟用等級；模型僅提供思考開／關切換時取關閉。不支援思考或中繼資料不可用時，不傳思考等級並沿用模型預設。',
 				trimFollowSession: '跟隨對話模型',
-				trimEffortPinLow: '預設（pin low）',
+				trimEffortRecommended: '自動（依模型推薦規則）',
 				trimFoldFallbackModelLabel: '摺疊異常備援模型',
-				trimFoldFallbackModelHelp: '摘要模型呼叫失敗時改用該模型重試；仍失敗則壓力摺疊退回機械摺疊。盡量選擇沒有冷卻、風控或並行限制的模型，避免與主對話共用同一帳號。留空 = 無備援。',
+				trimFoldFallbackModelHelp: '摘要模型呼叫失敗時改用該模型重試；仍失敗則壓力摺疊退回機械摺疊。思考等級可單獨指定；留空時依該模型推薦規則自動選擇。盡量選擇沒有冷卻、風控或並行限制的模型，避免與主對話共用同一帳號。留空 = 無備援。',
 				trimFallbackUnset: '未設定（失敗時直接機械摺疊）',
 				trimStateDirLabel: '帳本目錄',
 				trimStateDirHelp: '留空 = 預設的裁剪狀態目錄。',
@@ -1566,7 +1564,7 @@ window.__ModuleLoader__.load({
 				intentHistoryMaxCharsHelp: '對話摘錄的總字元上限（200–20000）。',
 				intentFallbackRouteLabel: '備援模型',
 				intentFallbackRouteHelp:
-					'分類失敗時依次：上一輪實際路由 → 備援模型 → 候選第一位；留空用候選第一位。',
+					'分類失敗時依次：上一輪實際路由 → 備援模型 → 候選第一位；留空用候選第一位。可選固定思考等級；未指定時使用備援模型預設等級。',
 				intentRouteUnset: '未設定',
 				intentEffortFollow: '跟隨模型預設',
 				intentDockAuto: '自動',
@@ -1796,10 +1794,16 @@ window.__ModuleLoader__.load({
 					'会話抜粋の合計文字上限（200–20000）。',
 				intentFallbackRouteLabel: 'フォールバックモデル',
 				intentFallbackRouteHelp:
-					'分類失敗時：前回ルート → フォールバック → 候補の先頭。空欄は候補の先頭。',
+					'分類失敗時：前回ルート → フォールバック → 候補の先頭。空欄は候補の先頭。思考レベルを固定できます。未指定ならモデル既定を使用します。',
 				intentRouteUnset: '未設定',
 				intentEffortFollow: 'モデルのデフォルト',
-				trimEffortPinLow: 'デフォルト（pin low）',
+				trimEffortRecommended: '自動（モデル推奨）',
+				trimSideModelLabel: '要約モデル',
+				trimSideModelHelp: '要約に使うモデルルート。既定ではセッションモデルに従いますが、その呼び出しの思考レベルは引き継ぎません。段階的蒸留も同じルートを使います。手動指定がなければ、モデル情報から有効な思考レベルの最低段階を選びます。思考のオン／オフだけのモデルは off を選択します。非対応またはモデル情報がない場合はレベルを送らず、モデルの既定値を使います。',
+				trimFollowSession: 'セッションモデルに従う',
+				trimFoldFallbackModelLabel: '折りたたみ時のフォールバックモデル',
+				trimFoldFallbackModelHelp: '要約モデルの呼び出しに失敗した場合、このモデルで再試行します。これも失敗すると、圧力折りたたみは機械的な折りたたみに切り替わります。思考レベルは個別に指定でき、未指定ならこのモデルの推奨設定を使います。冷却・リスク管理・同時実行の制限に余裕のあるモデルを選び、メインセッションと同じアカウントの共有は避けてください。空欄 = フォールバックなし。',
+				trimFallbackUnset: '未設定（失敗時は機械的な折りたたみに直接移行）',
 				intentDockAuto: '自動',
 				intentDockUnrouted: '未ルーティング',
 				intentDockUsing: '使用中',
@@ -1939,7 +1943,13 @@ window.__ModuleLoader__.load({
 					'서브에이전트 자체 모델 창에 맞춰 3단계 축소: force = min(정적 기준, 창×비율). soft/hard도 같은 비율로 축소. 완화 없이 강화만.',
 				wmSubagentFollowForce: 'force 단계 따르기(0)',
 				wmCommands: '명령: /ctx-pause 수위 개입 일시 중지 · /ctx-resume 재개 · /ctx-handover 지금 핸드오버 문서를 작성하고 압축.',
-				trimEffortPinLow: '기본 (low 고정)',
+				trimEffortRecommended: '자동 (모델 권장)',
+				trimSideModelLabel: '요약 모델',
+				trimSideModelHelp: '요약에 사용할 모델 경로입니다. 기본값은 세션 모델을 따르지만 해당 호출의 추론 수준은 상속하지 않습니다. 단계별 증류도 같은 경로를 사용합니다. 수동 지정이 없으면 모델 메타데이터에서 활성화된 가장 낮은 추론 단계를 선택합니다. 추론 켜기/끄기만 지원하는 모델은 off를 선택합니다. 추론을 지원하지 않거나 메타데이터가 없으면 수준을 보내지 않고 모델 기본값을 사용합니다.',
+				trimFollowSession: '세션 모델 따르기',
+				trimFoldFallbackModelLabel: '접기 대체 모델',
+				trimFoldFallbackModelHelp: '요약 모델 호출이 실패하면 이 모델로 재시도합니다. 이것도 실패하면 압력 접기는 기계적 접기로 전환됩니다. 추론 수준은 별도로 지정할 수 있으며, 비워 두면 이 모델의 권장 설정을 사용합니다. 쿨다운, 위험 제어, 동시성 제한에 여유가 있는 모델을 선택하고 주 세션과 같은 계정을 공유하지 않는 편이 좋습니다. 비우면 대체 경로가 없습니다.',
+				trimFallbackUnset: '미설정(실패 시 바로 기계적 접기)',
 				trimSectionTitle: '컨텍스트 트림',
 				trimModeLabel: '트림 모드',
 				trimModeHelp:
@@ -2028,7 +2038,7 @@ window.__ModuleLoader__.load({
 					'대화 발췌의 총 문자 상한(200–20000).',
 				intentFallbackRouteLabel: '폴백 모델',
 				intentFallbackRouteHelp:
-					'분류 실패 시: 이전 라우트 → 폴백 → 첫 후보. 빈 값은 첫 후보.',
+					'분류 실패 시: 이전 라우트 → 폴백 → 첫 후보. 비어 있으면 첫 후보입니다. 추론 수준을 선택적으로 고정할 수 있으며, 지정하지 않으면 폴백 모델 기본값을 따릅니다.',
 				intentRouteUnset: '미설정',
 				intentEffortFollow: '모델 기본값',
 				intentDockAuto: '자동',
@@ -2170,7 +2180,13 @@ window.__ModuleLoader__.load({
 					'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)',
+				trimEffortRecommended: 'Automatisch (Modell-Empfehlung)',
+				trimSideModelLabel: 'Zusammenfassungsmodell',
+				trimSideModelHelp: 'Modellroute für Zusammenfassungen. Standardmäßig folgt sie dem Sitzungsmodell, übernimmt aber nicht dessen Denkstufe. Leiter-Destillationen verwenden dieselbe Route. Ohne manuelle Vorgabe wird anhand der Modellmetadaten die niedrigste aktivierte Denkstufe gewählt; bei Modellen mit reinem Ein/Aus-Schalter wird off gewählt. Bei fehlender Unterstützung oder Metadaten wird keine Denkstufe gesendet und der Modellstandard verwendet.',
+				trimFollowSession: 'Sitzungsmodell folgen',
+				trimFoldFallbackModelLabel: 'Fallback-Modell für Faltungen',
+				trimFoldFallbackModelHelp: 'Wenn der Zusammenfassungsaufruf fehlschlägt, wird mit diesem Modell erneut versucht; schlägt auch das fehl, wird ein Druck-Fold mechanisch ausgeführt. Die Denkstufe kann unabhängig festgelegt werden; ohne Angabe greift die Modellempfehlung. Möglichst ein Modell ohne Cooldown-, Risiko- oder Parallelitätsbeschränkungen wählen und nicht dasselbe Konto wie die Hauptsitzung verwenden. Leer = kein Fallback.',
+				trimFallbackUnset: 'Nicht festgelegt (bei Fehler direkt mechanisch falten)',
 				trimSectionTitle: 'Kontext-Trim',
 				trimModeLabel: 'Trim-Modus',
 				trimModeHelp:
@@ -2262,7 +2278,7 @@ window.__ModuleLoader__.load({
 					'Gesamtzeichengrenze des Gesprächsauszugs (200–20000).',
 				intentFallbackRouteLabel: 'Fallback-Modell',
 				intentFallbackRouteHelp:
-					'Bei Klassifikationsfehler: zuletzt geroutet → Fallback → erster Kandidat; leer = erster Kandidat.',
+					'Bei Klassifikationsfehler: zuletzt geroutet → Fallback → erster Kandidat; leer = erster Kandidat. Der Thinking-Aufwand kann optional festgelegt werden; andernfalls gilt der Modellstandard des Fallbacks.',
 				intentRouteUnset: 'Nicht festgelegt',
 				intentEffortFollow: 'Modellstandard',
 				intentDockAuto: 'Auto',
@@ -2404,7 +2420,13 @@ window.__ModuleLoader__.load({
 					'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)',
+				trimEffortRecommended: 'Automático (recomendación del modelo)',
+				trimSideModelLabel: 'Modelo de resumen',
+				trimSideModelHelp: 'Ruta del modelo para los resúmenes. De forma predeterminada sigue el modelo de la sesión, pero no hereda su nivel de razonamiento. Las destilaciones por niveles usan la misma ruta. Sin una selección manual, los metadatos del modelo determinan el nivel habilitado más bajo; si solo ofrece activar o desactivar el razonamiento, se elige off. Si no admite razonamiento o faltan metadatos, no se envía ningún nivel y se usa el valor predeterminado del modelo.',
+				trimFollowSession: 'Seguir el modelo de la sesión',
+				trimFoldFallbackModelLabel: 'Modelo de respaldo para el plegado',
+				trimFoldFallbackModelHelp: 'Si falla la llamada al modelo de resumen, se reintenta con este modelo; si también falla, el plegado por presión pasa a ser mecánico. El nivel de razonamiento se puede fijar por separado; si se deja vacío, se aplica la recomendación de este modelo. Elige un modelo con margen en límites de enfriamiento, riesgo y concurrencia, y evita compartir cuenta con la sesión principal. Vacío = sin respaldo.',
+				trimFallbackUnset: 'Sin configurar (si falla, pasar directamente al plegado mecánico)',
 				trimSectionTitle: 'Recorte de contexto',
 				trimModeLabel: 'Modo de recorte',
 				trimModeHelp:
@@ -2497,7 +2519,7 @@ window.__ModuleLoader__.load({
 					'Límite total de caracteres del extracto de conversación (200–20000).',
 				intentFallbackRouteLabel: 'Modelo de reserva',
 				intentFallbackRouteHelp:
-					'Si falla la clasificación: último modelo enrutado → reserva → primer candidato; vacío = primer candidato.',
+					'Si falla la clasificación: último modelo enrutado → reserva → primer candidato; vacío = primer candidato. Puedes fijar opcionalmente el nivel de razonamiento; si no, se usa el valor predeterminado del modelo de reserva.',
 				intentRouteUnset: 'Sin establecer',
 				intentEffortFollow: 'predeterminado del modelo',
 				intentDockAuto: 'Auto',
@@ -2639,7 +2661,13 @@ window.__ModuleLoader__.load({
 					'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)',
+				trimEffortRecommended: 'Automatique (recommandation du modèle)',
+				trimSideModelLabel: 'Modèle de résumé',
+				trimSideModelHelp: 'Route du modèle pour les résumés. Par défaut, elle suit le modèle de la session sans reprendre son niveau de raisonnement. Les distillations en cascade utilisent la même route. Sans choix manuel, les métadonnées sélectionnent le niveau activé le plus faible ; pour un modèle avec seulement un interrupteur de raisonnement, le niveau choisi est off. Si le raisonnement est indisponible ou que les métadonnées manquent, aucun niveau n’est envoyé et le défaut du modèle s’applique.',
+				trimFollowSession: 'Suivre le modèle de la session',
+				trimFoldFallbackModelLabel: 'Modèle de secours pour le pliage',
+				trimFoldFallbackModelHelp: 'Si l’appel au modèle de résumé échoue, une nouvelle tentative utilise ce modèle ; en cas de nouvel échec, un pliage sous pression devient mécanique. Le niveau de raisonnement se règle séparément ; sans choix, la recommandation de ce modèle s’applique. Choisissez un modèle avec de la marge sur le refroidissement, le contrôle des risques et la concurrence, et évitez le même compte que la session principale. Vide = aucun secours.',
+				trimFallbackUnset: 'Non défini (en cas d’échec, passer directement au pliage mécanique)',
 				trimSectionTitle: 'Rognage du contexte',
 				trimModeLabel: 'Mode de rognage',
 				trimModeHelp:
@@ -2732,7 +2760,7 @@ window.__ModuleLoader__.load({
 					'Plafond total de caractères de l’extrait de conversation (200–20000).',
 				intentFallbackRouteLabel: 'Modèle de secours',
 				intentFallbackRouteHelp:
-					'En cas d’échec : dernier modèle routé → secours → premier candidat ; vide = premier candidat.',
+					'En cas d’échec : dernier modèle routé → secours → premier candidat ; vide = premier candidat. Vous pouvez épingler le niveau de raisonnement ; sinon, le niveau par défaut du modèle de secours est utilisé.',
 				intentRouteUnset: 'Non défini',
 				intentEffortFollow: 'par défaut du modèle',
 				intentDockAuto: 'Auto',
@@ -2874,7 +2902,13 @@ window.__ModuleLoader__.load({
 					'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)',
+				trimEffortRecommended: 'Automatico (consigliato dal modello)',
+				trimSideModelLabel: 'Modello di riepilogo',
+				trimSideModelHelp: 'Percorso del modello per i riepiloghi. Per impostazione predefinita segue il modello della sessione, senza ereditarne il livello di ragionamento. Anche le distillazioni a livelli usano lo stesso percorso. Senza una scelta manuale, i metadati determinano il livello attivo più basso; per i modelli con il solo interruttore on/off si usa off. Se il ragionamento non è supportato o mancano i metadati, non viene inviato alcun livello e si usa il valore predefinito del modello.',
+				trimFollowSession: 'Segui il modello della sessione',
+				trimFoldFallbackModelLabel: 'Modello di riserva per la piegatura',
+				trimFoldFallbackModelHelp: 'Se la chiamata al modello di riepilogo fallisce, si riprova con questo modello; se fallisce anche questo, la piegatura sotto pressione diventa meccanica. Il livello di ragionamento si può impostare separatamente; se vuoto, si usa la raccomandazione del modello. Scegli un modello con margine per cooldown, controllo del rischio e concorrenza, evitando di condividere l’account con la sessione principale. Vuoto = nessun fallback.',
+				trimFallbackUnset: 'Non impostato (in caso di errore, passa direttamente alla piegatura meccanica)',
 				trimSectionTitle: 'Riduzione del contesto',
 				trimModeLabel: 'Modalità di riduzione',
 				trimModeHelp:
@@ -2967,7 +3001,7 @@ window.__ModuleLoader__.load({
 					'Limite totale di caratteri dell’estratto della conversazione (200–20000).',
 				intentFallbackRouteLabel: 'Modello di riserva',
 				intentFallbackRouteHelp:
-					'In caso di errore: ultimo modello instradato → riserva → primo candidato; vuoto = primo candidato.',
+					'In caso di errore: ultimo modello instradato → riserva → primo candidato; vuoto = primo candidato. Puoi fissare il livello di ragionamento; se omesso, si usa il valore predefinito del modello di riserva.',
 				intentRouteUnset: 'Non impostato',
 				intentEffortFollow: 'predefinito del modello',
 				intentDockAuto: 'Auto',
@@ -3109,7 +3143,13 @@ window.__ModuleLoader__.load({
 					'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)',
+				trimEffortRecommended: 'Automático (recomendação do modelo)',
+				trimSideModelLabel: 'Modelo de resumo',
+				trimSideModelHelp: 'Rota do modelo para os resumos. Por padrão, segue o modelo da sessão, mas não herda o nível de raciocínio dessa chamada. As destilações em níveis usam a mesma rota. Sem escolha manual, os metadados selecionam o nível ativo mais baixo; para modelos com apenas a opção de ligar/desligar o raciocínio, usa-se off. Se o raciocínio não for compatível ou faltarem metadados, nenhum nível é enviado e vale o padrão do modelo.',
+				trimFollowSession: 'Seguir o modelo da sessão',
+				trimFoldFallbackModelLabel: 'Modelo de reserva para dobra',
+				trimFoldFallbackModelHelp: 'Se a chamada do modelo de resumo falhar, tenta novamente com este modelo; se também falhar, a dobra por pressão passa a ser mecânica. O nível de raciocínio pode ser definido separadamente; se ficar vazio, usa-se a recomendação deste modelo. Escolha um modelo com margem para cooldown, controle de risco e concorrência, evitando compartilhar a conta com a sessão principal. Vazio = sem fallback.',
+				trimFallbackUnset: 'Não configurado (em caso de falha, usar dobra mecânica diretamente)',
 				trimSectionTitle: 'Corte de contexto',
 				trimModeLabel: 'Modo de corte',
 				trimModeHelp:
@@ -3202,7 +3242,7 @@ window.__ModuleLoader__.load({
 					'Limite total de caracteres do trecho da conversa (200–20000).',
 				intentFallbackRouteLabel: 'Modelo de reserva',
 				intentFallbackRouteHelp:
-					'Se a classificação falhar: último modelo roteado → reserva → primeiro candidato; vazio = primeiro candidato.',
+					'Se a classificação falhar: último modelo roteado → reserva → primeiro candidato; vazio = primeiro candidato. É possível fixar o nível de raciocínio; se não definido, usa-se o padrão do modelo de reserva.',
 				intentRouteUnset: 'Não definido',
 				intentEffortFollow: 'padrão do modelo',
 				intentDockAuto: 'Auto',
@@ -3344,7 +3384,13 @@ window.__ModuleLoader__.load({
 					'Масштабирует уровни под собственное окно модели субагента: force = min(статический уровень, окно × доля); soft/hard сжимаются на тот же коэффициент. Только ужесточает, не смягчает.',
 				wmSubagentFollowForce: 'Следовать линии force (0)',
 				wmCommands: 'Команды: /ctx-pause приостанавливает действия по уровню воды · /ctx-resume возобновляет их · /ctx-handover записывает документ передачи и сжимает прямо сейчас.',
-				trimEffortPinLow: 'По умолчанию (pin low)',
+				trimEffortRecommended: 'Авто (рекомендация модели)',
+				trimSideModelLabel: 'Модель сводки',
+				trimSideModelHelp: 'Маршрут модели для сводок. По умолчанию следует модели сессии, но не наследует уровень рассуждения этого вызова. Для ступенчатой дистилляции используется тот же маршрут. Без ручного выбора метаданные задают самый низкий включённый уровень; для модели только с переключателем рассуждений выбирается off. Если рассуждения не поддерживаются или метаданных нет, уровень не передаётся и используется значение модели по умолчанию.',
+				trimFollowSession: 'Следовать модели сессии',
+				trimFoldFallbackModelLabel: 'Резервная модель сворачивания',
+				trimFoldFallbackModelHelp: 'Если вызов модели сводки завершается ошибкой, повтор выполняется на этой модели; при повторном сбое сворачивание под давлением становится механическим. Уровень рассуждения задаётся отдельно; если не указан, действует рекомендация этой модели. Выбирайте модель с запасом по охлаждению, контролю рисков и параллельным запросам и не используйте общий аккаунт с главной сессией. Пусто = без резервного маршрута.',
+				trimFallbackUnset: 'Не задано (при сбое сразу перейти к механическому сворачиванию)',
 				trimSectionTitle: 'Обрезка контекста',
 				trimModeLabel: 'Режим обрезки',
 				trimModeHelp:
@@ -3436,7 +3482,7 @@ window.__ModuleLoader__.load({
 					'Общий лимит символов выборки диалога (200–20000).',
 				intentFallbackRouteLabel: 'Резервная модель',
 				intentFallbackRouteHelp:
-					'При сбое классификации: прошлая модель → резерв → первый кандидат; пусто = первый кандидат.',
+					'При сбое классификации: прошлая модель → резерв → первый кандидат; пусто = первый кандидат. Можно задать уровень reasoning; если он не указан, используется значение резервной модели по умолчанию.',
 				intentRouteUnset: 'Не задано',
 				intentEffortFollow: 'по умолчанию модели',
 				intentDockAuto: 'Авто',
@@ -5433,10 +5479,12 @@ window.__ModuleLoader__.load({
 				trimSideModel: {
 					provider: values.trimSideModel.provider,
 					model: values.trimSideModel.model,
+					...(values.trimSideModel.effort ? { effort: values.trimSideModel.effort } : {}),
 				},
 				trimFoldFallbackModel: {
 					provider: values.trimFoldFallbackModel.provider,
 					model: values.trimFoldFallbackModel.model,
+					...(values.trimFoldFallbackModel.effort ? { effort: values.trimFoldFallbackModel.effort } : {}),
 				},
 				trimStateDir: values.trimStateDir,
 				...Object.fromEntries(
@@ -5445,9 +5493,9 @@ window.__ModuleLoader__.load({
 				teamsMode: values.teamsMode,
 				syncWhitelist: values.syncWhitelist,
 				// Intent recognition (design: intent-routing.md §2): route
-				// objects materialize {provider, model} like the pool fields;
-				// candidate effort/note are always sent (blank string = unset,
-				// the Host coerces per its schema).
+				// Route objects materialize {provider, model[, effort]} as configured;
+				// the classifier route remains effort-free. Candidate effort/note are
+				// always sent (blank string = unset; Host coerces per schema).
 				intentEnabled: values.intentEnabled,
 				intentClassifierRoute: {
 					provider: values.intentClassifierRoute.provider,
@@ -5472,6 +5520,7 @@ window.__ModuleLoader__.load({
 				intentFallbackRoute: {
 					provider: values.intentFallbackRoute.provider,
 					model: values.intentFallbackRoute.model,
+					...(values.intentFallbackRoute.effort ? { effort: values.intentFallbackRoute.effort } : {}),
 				},
 			};
 			if (sameValues(current, desired)) {
@@ -5875,9 +5924,10 @@ window.__ModuleLoader__.load({
 										(meta) => meta.model === route.model,
 									);
 									edit(field, {
-										provider: next,
-										model: kept ? route.model : '',
-									});
+									provider: next,
+									model: kept ? route.model : '',
+									effort: '',
+								});
 								},
 							),
 							'aria-label': `${label} · provider`,
@@ -5891,7 +5941,7 @@ window.__ModuleLoader__.load({
 								`${intentId}-${field}-model`,
 								route.model,
 								(next) => {
-									edit(field, { ...route, model: next });
+									edit(field, { ...route, model: next, effort: '' });
 								},
 							),
 							disabled: !editable || route.provider === '',
@@ -5899,6 +5949,16 @@ window.__ModuleLoader__.load({
 						},
 						...intentModelOptions(route.provider, route.model),
 					),
+					field === 'intentFallbackRoute' && route.provider !== '' && route.model !== ''
+						? intentEffortSelect(
+							`${intentId}-${field}-effort`,
+							route,
+							route.effort ?? '',
+							(next) => edit(field, { ...route, effort: next }),
+							`${label} · effort`,
+							t('intentEffortFollow'),
+						)
+						: null,
 				);
 			};
 			/** Trim route rows reuse the intent route picker machinery — the
@@ -5950,6 +6010,7 @@ window.__ModuleLoader__.load({
 									...route,
 									provider: next,
 									model: kept ? route.model : '',
+									effort: '',
 								});
 							},
 						),
@@ -5963,10 +6024,10 @@ window.__ModuleLoader__.load({
 								: route.model,
 							(next) => {
 								if (followMode && next === TRIM_ROUTE_FOLLOW) {
-									edit(field, { ...route, model: '' });
+									edit(field, { ...route, model: '', effort: '' });
 									return;
 								}
-								edit(field, { ...route, model: next });
+								edit(field, { ...route, model: next, effort: '' });
 							},
 						),
 						disabled: !editable || route.provider === '',
@@ -5976,10 +6037,10 @@ window.__ModuleLoader__.load({
 						? intentEffortSelect(
 							`${trimId}-${field}-effort`,
 							route,
-							route.effort,
+							route.effort ?? '',
 							(next) => edit(field, { ...route, effort: next }),
 							`${label} · effort`,
-							t('trimEffortPinLow'),
+							t('trimEffortRecommended'),
 						)
 						: null,
 				);
@@ -5988,8 +6049,8 @@ window.__ModuleLoader__.load({
 			 *  wire efforts when the catalog reports them, the EFFORTS
 			 *  fallback otherwise; '' = adapter default. A stored value
 			 *  missing from the list stays selectable. emptyLabel replaces
-			 *  the '' option label (trim rows pin low instead of following
-			 *  the model default). */
+			 *  the '' option label. Trim rows use their automatic recommendation;
+			 *  an empty intent-fallback pin follows the model default. */
 			const intentEffortSelect = (
 				id,
 				route,

package/host/config.js

@@ -67,10 +67,9 @@ 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. 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. */
+ *  Consumers validate non-empty before trusting the route. `effort` is an
+ *  optional override for summary routes and intent fallback; the classifier
+ *  route remains effort-free in its route cleaner. */
 const IntentRouteSchema = z.object({
 	provider: z.string(),
 	model: z.string(),
@@ -240,8 +239,9 @@ export const Config = z.object({
 	 *  the 0.8×-window auto-compaction (see effectiveContextWindow in
 	 *  host/intent.js). */
 	intentContextWindow: z.number().min(1024).default(200000).volatile(),
-	/** Optional last-resort route when the classifier fails and no previous
-	 *  routed model exists; empty = the first candidate. */
+	/** Optional fallback route after classification fails when no prior route
+	 *  is available; empty = the first candidate. An optional effort pin
+	 *  overrides the fallback model's default. */
 	intentFallbackRoute: IntentRouteSchema.default({ provider: "", model: "" }).volatile(),
 
 	// --- Context trim: fully-automatic conversation compression ------------
@@ -292,12 +292,14 @@ export const Config = z.object({
 	 *  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. */
+	 *  session's current provider/model; an optional effort pin overrides
+	 *  the model's automatic recommended effort. */
 	trimSideModel: IntentRouteSchema.default({ provider: "", model: "" }).volatile(),
 	/** Route for the fold-fallback summarizer. When the primary side route
 	 *  (trimSideModel or the inherited session model) fails, raw folds retry
 	 *  on this route before degrading to a mechanical fold; ladder folds
-	 *  retry but never go mechanical. Pick a route with headroom on cooldown,
+	 *  retry but never go mechanical. An optional effort pin overrides the
+	 *  model's automatic recommendation. Pick a route with headroom on cooldown,
 	 *  risk-control, and concurrency limits. Empty = no fallback leg. */
 	trimFoldFallbackModel: IntentRouteSchema.default({ provider: "", model: "" }).volatile(),
 	/** T1/T2/T3 ladder folding (docs/ladder-fold.md): master switch for the

package/host/context-trim/index.js

@@ -695,10 +695,9 @@ export function applyContextTrim(ctx, config) {
 		} else if (view.applied > 0) {
 			epochResetDoneBySession.delete(sessionId);
 		}
-		// 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.
+		// Record the active request's route and resolved effort for diagnostics only.
+		// The side summarizer follows provider/model only and resolves effort from its
+		// model metadata rather than inheriting this dispatch's effort.
 		const model = {
 			provider: options.provider ?? null,
 			model: options.model ?? null,
@@ -718,16 +717,14 @@ export function applyContextTrim(ctx, config) {
 	}
 
 	/** Resolve the side-model route: explicit trimSideModel route, else the
-	 * session's own model (inherit — design §5). */
+	 * session's own provider/model. Effort is resolved from that model's
+	 * supported thinking metadata, not inherited from the active session call. */
 	function sideRouteFor(sessionId) {
 		const explicit = readRoute(config, "trimSideModel");
 		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 !== "") {
-			// 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 { provider: model.provider, model: model.model };
 		}
 		return null;
 	}

package/host/context-trim/summarizer.js

@@ -224,15 +224,25 @@ function describeFailure(chunk) {
 	return ` (${raw.replace(/\s+/gu, " ").trim().slice(0, 300)})`;
 }
 
-/** Side-model summary. llm: the dsh llm service (receiver-bound methods);
- * 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). */
+/** Choose the lowest enabled tier when several reasoning levels are available.
+ * A model with only an on/off switch is pinned to "off"; when reasoning
+ * metadata is absent, leave the model's adapter default unchanged. */
+export function recommendedReasoningEffort(modelInfo) {
+	const efforts = modelInfo?.reasoning?.efforts;
+	if (!Array.isArray(efforts) || efforts.length === 0) return null;
+	const ids = efforts.map((entry) => typeof entry === "string" ? entry : entry?.id).filter((id) => typeof id === "string" && id !== "");
+	const enabled = ids.filter((id) => id !== "off");
+	if (enabled.length > 1) return enabled[0];
+	return ids.includes("off") ? "off" : null;
+}
+
+/** Side-model summary. llm: the dsh llm service; route: {provider, model, effort?}.
+ * An empty effort pin is resolved from model reasoning metadata; unavailable
+ * metadata leaves the adapter default unchanged. Returns summary text or null. */
 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.
+	// Effort-retry notice: fires before a one-time effort fallback, whether
+	// or not that retry lands. Falls back to fail when no notice is supplied.
 	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; }
@@ -242,39 +252,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 {
-		// 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";
+		// Resolve from the selected model itself: an empty pin means the lowest
+		// advertised thinking effort, while absent reasoning metadata leaves
+		// the adapter default (no thinking) untouched. Explicit effort pins win.
+		let modelInfo = null;
+		if (typeof llm.resolveModelInfo === "function") {
+			try { modelInfo = await llm.resolveModelInfo(route.provider, route.model, controller.signal); }
+			catch { /* Metadata is advisory; prepareCall remains authoritative. */ }
+		}
+		const automaticEffort = recommendedReasoningEffort(modelInfo);
+		const hasOffEffort = Array.isArray(modelInfo?.reasoning?.efforts) && modelInfo.reasoning.efforts.some((entry) => (typeof entry === "string" ? entry : entry?.id) === "off");
+		const explicitEffort = typeof route.effort === "string" && route.effort !== "";
+		const requestedEffort = explicitEffort ? route.effort : automaticEffort;
+		const proposalFor = (effort) => ({
+			provider: route.provider,
+			model: route.model,
+			maxTokens,
+			...(typeof effort === "string" && effort !== "" ? { reasoningEffort: effort } : {}),
+		});
 		let call;
 		try {
-			call = await llm.prepareCall(
-				{ provider: route.provider, model: route.model, maxTokens, reasoningEffort: requestedEffort },
-				controller.signal,
-				(controls) => controls,
-			);
+			call = await llm.prepareCall(proposalFor(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,
-			);
+			if (code !== "UNSUPPORTED_REASONING_EFFORT" && !named) throw prepareError;
+			// Stale metadata or a stale pin should not prevent a summary: retry
+			// once at the model's automatic minimum, or without an effort. Never
+			// turn an explicitly requested "off" into enabled reasoning.
+			const retryEffort = requestedEffort === "off"
+				? null
+				: (explicitEffort && automaticEffort !== requestedEffort ? automaticEffort : (hasOffEffort ? "off" : null));
+			if (retryEffort === requestedEffort) throw prepareError;
+			(notice ?? fail)?.(`effort "${requestedEffort ?? "default"}" unsupported, retrying ${retryEffort ?? "without reasoning"}`);
+			call = await llm.prepareCall(proposalFor(retryEffort), controller.signal, (controls) => controls);
 		}
 		let text = "";
 		let finishKind = null;

package/host/ptc-guard.js

@@ -89,6 +89,12 @@ function renderPtcGuard() {
 		`- Every other tool MUST be invoked as an awaited SDK function inside a ${RUN_CODE_NAME} program: \`await tools.name(args)\` — e.g. \`await tools.skill({ name: "git-commit-message" })\` or \`await tools.spawn_teammate({ ... })\`.`,
 		`- A direct call fails with: unknown tool "x": only \`${RUN_CODE_NAME}\` is callable directly — call \`x\` from inside a \`${RUN_CODE_NAME}\` program instead. Never retry the direct form; wrap the call.`,
 		`- Wherever this prompt says "call the X tool" (skill catalog, doctrines, per-turn reminders), read it as "call X inside a ${RUN_CODE_NAME} program". Batch independent calls as parallel awaits inside ONE program.`,
+		`- \`grep.pattern\` is a regular expression. In a normal JavaScript string inside \`${RUN_CODE_NAME}\`, double backslashes: write \`"\\\\("\` to pass \`\\(\` to grep; \`String.raw\` tagged templates also preserve backslashes. If grep reports \`unclosed group\`, fix the pattern before retrying; never repeat it unchanged.`,
+		`- Unless this call must intentionally retain state across calls (e.g. the one-time CUA bridge initialization), MUST wrap the entire ${RUN_CODE_NAME} program body in an async IIFE: \`await (async () => { ... })();\`. Keep all temporary \`const\`/\`let\`/\`class\` declarations inside it; this makes reusing local names such as \`res\` safe even when an earlier call used them. Top-level bindings persist for this Agent: only create them for intentionally shared state, and never redeclare existing top-level \`const\`/\`let\`/\`class\`; reassign an existing top-level \`var\` or choose a fresh unique name. If \`Identifier ... has already been declared\` occurs, rewrite the program in the IIFE rather than merely rerunning it—the SyntaxError happens before the body runs.`,
+		`- For intentional top-level bindings, maintain a ledger of declared names at \`globalThis.__dshSwitchmanPtcBindings\` (initialize idempotently with \`globalThis.__dshSwitchmanPtcBindings ??= new Set()\`). Before emitting a program with top-level declarations, check each name against this ledger and the visible prior \`${RUN_CODE_NAME}\` snippets; after a successful declaration, add the name with \`globalThis.__dshSwitchmanPtcBindings.add("name")\`. This ledger is manually maintained, not automatic introspection: if the old history or ledger is incomplete, do not guess—keep the code in an IIFE or choose a fresh name.`,
+		`- For routine \`${RUN_CODE_NAME}\` calls — including programs that only call SDK tools such as \`tools.skill(...)\` — pass only \`code\`, \`description\`, and \`timeoutMs\`; omit both \`sandbox_permissions\` and \`justification\`. If a call is rejected for invalid justification, never repeat it unchanged; retry without those fields.`,
+		`- If ${RUN_CODE_NAME} returns a parser error such as "Expected ident", treat it as a syntax issue in the submitted code; when present, the appended "File sandbox: ..." reports execution context, not the cause. Correct the code before retrying; never repeat it unchanged.`,
+		`- When a ${RUN_CODE_NAME} program embeds long prompt text, do not hand-write it as a double-quoted JavaScript string if it contains quotes (for example, getResource(".") or System.getProperty("user.dir")): build the text as data, escape the inner quotes, or serialize it with JSON.stringify(text); inspect or syntax-check the complete source before retrying.`,
 		`- Never set \`sandbox_permissions\` on any call, direct or SDK: it is a privilege-escalation request and fails with "not strictly wider than this call's current ... mode" whenever the session already runs at least that access level — retry without the field.`,
 	].join("\n");
 }

package/host/routes.js

@@ -150,13 +150,12 @@ 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 round-trip the "unset" {provider:"", model:""}
+/** Intent classifier routes 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"];
+ *  must be strings; either may be empty). */
+const INTENT_ROUTE_FIELDS = ["intentClassifierRoute"];
+/** Summary routes and the intent fallback route can carry an effort pin. */
+const EFFORT_ROUTE_FIELDS = ["trimSideModel", "trimFoldFallbackModel", "intentFallbackRoute"];
 /** Intent candidate list (route + optional effort/note per entry). */
 const INTENT_CANDIDATE_FIELDS = ["intentCandidates"];
 
@@ -315,11 +314,8 @@ function cleanIntentRoute(entry) {
 	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) {
+/** Coerce one route that may carry an optional reasoning-effort pin. */
+function cleanEffortRoute(entry) {
 	const route = cleanIntentRoute(entry);
 	if (route === null) return null;
 	const effort = typeof entry.effort === "string" ? entry.effort.trim() : "";
@@ -370,7 +366,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 EFFORT_ROUTE_FIELDS) values[field] = cleanEffortRoute(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))
@@ -445,8 +441,8 @@ export function coerceValues(input) {
 		if (route === null) return null;
 		values[field] = route;
 	}
-	for (const field of TRIM_ROUTE_FIELDS) {
-		const route = cleanTrimRoute(input[field]);
+	for (const field of EFFORT_ROUTE_FIELDS) {
+		const route = cleanEffortRoute(input[field]);
 		if (route === null) return null;
 		values[field] = route;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dsh-switchman",
-	"version": "1.11.4",
+	"version": "1.11.5",
 	"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": [