muonroi-cli 1.8.3 → 1.8.5

package/dist/src/utils/settings.d.ts

@@ -4,6 +4,17 @@ import type { ProviderId } from "../providers/types.js";
 import type { AgentMode, ReasoningEffort } from "../types/index.js";
 import { type ShellSettings } from "./shell.js";
 export type ModelRole = "leader" | "implement" | "verify" | "research";
+export type PeakHourMode = "downgrade" | "switch";
+export interface PeakHourPolicy {
+    /** Default true — peak-hour routing active. */
+    enabled?: boolean;
+    /**
+     * downgrade: same-provider only (per catalog provider_policies.peak_hour).
+     * switch: try catalog switch_fallback_providers first.
+     * Default: switch.
+     */
+    mode?: PeakHourMode;
+}
 export declare function getCatalogDefaultModel(): string;
 export type TelegramStreamingMode = "off" | "partial";
 export type CouncilExperienceMode = "off" | "advisory" | "enforcing";
@@ -101,6 +112,9 @@ export interface UserSettings {
     autoCompactAfterTurn?: boolean;
     /** Minimum % of context window to trigger post-turn auto-compact (default 0.25 = 25%, range 0.05-0.50). */
     autoCompactThresholdPct?: number;
+    /** Minimum new tokens accumulated since the last compaction before another
+     *  post-turn compaction may fire. Prevents cache-reset thrash. Default 20000. */
+    autoCompactMinNewTokens?: number;
     roleModels?: Partial<Record<ModelRole, string>>;
     councilRounds?: number;
     autoCouncil?: boolean;
@@ -118,6 +132,26 @@ export interface UserSettings {
      * preserving legacy behavior).
      */
     autoCouncilMinRoles?: number;
+    /**
+     * Whether an auto-triggered council/debate runs the pre-debate clarification
+     * interview (model-designed askcards) before debating, instead of jumping
+     * straight into the debate on the bare prompt. Default true — a broad request
+     * like "dùng debate mode thảo luận lên plan" is exactly the kind of ambiguous
+     * scope the interview is meant to chốt first (prevents the debate drifting /
+     * "lan man"). The clarifier is ROI-gated and returns 0 cards on already-detailed
+     * topics, so enabling it is safe. Set false (or env MUONROI_AUTOCOUNCIL_CLARIFY=0)
+     * to restore the old skip-clarification behaviour.
+     */
+    autoCouncilClarify?: boolean;
+    /**
+     * When true (default), auto-council is skipped if the current session model is
+     * a reasoning model (catalog `reasoning: true`). Reasoning models already
+     * perform an internal self-debate via extended thinking, so running an
+     * explicit multi-role council on the same prompt is usually low-ROI and
+     * expensive. Set false (or env MUONROI_AUTOCOUNCIL_SKIP_REASONING=0) to force
+     * council even for reasoning models.
+     */
+    autoCouncilSkipReasoning?: boolean;
     councilPreferMultiProvider?: boolean;
     /** EE involvement level in council debates. Default: advisory. CQ-19. */
     councilExperienceMode?: CouncilExperienceMode;
@@ -132,6 +166,20 @@ export interface UserSettings {
      * decide structure and quality, not throughput.
      */
     councilCostAware?: boolean;
+    /**
+     * Language the council debate is conducted in (Feature B). The chosen language
+     * IS the debate language — no separate translate-back pass, so no extra LLM
+     * rounds. Values:
+     *   - "auto" (default) — debate + conclusion follow the language of the user's
+     *     prompt/brief (they type Vietnamese → the debate runs in Vietnamese).
+     *   - "english" — force the historical English-only debate (citation tags,
+     *     JSON, cross-turn citations stay maximally machine-stable).
+     *   - any other free-text locale label (e.g. "vietnamese", "日本語") — pin the
+     *     debate to that language regardless of the prompt's language.
+     * Citation tags, JSON keys, the `type` field, code identifiers, and STACK LOCK
+     * technology names always stay verbatim English regardless of this setting.
+     */
+    councilLanguage?: string;
     /** Set true after the user has been prompted (or skipped) the web-research onboarding. */
     webResearchPrompted?: boolean;
     /** Set true after the user has been prompted (or skipped) the first-run Experience Engine setup. */
@@ -151,13 +199,13 @@ export interface UserSettings {
     providers?: {
         anthropic?: ProviderKeyConfig;
         openai?: ProviderKeyConfig;
-        google?: ProviderKeyConfig;
         deepseek?: ProviderKeyConfig;
-        siliconflow?: ProviderKeyConfig;
         xai?: ProviderKeyConfig;
         ollama?: {
             baseURL?: string;
         };
+        zai?: ProviderKeyConfig;
+        "opencode-go"?: ProviderKeyConfig;
     };
     /** Providers the user has explicitly disabled in the model picker (still configured but hidden). */
     disabledProviders?: ProviderId[];
@@ -187,6 +235,11 @@ export interface UserSettings {
         /** Switch back to premium for final synthesis. Default: false. */
         premiumSynthesis?: boolean;
     };
+    /**
+     * Peak-hour routing for Z.ai (14:00–18:00 UTC+8 per docs) and DeepSeek
+     * (pro→flash downgrade in the same window to ease concurrency pressure).
+     */
+    peakHourPolicy?: PeakHourPolicy;
     /**
      * Reporter auto-fire settings (B2).
      * Controls whether the reporter posts to Discord automatically on sprint
@@ -216,6 +269,27 @@ export interface UserSettings {
      * Default 400_000 (~100k tokens).
      */
     topLevelToolBudgetChars?: number;
+    /**
+     * Router tier-promotion cap. The session's default model is treated as the
+     * user's cost ceiling: the EE router may DOWNGRADE per turn (cheaper model)
+     * but may not promote to a HIGHER tier than this setting allows without an
+     * explicit opt-in.
+     *
+     * - `"off"`: never promote beyond the default model's own tier.
+     * - `"balanced"` (default): allow promotion up to balanced, never premium.
+     *   Routine tasks the EE brain over-classifies as premium get clamped to
+     *   balanced (or to the default model when the provider has no balanced
+     *   option — e.g. DeepSeek native only has fast + premium).
+     * - `"any"`: restore legacy behavior (router may promote to any tier).
+     *
+     * Evidence: session 89b34ce9a4e8 — default deepseek-v4-flash (fast tier),
+     * stored session.model=flash, but EE warm path returned premium for a
+     * routine "check và commit files" task → 47/47 turns silently ran on
+     * deepseek-v4-pro ($0.353) instead of flash (~$0.06). The per-turn routing
+     * override never flowed through setModel so the sessions row stayed flash
+     * ("session.model lie"). Default cap="balanced" prevents that silent leak.
+     */
+    routingPromoteMax?: "off" | "balanced" | "any";
 }
 export interface ProjectSettings {
     model?: string;
@@ -279,6 +353,7 @@ export declare function loadPaymentSettings(): Required<PaymentSettings>;
 export declare function savePaymentSettings(partial: PaymentSettings): void;
 export declare function isAutoCompactAfterTurnEnabled(): boolean;
 export declare function getAutoCompactThresholdPct(): number;
+export declare function getAutoCompactMinNewTokens(): number;
 /**
  * Per-invocation cap on cumulative tool-output chars inside a `task`
  * sub-agent. See orchestrator/sub-agent-cap.ts for the tiered compression
@@ -294,6 +369,21 @@ export declare function getSubAgentBudgetChars(): number;
  * Default 120_000 (2 min). Env override: MUONROI_PROVIDER_STALL_TIMEOUT_MS.
  */
 export declare function getProviderStallTimeoutMs(): number;
+/**
+ * No-forward-progress watchdog timeout (ms) for streaming model calls. Distinct
+ * from the stall watchdog: the stall watchdog re-arms on ANY stream chunk —
+ * including a reasoning model's `reasoning-delta` chunks — so a model stuck in an
+ * endless chain-of-thought keeps petting it and it NEVER fires (observed live
+ * 2026-07-10: a deepseek-v4-flash sub-agent churned reasoning for 30+ min, 1.4M
+ * input tokens, ZERO text/tool output, and the 2-min stall watchdog never tripped
+ * because reasoning chunks kept arriving). This second watchdog is petted ONLY on
+ * REAL forward progress (a text-delta or a tool-call), so a runaway-reasoning /
+ * no-output loop is aborted while a legitimately long reasoning burst that DOES
+ * eventually emit text/tools survives. Set generously above a normal reasoning
+ * burst. Range 30_000–1_800_000; 0 disables. Default 300_000 (5 min). Env
+ * override: MUONROI_PROVIDER_PROGRESS_TIMEOUT_MS.
+ */
+export declare function getProviderProgressTimeoutMs(): number;
 /**
  * Number of times to AUTOMATICALLY re-issue a streaming model call after the
  * stall watchdog fires WITHOUT any chunk having arrived (a time-to-first-byte
@@ -337,21 +427,48 @@ export declare function getSubAgentCompactKeepLast(): number;
  * top-level loops typically carry more useful early context.
  * Env override: MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS.
  */
-export declare function getTopLevelCompactThresholdChars(): number;
+export declare function getTopLevelCompactThresholdChars(contextWindowTokens?: number): number;
+/**
+ * Compaction hysteresis factor for the top-level loop. Once B4 compaction has
+ * fired within a turn, the compacted prefix is FROZEN and only new messages are
+ * appended (keeping the provider prompt-cache prefix byte-stable) until the
+ * cumulative size grows past `lastTriggerChars * factor` — then it re-compacts.
+ *
+ * Why: measured on session 1afb2728e67a — a 24-step turn re-ran compaction every
+ * step, and each step's sliding keepLast boundary flipped one more tool result
+ * verbatim→stub, breaking the cache prefix at that position. 63% of that
+ * session's FRESH input came from 5 such compaction-induced cache breaks.
+ * Holding the boundary between compactions trades a higher peak input for far
+ * fewer cache-break re-bills.
+ *
+ * Range 1.0–3.0. Default 1.15 (re-compact at +15% growth). `1.0` or env `0`
+ * disables hysteresis → legacy per-step compaction.
+ * Env override: MUONROI_COMPACT_HYSTERESIS.
+ */
+export declare function getTopLevelCompactHysteresis(): number;
 /**
  * Phase B4 — number of trailing tool turns kept verbatim during top-level
  * compaction. Higher than sub-agent default because top-level agents make
  * decisions across longer horizons.
  * Env override: MUONROI_TOP_LEVEL_COMPACT_KEEP_LAST.
  */
-export declare function getTopLevelCompactKeepLast(): number;
+export declare function getTopLevelCompactKeepLast(contextWindowTokens?: number): number;
+/**
+ * O2 — byte budget for the verbatim tail (last keepLast turns) in top-level B4
+ * compaction. The keepLast shrink is otherwise fill-ratio based, so on a
+ * large-context model a read-heavy tail stays verbatim at ~50% fill, pinning
+ * each tool round at 60-80K input (measured on July-8 sessions). This caps the
+ * tail's actual chars, shrinking keepLast further (floor 2) when the kept tool
+ * results are large. 0 disables. Env: MUONROI_TOP_LEVEL_COMPACT_TAIL_BUDGET_CHARS.
+ */
+export declare function getTopLevelCompactTailBudgetChars(contextWindowTokens?: number): number;
 /**
  * Per-turn cap on cumulative tool-output chars inside the top-level
  * orchestrator agentic loop. Same tiered compression as the sub-agent cap,
  * higher default so single-tool turns are unaffected. Env override:
  * MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS.
  */
-export declare function getTopLevelToolBudgetChars(maxRounds?: number): number;
+export declare function getTopLevelToolBudgetChars(maxRounds?: number, contextWindowTokens?: number): number;
 export declare function getRoleModel(role: ModelRole): string | undefined;
 export declare function getRoleModels(): Partial<Record<ModelRole, string>>;
 export declare function getCouncilRounds(): number;
@@ -361,10 +478,41 @@ export declare function normalizeAutoCouncilConfidence(val: unknown): number;
 /** Pure validator extracted for testability; clamps user input to a sane range. */
 export declare function normalizeAutoCouncilMinRoles(val: unknown): number;
 export declare function getAutoCouncilConfidence(): number;
+/**
+ * Whether the auto-council path runs the pre-debate clarification interview
+ * (model-designed askcards) before debating. Default true so a broadly-scoped
+ * "debate mode" request is clarified first. Env override wins over the user
+ * setting for quick dev toggling; env "0"/"false" disables, "1"/"true" enables.
+ */
+export declare function isAutoCouncilClarifyEnabled(): boolean;
+/**
+ * Whether auto-council should be skipped when the session model is a reasoning
+ * model. Default true. Env override wins over the user setting for quick dev
+ * toggling; env "0"/"false" disables the skip (forces council), "1"/"true"
+ * enables the skip.
+ */
+export declare function isAutoCouncilSkipReasoning(): boolean;
 export declare function getAutoCouncilMinRoles(): number;
 export declare function isCouncilMultiProviderPreferred(): boolean;
 export declare function getCouncilExperienceMode(): CouncilExperienceMode;
+export declare function normalizePeakHourPolicy(raw: unknown): PeakHourPolicy;
+export declare function getPeakHourPolicy(): PeakHourPolicy;
 export declare function isCouncilCostAware(): boolean;
+/**
+ * Normalize a raw councilLanguage value (Feature B). Trims + lowercases the two
+ * reserved modes ("auto", "english"); any other non-empty string is preserved
+ * as-is (trimmed) so locale labels keep the user's exact casing (e.g. "日本語").
+ * Empty / non-string → "auto".
+ */
+export declare function normalizeCouncilLanguage(raw: unknown): string;
+export declare function getCouncilLanguage(): string;
+/**
+ * Router tier-promotion ceiling. See UserSettings.routingPromoteMax.
+ * Default "balanced" — router may promote up to balanced but never silently
+ * to premium. Validated to the three allowed values; any unknown value
+ * falls back to the default.
+ */
+export declare function getRoutingPromoteMax(): "off" | "balanced" | "any";
 export declare function getDisabledProviders(): ProviderId[];
 export declare function isProviderDisabled(provider: ProviderId): boolean;
 export declare function setProviderDisabled(provider: ProviderId, disabled: boolean): ProviderId[];

package/dist/src/utils/settings.js

@@ -1,7 +1,7 @@
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-import { getEffectiveReasoningEffort, getFirstCatalogModel, getFirstCatalogProvider, getModelByTier, getModelIds, getModelInfo, MODELS, normalizeModelId, } from "../models/registry.js";
+import { getCatalogCouncilRouting, getEffectiveReasoningEffort, getFirstCatalogModel, getFirstCatalogProvider, getModelByTier, getModelIds, getModelInfo, MODELS, normalizeModelId, } from "../models/registry.js";
 import { apiBaseFor, PROVIDER_ENDPOINTS } from "../providers/endpoints.js";
 import { ALL_PROVIDER_IDS } from "../providers/types.js";
 import { logger } from "./logger.js";
@@ -72,8 +72,9 @@ export function parseSubAgentsRawList(raw) {
 export function loadValidSubAgents() {
     return parseSubAgentsRawList(loadUserSettings().subAgents);
 }
-const USER_DIR = path.join(os.homedir(), ".muonroi-cli");
-const USER_SETTINGS_PATH = path.join(USER_DIR, "user-settings.json");
+function getUserSettingsPath() {
+    return path.join(os.homedir(), ".muonroi-cli", "user-settings.json");
+}
 function ensureDir(dir) {
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
@@ -179,7 +180,7 @@ export function ensureFootprintGitignored(cwd = process.cwd()) {
     }
 }
 export function loadUserSettings() {
-    return readJson(USER_SETTINGS_PATH) || {};
+    return readJson(getUserSettingsPath()) || {};
 }
 export function saveUserSettings(partial) {
     const current = loadUserSettings();
@@ -248,7 +249,7 @@ export function saveUserSettings(partial) {
             }
             : {}),
     };
-    writeJson(USER_SETTINGS_PATH, next);
+    writeJson(getUserSettingsPath(), next);
 }
 export function loadProjectSettings() {
     const projectPath = path.join(process.cwd(), ".muonroi-cli", "settings.json");
@@ -310,11 +311,6 @@ export function getProviderConfigs(mainApiKey) {
     if (openaiKey) {
         configs.openai = { apiKey: openaiKey, baseURL: p.openai?.baseURL };
     }
-    // Google Gemini
-    const googleKey = process.env.GOOGLE_API_KEY ?? p.google?.apiKey;
-    if (googleKey) {
-        configs.google = { apiKey: googleKey, baseURL: p.google?.baseURL };
-    }
     // DeepSeek
     const deepseekKey = process.env.DEEPSEEK_API_KEY ?? p.deepseek?.apiKey;
     if (deepseekKey) {
@@ -323,14 +319,6 @@ export function getProviderConfigs(mainApiKey) {
             baseURL: p.deepseek?.baseURL ?? apiBaseFor("deepseek"),
         };
     }
-    // SiliconFlow
-    const siliconflowKey = process.env.SILICONFLOW_API_KEY ?? p.siliconflow?.apiKey;
-    if (siliconflowKey) {
-        configs.siliconflow = {
-            apiKey: siliconflowKey,
-            baseURL: p.siliconflow?.baseURL ?? apiBaseFor("siliconflow"),
-        };
-    }
     // xAI / Grok (OpenAI-compatible)
     const xaiKey = process.env.XAI_API_KEY ?? p.xai?.apiKey;
     if (xaiKey) {
@@ -339,6 +327,22 @@ export function getProviderConfigs(mainApiKey) {
             baseURL: p.xai?.baseURL ?? apiBaseFor("xai"),
         };
     }
+    // Z.ai (OpenAI-compatible)
+    const zaiKey = process.env.ZAI_API_KEY ?? p.zai?.apiKey;
+    if (zaiKey) {
+        configs.zai = {
+            apiKey: zaiKey,
+            baseURL: p.zai?.baseURL ?? apiBaseFor("zai"),
+        };
+    }
+    // OpenCode Go (OpenAI-compatible)
+    const opencodeGoKey = process.env.OPENCODE_GO_API_KEY ?? p["opencode-go"]?.apiKey;
+    if (opencodeGoKey) {
+        configs["opencode-go"] = {
+            apiKey: opencodeGoKey,
+            baseURL: p["opencode-go"]?.baseURL ?? apiBaseFor("opencode-go"),
+        };
+    }
     // Ollama — no key needed, just baseURL
     const ollamaURL = process.env.OLLAMA_URL ?? p.ollama?.baseURL ?? "http://localhost:11434";
     configs.ollama = { baseURL: ollamaURL };
@@ -591,6 +595,12 @@ export function getAutoCompactThresholdPct() {
         return val;
     return 0.4; // default 40% — Reduced from 25% after session bf58d0f46b51 analysis: 13 compacts in 43min generated 1.3M uncached tokens. Higher threshold = fewer compacts = less compaction overhead. For DeepSeek 128K context: fires at 51K instead of 32K.
 }
+export function getAutoCompactMinNewTokens() {
+    const val = loadUserSettings().autoCompactMinNewTokens;
+    if (typeof val === "number" && val >= 0 && val <= 200_000)
+        return val;
+    return 20_000; // Observed thrash: re-compact after ~14K new tokens (session ff932f8568e8).
+}
 /**
  * Per-invocation cap on cumulative tool-output chars inside a `task`
  * sub-agent. See orchestrator/sub-agent-cap.ts for the tiered compression
@@ -627,6 +637,31 @@ export function getProviderStallTimeoutMs() {
     }
     return 120_000;
 }
+/**
+ * No-forward-progress watchdog timeout (ms) for streaming model calls. Distinct
+ * from the stall watchdog: the stall watchdog re-arms on ANY stream chunk —
+ * including a reasoning model's `reasoning-delta` chunks — so a model stuck in an
+ * endless chain-of-thought keeps petting it and it NEVER fires (observed live
+ * 2026-07-10: a deepseek-v4-flash sub-agent churned reasoning for 30+ min, 1.4M
+ * input tokens, ZERO text/tool output, and the 2-min stall watchdog never tripped
+ * because reasoning chunks kept arriving). This second watchdog is petted ONLY on
+ * REAL forward progress (a text-delta or a tool-call), so a runaway-reasoning /
+ * no-output loop is aborted while a legitimately long reasoning burst that DOES
+ * eventually emit text/tools survives. Set generously above a normal reasoning
+ * burst. Range 30_000–1_800_000; 0 disables. Default 300_000 (5 min). Env
+ * override: MUONROI_PROVIDER_PROGRESS_TIMEOUT_MS.
+ */
+export function getProviderProgressTimeoutMs() {
+    const envRaw = process.env.MUONROI_PROVIDER_PROGRESS_TIMEOUT_MS;
+    if (envRaw !== undefined && envRaw !== "") {
+        const n = Number(envRaw);
+        if (Number.isFinite(n) && n === 0)
+            return 0; // explicit disable
+        if (Number.isFinite(n) && n >= 30_000 && n <= 1_800_000)
+            return Math.floor(n);
+    }
+    return 300_000;
+}
 /**
  * Number of times to AUTOMATICALLY re-issue a streaming model call after the
  * stall watchdog fires WITHOUT any chunk having arrived (a time-to-first-byte
@@ -702,17 +737,50 @@ export function getSubAgentCompactKeepLast() {
  * top-level loops typically carry more useful early context.
  * Env override: MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS.
  */
-export function getTopLevelCompactThresholdChars() {
+export function getTopLevelCompactThresholdChars(contextWindowTokens) {
     const envRaw = process.env.MUONROI_TOP_LEVEL_COMPACT_THRESHOLD_CHARS;
     if (envRaw) {
         const n = Number(envRaw);
-        if (Number.isFinite(n) && n >= 50_000 && n <= 1_500_000)
+        if (Number.isFinite(n) && n >= 10_000 && n <= 1_500_000)
             return Math.floor(n);
     }
-    // Phase C5 — lowered from 200_000 to 100_000 chars (symmetric with the
-    // sub-agent 80→40K reduction). Same evidence applies: tool results are
-    // capped, so the chars threshold rarely trips while token billing climbs.
-    return 100_000;
+    // For small-context models (e.g. DeepSeek 64K), scale threshold proportionally
+    // to prevent linear token growth during tool loops. A model with 64K context
+    // gets threshold = 64000 * 4 * 0.35 = 89,600 chars (~22K tokens = 35% of window).
+    // Large-context models (128K+) keep the original 200K default.
+    if (contextWindowTokens && contextWindowTokens > 0) {
+        const dynamicThreshold = Math.floor(contextWindowTokens * 4 * 0.35);
+        return Math.min(200_000, dynamicThreshold);
+    }
+    return 200_000;
+}
+/**
+ * Compaction hysteresis factor for the top-level loop. Once B4 compaction has
+ * fired within a turn, the compacted prefix is FROZEN and only new messages are
+ * appended (keeping the provider prompt-cache prefix byte-stable) until the
+ * cumulative size grows past `lastTriggerChars * factor` — then it re-compacts.
+ *
+ * Why: measured on session 1afb2728e67a — a 24-step turn re-ran compaction every
+ * step, and each step's sliding keepLast boundary flipped one more tool result
+ * verbatim→stub, breaking the cache prefix at that position. 63% of that
+ * session's FRESH input came from 5 such compaction-induced cache breaks.
+ * Holding the boundary between compactions trades a higher peak input for far
+ * fewer cache-break re-bills.
+ *
+ * Range 1.0–3.0. Default 1.15 (re-compact at +15% growth). `1.0` or env `0`
+ * disables hysteresis → legacy per-step compaction.
+ * Env override: MUONROI_COMPACT_HYSTERESIS.
+ */
+export function getTopLevelCompactHysteresis() {
+    const envRaw = process.env.MUONROI_COMPACT_HYSTERESIS;
+    if (envRaw !== undefined && envRaw.trim() !== "") {
+        const n = Number(envRaw);
+        if (Number.isFinite(n) && n === 0)
+            return 1.0; // explicit disable
+        if (Number.isFinite(n) && n >= 1.0 && n <= 3.0)
+            return n;
+    }
+    return 1.15;
 }
 /**
  * Phase B4 — number of trailing tool turns kept verbatim during top-level
@@ -720,22 +788,59 @@ export function getTopLevelCompactThresholdChars() {
  * decisions across longer horizons.
  * Env override: MUONROI_TOP_LEVEL_COMPACT_KEEP_LAST.
  */
-export function getTopLevelCompactKeepLast() {
+export function getTopLevelCompactKeepLast(contextWindowTokens) {
     const envRaw = process.env.MUONROI_TOP_LEVEL_COMPACT_KEEP_LAST;
     if (envRaw) {
         const n = Number(envRaw);
         if (Number.isFinite(n) && n >= 1 && n <= 30)
             return Math.floor(n);
     }
+    // Small-context models (< 100K tokens) benefit from keeping fewer trailing
+    // turns — each verbatim turn with tool results + reasoning tokens costs
+    // 5-15K tokens. Reduce from 5 to 3 for small windows.
+    if (contextWindowTokens && contextWindowTokens < 100_000) {
+        return 3;
+    }
     return 5;
 }
+/**
+ * O2 — byte budget for the verbatim tail (last keepLast turns) in top-level B4
+ * compaction. The keepLast shrink is otherwise fill-ratio based, so on a
+ * large-context model a read-heavy tail stays verbatim at ~50% fill, pinning
+ * each tool round at 60-80K input (measured on July-8 sessions). This caps the
+ * tail's actual chars, shrinking keepLast further (floor 2) when the kept tool
+ * results are large. 0 disables. Env: MUONROI_TOP_LEVEL_COMPACT_TAIL_BUDGET_CHARS.
+ */
+export function getTopLevelCompactTailBudgetChars(contextWindowTokens) {
+    const envRaw = process.env.MUONROI_TOP_LEVEL_COMPACT_TAIL_BUDGET_CHARS;
+    if (envRaw !== undefined && envRaw.trim() !== "") {
+        const n = Number(envRaw);
+        // 0 = explicit disable; otherwise clamp to a sane floor so a fat-fingered
+        // tiny value can't stub away all recent context.
+        if (Number.isFinite(n) && n === 0)
+            return 0;
+        if (Number.isFinite(n) && n >= 20_000 && n <= 1_000_000)
+            return Math.floor(n);
+    }
+    // Default 50K chars (~12.5K tokens). Chosen from a deterministic measurement:
+    // on a realistic read-heavy turn the keepLast=5 verbatim tail is ~70-100K
+    // chars, so a looser budget (e.g. 120K) never bites (no-op). 50K shrinks the
+    // effective tail to ~3 turns on heavy turns (matching the sub-agent keepLast
+    // default) — ~7K tokens/call saved — while high-value results stay verbatim
+    // and light turns (below the 200K compaction threshold) are untouched. For
+    // small windows, scale to ~20% of the window so the tail can't dominate.
+    if (contextWindowTokens && contextWindowTokens > 0) {
+        return Math.min(50_000, Math.floor(contextWindowTokens * 4 * 0.2));
+    }
+    return 50_000;
+}
 /**
  * Per-turn cap on cumulative tool-output chars inside the top-level
  * orchestrator agentic loop. Same tiered compression as the sub-agent cap,
  * higher default so single-tool turns are unaffected. Env override:
  * MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS.
  */
-export function getTopLevelToolBudgetChars(maxRounds) {
+export function getTopLevelToolBudgetChars(maxRounds, contextWindowTokens) {
     const envRaw = process.env.MUONROI_TOP_LEVEL_TOOL_BUDGET_CHARS;
     if (envRaw) {
         const n = Number(envRaw);
@@ -748,10 +853,35 @@ export function getTopLevelToolBudgetChars(maxRounds) {
     // Dynamically scale default based on maxRounds relative to default base (40)
     const baseRounds = 40;
     const scale = maxRounds && maxRounds > baseRounds ? maxRounds / baseRounds : 1;
-    return Math.floor(400_000 * scale);
+    const baseDefault = Math.floor(400_000 * scale);
+    // For small-context models (e.g. DeepSeek 64K), scale the budget to 60% of
+    // the context window in chars so tiered compression kicks in before the
+    // cumulative tool output exceeds what the model can hold in context.
+    if (contextWindowTokens && contextWindowTokens > 0 && contextWindowTokens < 200_000) {
+        const windowBudget = Math.floor(contextWindowTokens * 4 * 0.6);
+        return Math.min(baseDefault, Math.max(50_000, windowBudget));
+    }
+    return baseDefault;
 }
 export function getRoleModel(role) {
-    return loadUserSettings().roleModels?.[role];
+    const configured = loadUserSettings().roleModels?.[role];
+    if (!configured)
+        return undefined;
+    // Graceful staleness guard (mirrors getCurrentModel's pickValid): a role model
+    // persisted before a catalog rename/drop (e.g. "grok-build-0.1" after it was
+    // dropped in favor of grok-composer-2.5-fast) must NOT leak a dead id to the
+    // runtime, where resolveModelRuntime throws "not found in catalog — cannot
+    // determine provider" and takes down the whole council speaker (observed:
+    // Experience Auditor on the research role). If the catalog hasn't loaded yet,
+    // trust the normalized id; otherwise drop unresolved ids so the caller falls
+    // back to its own default instead of crashing.
+    const normalized = normalizeModelId(configured);
+    if (MODELS.length === 0)
+        return normalized;
+    if (getModelInfo(normalized))
+        return normalized;
+    logger.warn("cli", `roleModels.${role} = "${configured}" is not in the catalog (renamed or removed); ignoring so the caller falls back to its default. Update it via /config.`);
+    return undefined;
 }
 export function getRoleModels() {
     return loadUserSettings().roleModels ?? {};
@@ -778,18 +908,92 @@ export function normalizeAutoCouncilMinRoles(val) {
 export function getAutoCouncilConfidence() {
     return normalizeAutoCouncilConfidence(loadUserSettings().autoCouncilConfidence);
 }
+/**
+ * Whether the auto-council path runs the pre-debate clarification interview
+ * (model-designed askcards) before debating. Default true so a broadly-scoped
+ * "debate mode" request is clarified first. Env override wins over the user
+ * setting for quick dev toggling; env "0"/"false" disables, "1"/"true" enables.
+ */
+export function isAutoCouncilClarifyEnabled() {
+    const env = process.env.MUONROI_AUTOCOUNCIL_CLARIFY?.trim().toLowerCase();
+    if (env === "0" || env === "false")
+        return false;
+    if (env === "1" || env === "true")
+        return true;
+    return loadUserSettings().autoCouncilClarify ?? true;
+}
+/**
+ * Whether auto-council should be skipped when the session model is a reasoning
+ * model. Default true. Env override wins over the user setting for quick dev
+ * toggling; env "0"/"false" disables the skip (forces council), "1"/"true"
+ * enables the skip.
+ */
+export function isAutoCouncilSkipReasoning() {
+    const env = process.env.MUONROI_AUTOCOUNCIL_SKIP_REASONING?.trim().toLowerCase();
+    if (env === "0" || env === "false")
+        return false;
+    if (env === "1" || env === "true")
+        return true;
+    return loadUserSettings().autoCouncilSkipReasoning ?? true;
+}
 export function getAutoCouncilMinRoles() {
     return normalizeAutoCouncilMinRoles(loadUserSettings().autoCouncilMinRoles);
 }
 export function isCouncilMultiProviderPreferred() {
-    return loadUserSettings().councilPreferMultiProvider ?? false;
+    const user = loadUserSettings().councilPreferMultiProvider;
+    if (user !== undefined)
+        return user;
+    return getCatalogCouncilRouting()?.prefer_multi_provider ?? true;
 }
 export function getCouncilExperienceMode() {
     return loadUserSettings().councilExperienceMode ?? "advisory";
 }
+export function normalizePeakHourPolicy(raw) {
+    if (!raw || typeof raw !== "object") {
+        return { enabled: true, mode: "switch" };
+    }
+    const p = raw;
+    return {
+        enabled: p.enabled !== false,
+        mode: p.mode === "downgrade" ? "downgrade" : "switch",
+    };
+}
+export function getPeakHourPolicy() {
+    return normalizePeakHourPolicy(loadUserSettings().peakHourPolicy);
+}
 export function isCouncilCostAware() {
     return loadUserSettings().councilCostAware ?? true;
 }
+/**
+ * Normalize a raw councilLanguage value (Feature B). Trims + lowercases the two
+ * reserved modes ("auto", "english"); any other non-empty string is preserved
+ * as-is (trimmed) so locale labels keep the user's exact casing (e.g. "日本語").
+ * Empty / non-string → "auto".
+ */
+export function normalizeCouncilLanguage(raw) {
+    if (typeof raw !== "string")
+        return "auto";
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return "auto";
+    const lower = trimmed.toLowerCase();
+    if (lower === "auto" || lower === "english")
+        return lower;
+    return trimmed;
+}
+export function getCouncilLanguage() {
+    return normalizeCouncilLanguage(loadUserSettings().councilLanguage);
+}
+/**
+ * Router tier-promotion ceiling. See UserSettings.routingPromoteMax.
+ * Default "balanced" — router may promote up to balanced but never silently
+ * to premium. Validated to the three allowed values; any unknown value
+ * falls back to the default.
+ */
+export function getRoutingPromoteMax() {
+    const raw = loadUserSettings().routingPromoteMax;
+    return raw === "off" || raw === "balanced" || raw === "any" ? raw : "balanced";
+}
 export function getDisabledProviders() {
     const raw = loadUserSettings().disabledProviders;
     if (!Array.isArray(raw))

package/dist/src/utils/side-question.js

@@ -1,7 +1,7 @@
 import { generateText } from "ai";
 import { resolveModelRuntime } from "../providers/runtime.js";
-const SIDE_QUESTION_SYSTEM = `You are a helpful coding assistant answering a quick side question. The user is in the middle of a coding session and needs a fast, concise answer. Keep your response short and focused — this is a side question, not the main task.
-
+const SIDE_QUESTION_SYSTEM = `You are a helpful coding assistant answering a quick side question. The user is in the middle of a coding session and needs a fast, concise answer. Keep your response short and focused — this is a side question, not the main task.
+
 If conversation context is provided below, use it to give a more relevant answer.`;
 export async function runSideQuestion(question, provider, modelId, conversationContext, signal) {
     const runtime = resolveModelRuntime(provider, modelId);

package/dist/src/utils/skills.js

@@ -163,9 +163,9 @@ export function discoverSkills(projectRoot) {
     _skillsCache = { skills, cachedAt: now, cwd: projectRoot };
     return skills;
 }
-const SKILLS_INSTRUCTIONS = `AGENT SKILLS (optional):
-The following <available_skills> list specialized workflows. Use them when they might help the user's request — not only on exact keyword matches.
-If a skill's description fits the task or could improve consistency, read that skill's instructions first using read_file with the path from <location>, then follow the SKILL.md body.
+const SKILLS_INSTRUCTIONS = `AGENT SKILLS (optional):
+The following <available_skills> list specialized workflows. Use them when they might help the user's request — not only on exact keyword matches.
+If a skill's description fits the task or could improve consistency, read that skill's instructions first using read_file with the path from <location>, then follow the SKILL.md body.
 Paths inside a skill (scripts/, references/, assets/) are relative to the skill directory (the folder containing SKILL.md); prefer absolute paths in tool calls.`;
 /** OpenCode-style XML catalog plus activation instructions for read_file. Returns null if no skills. */
 export function formatSkillsForPrompt(skills) {