clementine-agent 1.18.14 → 1.18.16

package/README.md

@@ -324,14 +324,20 @@ clementine restart                    # apply changes
 
 Your overrides live in `~/.clementine/.env` — **they survive every `npm update -g` / `clementine update`** because they're in your data home, not the package directory.
 
+The dashboard exposes these spend controls in Settings -> Channels & Env ->
+Spend Guards & Context Health, including direct dollar-cap editing, Default
+Caps, Safe Recovery, and No Caps presets.
+
 For spend/context tuning, `clementine budgets` gives a safer shortcut:
 
 ```bash
 clementine budgets              # show chat/cron/heartbeat caps and 1M context state
-clementine budgets safe         # lower background budgets and disable Claude 1M context
-clementine budgets 1m on        # enable 1M context for eligible accounts / Extra Usage
+clementine budgets safe         # lower background budgets and force standard 200K context
+clementine budgets 1m auto      # allow included Opus 1M, keep Sonnet on 200K
+clementine budgets 1m on        # force 1M context for Extra Usage/API users
 clementine budgets 1m off       # disable 1M context for maximum compatibility
 clementine budgets set chat 10  # raise one budget cap
+clementine budgets set chat 0   # remove one cap
 ```
 
 **Commonly tuned knobs:**
@@ -342,7 +348,8 @@ clementine budgets set chat 10  # raise one budget cap
 | `BUDGET_CRON_T1_USD` | `0.75` | Max spend per tier-1 cron job |
 | `BUDGET_CRON_T2_USD` | `1.50` | Max spend per tier-2 cron job |
 | `BUDGET_HEARTBEAT_USD` | `0.25` | Max spend per heartbeat tick |
-| `CLAUDE_CODE_DISABLE_1M_CONTEXT` | `true` | `true`/`1` keeps Claude Code on 200K context unless the user explicitly enables 1M |
+| `CLEMENTINE_1M_CONTEXT_MODE` | `auto` | `auto` allows included Opus 1M on Max/Team/Enterprise while keeping Sonnet on 200K; `off` forces 200K; `on` forces 1M |
+| `CLAUDE_CODE_DISABLE_1M_CONTEXT` | legacy | Backward-compatible Claude Code switch; `budgets safe` writes `1`, `budgets 1m auto` removes it |
 | `DEFAULT_MODEL_TIER` | `sonnet` | Default model: `haiku` / `sonnet` / `opus` |
 | `HEARTBEAT_INTERVAL_MINUTES` | `30` | How often the agent auto-checks in |
 | `HEARTBEAT_ACTIVE_START` | `8` | First hour of the active window (0–23) |

package/dist/agent/assistant.js

@@ -13,7 +13,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { query as rawQuery, listSubagents, getSubagentMessages, SYSTEM_PROMPT_DYNAMIC_BOUNDARY, } from '@anthropic-ai/claude-agent-sdk';
 import pino from 'pino';
-import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE, MEMORY_FILE, AGENTS_DIR, ASSISTANT_NAME, OWNER_NAME, MODEL, MODELS, HEARTBEAT_MAX_TURNS, SEARCH_CONTEXT_LIMIT, SEARCH_RECENCY_LIMIT, SYSTEM_PROMPT_MAX_CONTEXT_CHARS, SESSION_EXCHANGE_HISTORY_SIZE, SESSION_EXCHANGE_MAX_CHARS, INJECTED_CONTEXT_MAX_CHARS, UNLEASHED_PHASE_TURNS, UNLEASHED_DEFAULT_MAX_HOURS, UNLEASHED_MAX_PHASES, PROJECTS_META_FILE, CRON_PROGRESS_DIR, CRON_REFLECTIONS_DIR, HANDOFFS_DIR, BUDGET, TASK_BUDGET_TOKENS, IDENTITY_FILE, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, envSnapshot, } from '../config.js';
+import { BASE_DIR, PKG_DIR, VAULT_DIR, DAILY_NOTES_DIR, SOUL_FILE, AGENTS_FILE, MEMORY_FILE, AGENTS_DIR, ASSISTANT_NAME, OWNER_NAME, MODEL, MODELS, HEARTBEAT_MAX_TURNS, SEARCH_CONTEXT_LIMIT, SEARCH_RECENCY_LIMIT, SYSTEM_PROMPT_MAX_CONTEXT_CHARS, SESSION_EXCHANGE_HISTORY_SIZE, SESSION_EXCHANGE_MAX_CHARS, INJECTED_CONTEXT_MAX_CHARS, UNLEASHED_PHASE_TURNS, UNLEASHED_DEFAULT_MAX_HOURS, UNLEASHED_MAX_PHASES, PROJECTS_META_FILE, CRON_PROGRESS_DIR, CRON_REFLECTIONS_DIR, HANDOFFS_DIR, BUDGET, TASK_BUDGET_TOKENS, IDENTITY_FILE, CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_API_KEY as CONFIG_ANTHROPIC_API_KEY, claudeCodeDisableOneMillionForModel, currentOneMillionContextMode, normalizeClaudeModelForOneMillionContext, usesOneMillionContext, envSnapshot, } from '../config.js';
 import { summarizeIntegrationStatus } from '../config/integrations-registry.js';
 import { loadToolPreferences, computeAvailability, buildPromptInstruction, buildComposioStatusBlock, } from '../integrations/tool-preferences.js';
 import { loadClaudeIntegrations } from './mcp-bridge.js';
@@ -320,6 +320,8 @@ const MODEL_CONTEXT_WINDOWS = {
     'opus': 200_000,
 };
 function getContextWindow(model) {
+    if (usesOneMillionContext(model))
+        return 1_000_000;
     for (const [family, size] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
         if (model.includes(family))
             return size;
@@ -338,10 +340,6 @@ function resultInputTokens(result) {
     }
     return total;
 }
-function oneMillionContextDisabled() {
-    const value = process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT;
-    return value === undefined || !/^(0|false|no)$/i.test(value);
-}
 export function looksLikeOneMillionContextError(value) {
     const text = String(value ?? '');
     return /extra usage.*1m context|1m context.*extra usage|context-1m/i.test(text);
@@ -537,12 +535,6 @@ function buildSafeEnv() {
         sanitized.ANTHROPIC_API_KEY = apiKeyVal;
     }
     // When all are absent: HOME lets the subprocess find Keychain OAuth automatically.
-    // Preserve trusted Claude Code runtime flags set by config.ts. In
-    // particular, CLAUDE_CODE_DISABLE_1M_CONTEXT defaults on so background
-    // helper queries do not silently re-enable the 1M context beta.
-    if (process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT !== undefined) {
-        sanitized.CLAUDE_CODE_DISABLE_1M_CONTEXT = process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT;
-    }
     // Step 3: Add trusted markers AFTER sanitization
     sanitized.CLEMENTINE_HOME = BASE_DIR;
     return sanitized;
@@ -2148,7 +2140,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             && toolsDisabledForCall
             && turnPolicy?.retrievalTier === 'none'
             && turnPolicy.effort === 'low';
-        const resolvedModel = resolveModel(requestedModel) ?? (lightweightModelEligible ? MODELS.haiku : MODEL);
+        const rawResolvedModel = resolveModel(requestedModel) ?? (lightweightModelEligible ? MODELS.haiku : MODEL);
+        const resolvedModel = normalizeClaudeModelForOneMillionContext(rawResolvedModel);
+        const oneMillionModeValue = currentOneMillionContextMode();
+        const oneMillionDisableValue = claudeCodeDisableOneMillionForModel(resolvedModel);
         const modelRouteReason = model
             ? 'explicit'
             : profile?.model
@@ -2421,7 +2416,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             systemPrompt: fullSystemPrompt,
             model: resolvedModel,
             ...(fallback ? { fallbackModel: fallback } : {}),
-            ...(oneMillionContextDisabled() ? { betas: [] } : {}),
+            ...(oneMillionDisableValue === '1' ? { betas: [] } : {}),
             permissionMode: effectivePermissionMode,
             allowDangerouslySkipPermissions: true,
             ...(sessionStore ? { sessionStore } : {}),
@@ -2459,6 +2454,10 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                             CLEMENTINE_TEAM_AGENT: profile?.slug ?? 'clementine',
                             CLEMENTINE_INTERACTION_SOURCE: sourceOverride ?? inferInteractionSource(sessionKey),
                             CLEMENTINE_TOOL_ALLOWLIST: clementineToolAllowlist,
+                            CLEMENTINE_1M_CONTEXT_MODE: oneMillionModeValue,
+                            ...(oneMillionDisableValue !== undefined
+                                ? { CLAUDE_CODE_DISABLE_1M_CONTEXT: oneMillionDisableValue }
+                                : {}),
                         },
                     },
                     ...externalMcpServers,
@@ -2472,14 +2471,21 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
             // env only when the prompt/job mentions a connector-backed service.
             // Per-MCP-server env isolation still happens inside each mcpServers
             // entry; this only affects the Claude Code subprocess itself.
-            ...(shouldInheritClaudeEnv ? {} : {
-                env: {
+            env: shouldInheritClaudeEnv
+                ? {
+                    ...process.env,
+                    CLEMENTINE_1M_CONTEXT_MODE: oneMillionModeValue,
+                    ...(oneMillionDisableValue !== undefined
+                        ? { CLAUDE_CODE_DISABLE_1M_CONTEXT: oneMillionDisableValue }
+                        : {}),
+                }
+                : {
                     ...SAFE_ENV,
-                    ...(process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT !== undefined
-                        ? { CLAUDE_CODE_DISABLE_1M_CONTEXT: process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT }
+                    CLEMENTINE_1M_CONTEXT_MODE: oneMillionModeValue,
+                    ...(oneMillionDisableValue !== undefined
+                        ? { CLAUDE_CODE_DISABLE_1M_CONTEXT: oneMillionDisableValue }
                         : {}),
                 },
-            }),
             // Avoid ambient Claude Code user/project/local settings and plugins by
             // default. Those can silently attach hundreds of tools. Explicit MCP
             // servers above still work; "all integrations/full tool surface" keeps
@@ -3421,13 +3427,14 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                                         responseText = responseText || ('Claude says the account credit balance is too low. I paused background jobs for a few hours so they stop draining/retrying, but interactive chat will also fail until credits are available again.');
                                     }
                                     else if (looksLikeOneMillionContextError(errorText)) {
+                                        process.env.CLEMENTINE_1M_CONTEXT_MODE = 'off';
                                         process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
                                         if (sessionKey) {
                                             this.sessions.delete(sessionKey);
                                             this.exchangeCounts.set(sessionKey, 0);
                                             this._compactedSessions.delete(sessionKey);
                                         }
-                                        responseText = responseText || ("Claude rejected the 1M context beta for this account. I've disabled 1M context for this process and reset the session. To persist the fix across restarts, run `clementine config doctor --fix`, then `clementine restart`.");
+                                        responseText = responseText || ("Claude rejected 1M context for this account. I've switched this process to 200K recovery mode and reset the session. To persist the fix across restarts, run `clementine budgets safe`, then `clementine restart`.");
                                     }
                                     else if (lower.includes('rate') && lower.includes('limit')) {
                                         hitRateLimit = true;
@@ -3552,13 +3559,14 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         responseText = responseText || ('Claude says the account credit balance is too low. I paused background jobs for a few hours so they stop draining/retrying, but interactive chat will also fail until credits are available again.');
                     }
                     else if (looksLikeOneMillionContextError(e)) {
+                        process.env.CLEMENTINE_1M_CONTEXT_MODE = 'off';
                         process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
                         if (sessionKey) {
                             this.sessions.delete(sessionKey);
                             this.exchangeCounts.set(sessionKey, 0);
                             this._compactedSessions.delete(sessionKey);
                         }
-                        responseText = responseText || ("Claude rejected the 1M context beta for this account. I've disabled 1M context for this process and reset the session. To persist the fix across restarts, run `clementine config doctor --fix`, then `clementine restart`.");
+                        responseText = responseText || ("Claude rejected 1M context for this account. I've switched this process to 200K recovery mode and reset the session. To persist the fix across restarts, run `clementine budgets safe`, then `clementine restart`.");
                     }
                     else if (errStr.includes('rate') && (errStr.includes('limit') || errStr.includes('rate_limit'))) {
                         hitRateLimit = true;
@@ -4814,6 +4822,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                         throw new Error(errText);
                     }
                     if (looksLikeOneMillionContextError(errText)) {
+                        process.env.CLEMENTINE_1M_CONTEXT_MODE = 'off';
                         process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
                         throw new Error(errText);
                     }
@@ -5162,6 +5171,7 @@ You have a cost budget per message — not a hard turn limit. Work until the tas
                                 throw new Error(exitText);
                             }
                             if (looksLikeOneMillionContextError(exitText)) {
+                                process.env.CLEMENTINE_1M_CONTEXT_MODE = 'off';
                                 process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
                                 throw new Error(exitText);
                             }

package/dist/cli/dashboard.js

@@ -5459,6 +5459,8 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             label: 'Model',
             keys: [
                 { key: 'DEFAULT_MODEL_TIER', label: 'Default Tier', hint: 'haiku, sonnet, or opus', type: 'select:haiku,sonnet,opus' },
+                { key: 'CLEMENTINE_1M_CONTEXT_MODE', label: '1M Context Mode', hint: 'auto allows included Opus 1M where available; off forces 200K; on forces 1M', type: 'select:auto,off,on' },
+                { key: 'CLAUDE_CODE_DISABLE_1M_CONTEXT', label: 'Legacy 1M Disable', hint: 'Backward-compatible Claude Code switch. Prefer CLEMENTINE_1M_CONTEXT_MODE.', type: 'select:,1,0,true,false' },
             ],
         },
         {
@@ -5585,6 +5587,7 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         return result;
     }
     function writeEnvValue(key, value) {
+        mkdirSync(BASE_DIR, { recursive: true });
         let content = existsSync(ENV_PATH) ? readFileSync(ENV_PATH, 'utf-8') : '';
         const re = new RegExp(`^${key}=.*$`, 'm');
         if (re.test(content)) {
@@ -5593,7 +5596,72 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
         else {
             content = content.trimEnd() + `\n${key}=${value}\n`;
         }
-        writeFileSync(ENV_PATH, content);
+        writeFileSync(ENV_PATH, content, { mode: 0o600 });
+    }
+    function deleteEnvValue(key) {
+        if (!existsSync(ENV_PATH))
+            return;
+        const re = new RegExp(`^${key}=.*\n?`, 'm');
+        const content = readFileSync(ENV_PATH, 'utf-8').replace(re, '');
+        writeFileSync(ENV_PATH, content, { mode: 0o600 });
+    }
+    const DASHBOARD_BUDGET_ROWS = [
+        { key: 'BUDGET_CHAT_USD', value: '5', label: 'Chat', hint: 'Per interactive chat turn' },
+        { key: 'BUDGET_HEARTBEAT_USD', value: '0.25', label: 'Heartbeat', hint: 'Per proactive heartbeat tick' },
+        { key: 'BUDGET_CRON_T1_USD', value: '0.75', label: 'Tier 1 cron', hint: 'Per lightweight scheduled job' },
+        { key: 'BUDGET_CRON_T2_USD', value: '1.5', label: 'Tier 2 cron', hint: 'Per deeper scheduled job' },
+    ];
+    const SAFE_DASHBOARD_BUDGETS = [
+        { key: 'BUDGET_HEARTBEAT_USD', value: '0.25', label: 'Heartbeat' },
+        { key: 'BUDGET_CRON_T1_USD', value: '0.75', label: 'Tier 1 cron' },
+        { key: 'BUDGET_CRON_T2_USD', value: '1.5', label: 'Tier 2 cron' },
+    ];
+    const DASHBOARD_BUDGET_KEYS = new Set(DASHBOARD_BUDGET_ROWS.map(row => row.key));
+    function normalizeDashboardOneMillionMode(value) {
+        const v = String(value ?? '').trim().toLowerCase();
+        if (!v)
+            return null;
+        if (v === 'auto')
+            return 'auto';
+        if (['off', 'disable', 'disabled', 'safe', '200k', 'standard'].includes(v))
+            return 'off';
+        if (['on', 'enable', 'enabled', 'yes', 'true', '1'].includes(v))
+            return 'on';
+        return null;
+    }
+    function legacyDisableToDashboardMode(value) {
+        const v = String(value ?? '').trim().toLowerCase();
+        if (!v)
+            return null;
+        if (['1', 'true', 'yes', 'on'].includes(v))
+            return 'off';
+        if (['0', 'false', 'no', 'off'].includes(v))
+            return 'on';
+        return null;
+    }
+    function formatDashboardBudgetValue(value) {
+        const n = Number(value);
+        if (!Number.isFinite(n))
+            return String(value ?? '');
+        if (n === 0)
+            return 'No cap';
+        return `$${n.toFixed(2)}`;
+    }
+    function writeDashboardBudgetCap(key, value) {
+        if (!DASHBOARD_BUDGET_KEYS.has(key)) {
+            return { ok: false, error: 'Unknown budget key' };
+        }
+        const n = Number(value);
+        if (!Number.isFinite(n) || n < 0) {
+            return { ok: false, error: 'Budget must be a non-negative dollar amount. Use 0 for no cap.' };
+        }
+        if (n > 1000) {
+            return { ok: false, error: 'Budget cap is too high for the dashboard. Use the CLI if you really need a cap above $1000.' };
+        }
+        const normalized = n === 0 ? '0' : String(Math.round(n * 100) / 100);
+        writeEnvValue(key, normalized);
+        process.env[key] = normalized;
+        return { ok: true, value: normalized };
     }
     const ASSISTANT_PREF_OPTIONS = {
         proactivity: ['quiet', 'balanced', 'proactive', 'operator'],
@@ -5653,6 +5721,188 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
             res.status(500).json({ error: String(err) });
         }
     });
+    app.get('/api/budgets', async (_req, res) => {
+        try {
+            const [{ computeEffectiveConfig }, { runDoctor }] = await Promise.all([
+                import('../config/effective-config.js'),
+                import('../config/config-doctor.js'),
+            ]);
+            const cfg = computeEffectiveConfig(BASE_DIR);
+            const doctor = runDoctor(BASE_DIR);
+            const byKey = new Map(cfg.entries.map(e => [e.key, e]));
+            const oneMModeEntry = byKey.get('CLEMENTINE_1M_CONTEXT_MODE');
+            const legacyEntry = byKey.get('CLAUDE_CODE_DISABLE_1M_CONTEXT');
+            const legacyMode = legacyDisableToDashboardMode(legacyEntry?.value);
+            const mode = normalizeDashboardOneMillionMode(oneMModeEntry?.value)
+                ?? legacyMode
+                ?? 'auto';
+            const source = oneMModeEntry?.source !== 'default'
+                ? oneMModeEntry?.source
+                : legacyMode
+                    ? legacyEntry?.source ?? 'default'
+                    : oneMModeEntry?.source ?? 'default';
+            const summary = mode === 'off'
+                ? 'Recovery mode: all models stay on standard 200K context.'
+                : mode === 'on'
+                    ? 'Forced 1M: Sonnet and Pro subscriptions may require Claude Extra Usage.'
+                    : 'Smart auto: Opus can use included 1M on eligible Max/Team/Enterprise accounts; Sonnet stays on 200K.';
+            const relevantKeys = new Set([
+                'BUDGET_CHAT_USD',
+                'BUDGET_HEARTBEAT_USD',
+                'BUDGET_CRON_T1_USD',
+                'BUDGET_CRON_T2_USD',
+                'CLEMENTINE_1M_CONTEXT_MODE',
+                'CLAUDE_CODE_DISABLE_1M_CONTEXT',
+            ]);
+            const findings = doctor.findings
+                .filter(f => (f.key && relevantKeys.has(f.key)) || /budget|credit|1m|context/i.test(f.message))
+                .slice(0, 8);
+            res.json({
+                ok: true,
+                baseDir: cfg.baseDir,
+                budgets: DASHBOARD_BUDGET_ROWS.map(row => {
+                    const entry = byKey.get(row.key);
+                    return {
+                        label: row.label,
+                        hint: row.hint,
+                        key: row.key,
+                        value: entry?.value ?? '',
+                        displayValue: formatDashboardBudgetValue(entry?.value),
+                        source: entry?.source ?? 'unknown',
+                    };
+                }),
+                context: {
+                    mode,
+                    source,
+                    summary,
+                    modeValue: oneMModeEntry?.value ?? 'auto',
+                    legacyValue: legacyEntry?.value ?? '',
+                    legacySource: legacyEntry?.source ?? 'default',
+                    legacyMode,
+                },
+                findings,
+                counts: doctor.counts,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/budgets/set', (req, res) => {
+        try {
+            const body = req.body;
+            const key = String(body?.key ?? '');
+            const result = writeDashboardBudgetCap(key, body?.value);
+            if (!result.ok) {
+                res.status(400).json({ error: result.error });
+                return;
+            }
+            res.json({
+                ok: true,
+                message: `${key} set to ${formatDashboardBudgetValue(result.value)}. Restart Clementine to apply to running workers.`,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/budgets/preset', (req, res) => {
+        try {
+            const preset = String(req.body?.preset ?? '').trim().toLowerCase();
+            let writes;
+            let message;
+            if (preset === 'defaults' || preset === 'standard') {
+                writes = DASHBOARD_BUDGET_ROWS.map(row => ({ key: row.key, value: row.value }));
+                message = 'Restored the standard spend caps. Restart Clementine to apply to running workers.';
+            }
+            else if (preset === 'uncapped' || preset === 'off' || preset === 'none') {
+                writes = DASHBOARD_BUDGET_ROWS.map(row => ({ key: row.key, value: '0' }));
+                message = 'Removed spend caps by setting all budget values to 0. Restart Clementine to apply to running workers.';
+            }
+            else {
+                res.status(400).json({ error: 'preset must be defaults or uncapped' });
+                return;
+            }
+            for (const item of writes) {
+                const result = writeDashboardBudgetCap(item.key, item.value);
+                if (!result.ok) {
+                    res.status(400).json({ error: result.error });
+                    return;
+                }
+            }
+            res.json({ ok: true, message });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/budgets/safe', (_req, res) => {
+        try {
+            for (const item of SAFE_DASHBOARD_BUDGETS) {
+                const result = writeDashboardBudgetCap(item.key, item.value);
+                if (!result.ok) {
+                    res.status(400).json({ error: result.error });
+                    return;
+                }
+            }
+            writeEnvValue('CLEMENTINE_1M_CONTEXT_MODE', 'off');
+            writeEnvValue('CLAUDE_CODE_DISABLE_1M_CONTEXT', '1');
+            process.env.CLEMENTINE_1M_CONTEXT_MODE = 'off';
+            process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
+            res.json({
+                ok: true,
+                message: 'Applied safe budgets and 200K recovery mode. Restart Clementine to apply to running chat workers.',
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/budgets/1m', (req, res) => {
+        try {
+            const mode = normalizeDashboardOneMillionMode(req.body?.mode);
+            if (!mode) {
+                res.status(400).json({ error: 'mode must be auto, off, or on' });
+                return;
+            }
+            writeEnvValue('CLEMENTINE_1M_CONTEXT_MODE', mode);
+            process.env.CLEMENTINE_1M_CONTEXT_MODE = mode;
+            if (mode === 'auto') {
+                deleteEnvValue('CLAUDE_CODE_DISABLE_1M_CONTEXT');
+                delete process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT;
+            }
+            else {
+                const legacyValue = mode === 'on' ? '0' : '1';
+                writeEnvValue('CLAUDE_CODE_DISABLE_1M_CONTEXT', legacyValue);
+                process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT = legacyValue;
+            }
+            const message = mode === 'auto'
+                ? 'Set 1M context to smart auto. Restart Clementine to apply everywhere.'
+                : mode === 'off'
+                    ? 'Disabled 1M context for recovery. Restart Clementine to apply everywhere.'
+                    : 'Forced 1M context on. Sonnet and Pro subscriptions may require Claude Extra Usage.';
+            res.json({ ok: true, message });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
+    app.post('/api/budgets/doctor-fix', async (_req, res) => {
+        try {
+            const { applyDoctorFixes } = await import('../config/config-doctor.js');
+            const result = applyDoctorFixes(BASE_DIR);
+            for (const item of result.changed) {
+                process.env[item.key] = item.value;
+            }
+            const message = result.changed.length
+                ? `Applied ${result.changed.length} config fix${result.changed.length === 1 ? '' : 'es'}. Restart Clementine to apply everywhere.`
+                : 'No budget or context fixes were needed.';
+            res.json({ ok: true, message, result });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err) });
+        }
+    });
     app.get('/api/settings', (_req, res) => {
         try {
             const env = parseEnvFile();
@@ -5739,10 +5989,7 @@ If the tool returns nothing or errors, return an empty array \`[]\`.`,
                 res.status(404).json({ error: '.env file not found' });
                 return;
             }
-            let content = readFileSync(ENV_PATH, 'utf-8');
-            const re = new RegExp(`^${key}=.*\n?`, 'm');
-            content = content.replace(re, '');
-            writeFileSync(ENV_PATH, content);
+            deleteEnvValue(key);
             // Hot-reload mirror of the PUT handler — drop process.env entry +
             // reset Composio client so removal takes effect without a restart.
             if (key === 'COMPOSIO_API_KEY' || key === 'COMPOSIO_USER_ID') {
@@ -15169,6 +15416,7 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
             <p style="color:var(--text-muted);margin:0">Manage API keys and configuration. Changes are saved to <code>~/.clementine/.env</code>.</p>
             <button class="btn-sm" style="white-space:nowrap;background:var(--bg-tertiary);border:1px solid var(--border);color:var(--text-primary);padding:6px 12px;border-radius:6px;cursor:pointer" onclick="restartDashboard()">Restart Dashboard</button>
           </div>
+          <div id="budget-health-content" style="margin-bottom:16px"><div class="empty-state">Loading budget health...</div></div>
           <div id="settings-content"><div class="empty-state">Loading settings...</div></div>
         </div>
         <div class="tab-pane" id="tab-settings-remote">
@@ -19717,8 +19965,153 @@ async function listenToDigest() {
   } catch(e) { toast(String(e), 'error'); }
 }
 
+async function refreshBudgetHealth() {
+  var container = document.getElementById('budget-health-content');
+  if (!container) return;
+  try {
+    var r = await apiFetch('/api/budgets');
+    var d = await r.json();
+    if (!d.ok) {
+      container.innerHTML = '<div class="empty-state" style="color:var(--red)">Failed to load budget health: ' + esc(d.error || 'Unknown error') + '</div>';
+      return;
+    }
+    var context = d.context || {};
+    var mode = context.mode || 'auto';
+    var modeClass = mode === 'off' ? 'badge-green' : mode === 'on' ? 'badge-yellow' : 'badge-blue';
+    var rows = d.budgets || [];
+    var findings = d.findings || [];
+    var html = '<div class="card">'
+      + '<div class="card-header" style="display:flex;align-items:center;justify-content:space-between;gap:12px">'
+      + '<div style="display:flex;align-items:center;gap:8px"><span>Spend Guards &amp; Context Health</span><span class="badge ' + modeClass + '" style="font-size:10px">1M ' + esc(mode) + '</span></div>'
+      + '<div style="display:flex;gap:6px;flex-wrap:wrap;justify-content:flex-end">'
+      + '<button class="btn-sm btn-primary" onclick="applySafeBudgetPreset()">Safe Recovery</button>'
+      + '<button class="btn-sm" onclick="applyBudgetPreset(\\x27defaults\\x27)">Default Caps</button>'
+      + '<button class="btn-sm" onclick="applyBudgetPreset(\\x27uncapped\\x27)">No Caps</button>'
+      + '<button class="btn-sm" onclick="setBudgetContextMode(\\x27auto\\x27)">Smart Auto</button>'
+      + '<button class="btn-sm" onclick="setBudgetContextMode(\\x27off\\x27)">Force 200K</button>'
+      + '<button class="btn-sm" onclick="forceBudgetOneMillion()">Force 1M</button>'
+      + '<button class="btn-sm" onclick="applyBudgetDoctorFix()">Doctor Fix</button>'
+      + '</div></div>'
+      + '<div class="card-body" style="padding:16px">';
+    html += '<div style="font-size:12px;color:var(--text-secondary);margin-bottom:12px">Spend guards are per-run dollar caps. They prevent runaway background work, but setting a cap to 0 removes that guard.</div>';
+    html += '<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(210px,1fr));gap:10px;margin-bottom:12px">';
+    for (var i = 0; i < rows.length; i++) {
+      var row = rows[i];
+      var inputId = 'budget-cap-' + String(row.key).replace(/[^A-Za-z0-9_-]/g, '-');
+      var rawValue = Number(row.value);
+      var inputValue = Number.isFinite(rawValue) ? String(rawValue) : '';
+      html += '<div style="border:1px solid var(--border);border-radius:8px;padding:10px;background:var(--bg-secondary)">'
+        + '<div style="display:flex;justify-content:space-between;gap:8px;align-items:flex-start">'
+        + '<div><div style="font-size:11px;color:var(--text-muted);text-transform:uppercase;letter-spacing:0">' + esc(row.label) + '</div>'
+        + '<div style="font-size:11px;color:var(--text-muted);margin-top:2px">' + esc(row.hint || row.key) + '</div></div>'
+        + '<span class="badge badge-gray" style="font-size:10px">' + esc(row.source || 'unknown') + '</span>'
+        + '</div>'
+        + '<div style="display:flex;gap:6px;align-items:center;margin-top:10px">'
+        + '<span style="font-size:13px;color:var(--text-muted)">$</span>'
+        + '<input id="' + inputId + '" type="number" min="0" step="0.05" value="' + esc(inputValue) + '" data-budget-key="' + esc(row.key) + '"'
+        + ' style="flex:1;min-width:0;padding:6px 8px;border:1px solid var(--border);border-radius:4px;background:var(--bg-primary);color:var(--text-primary);font-size:13px">'
+        + '<button class="btn-sm" onclick="saveBudgetCap(\\x27' + esc(row.key) + '\\x27)">Save</button>'
+        + '</div>'
+        + '<div style="font-size:11px;color:var(--text-muted);margin-top:6px">' + esc(row.key) + ' - ' + esc(row.displayValue || row.value || '') + '</div>'
+        + '</div>';
+    }
+    html += '</div>';
+    html += '<div style="display:flex;gap:10px;align-items:flex-start;flex-wrap:wrap;margin-bottom:12px">'
+      + '<div style="flex:1;min-width:240px;border:1px solid var(--border);border-radius:8px;padding:10px;background:var(--bg-primary)">'
+      + '<div style="font-weight:600;font-size:13px">1M context mode</div>'
+      + '<div style="font-size:12px;color:var(--text-secondary);margin-top:4px">' + esc(context.summary || '') + '</div>'
+      + '<div style="font-size:11px;color:var(--text-muted);margin-top:6px">Source: ' + esc(context.source || 'default')
+      + (context.legacyValue ? ' | legacy CLAUDE_CODE_DISABLE_1M_CONTEXT=' + esc(context.legacyValue) + ' from ' + esc(context.legacySource || 'default') : '')
+      + '</div></div>'
+      + '<div style="flex:1;min-width:240px;border:1px solid var(--border);border-radius:8px;padding:10px;background:var(--bg-primary)">'
+      + '<div style="font-weight:600;font-size:13px">What this protects</div>'
+      + '<div style="font-size:12px;color:var(--text-secondary);margin-top:4px">Safe Recovery lowers autonomous spend and disables 1M context for accounts seeing credit or entitlement errors.</div>'
+      + '<div style="font-size:11px;color:var(--text-muted);margin-top:6px">Restart the daemon after changing budgets or context mode.</div>'
+      + '</div></div>';
+    if (findings.length) {
+      html += '<div style="border-top:1px solid var(--border);padding-top:10px">'
+        + '<div style="font-weight:600;font-size:13px;margin-bottom:6px">Potential causes</div>';
+      for (var j = 0; j < findings.length; j++) {
+        var f = findings[j];
+        var cls = f.severity === 'error' ? 'badge-red' : f.severity === 'warning' ? 'badge-yellow' : 'badge-gray';
+        html += '<div style="display:flex;gap:8px;align-items:flex-start;padding:6px 0;border-bottom:1px solid rgba(127,127,127,0.12)">'
+          + '<span class="badge ' + cls + '" style="font-size:10px;min-width:54px;text-align:center">' + esc(f.severity || 'info') + '</span>'
+          + '<div style="font-size:12px;color:var(--text-secondary);line-height:1.4">'
+          + (f.key ? '<code>' + esc(f.key) + '</code>: ' : '') + esc(f.message || '')
+          + (f.fix ? '<div style="font-size:11px;color:var(--text-muted);margin-top:2px">Fix: <code>' + esc(f.fix) + '</code></div>' : '')
+          + '</div></div>';
+      }
+      html += '</div>';
+    } else {
+      html += '<div style="font-size:12px;color:var(--text-muted);border-top:1px solid var(--border);padding-top:10px">No budget or context warnings found.</div>';
+    }
+    html += '</div></div>';
+    container.innerHTML = html;
+  } catch(e) {
+    container.innerHTML = '<div class="empty-state" style="color:var(--red)">Failed to load budget health: ' + esc(String(e)) + '</div>';
+  }
+}
+
+async function postBudgetAction(url, body) {
+  try {
+    var r = await apiFetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body || {}),
+    });
+    var d = await r.json();
+    if (d.ok) toast(d.message || 'Updated', 'success');
+    else toast(d.error || 'Error', 'error');
+    await refreshBudgetHealth();
+    return d;
+  } catch(e) {
+    toast(String(e), 'error');
+    return null;
+  }
+}
+
+async function applySafeBudgetPreset() {
+  await postBudgetAction('/api/budgets/safe', {});
+  refreshSettings();
+}
+
+async function applyBudgetPreset(preset) {
+  if (preset === 'uncapped' && !confirm('Remove all spend caps? Clementine can still hit account limits or credits if a job runs long.')) return;
+  await postBudgetAction('/api/budgets/preset', { preset: preset });
+  refreshSettings();
+}
+
+async function saveBudgetCap(key) {
+  var inputId = 'budget-cap-' + String(key).replace(/[^A-Za-z0-9_-]/g, '-');
+  var input = document.getElementById(inputId);
+  if (!input) return;
+  var value = Number(input.value);
+  if (!Number.isFinite(value) || value < 0) {
+    toast('Budget must be a non-negative dollar amount. Use 0 for no cap.', 'error');
+    return;
+  }
+  await postBudgetAction('/api/budgets/set', { key: key, value: value });
+  refreshSettings();
+}
+
+async function setBudgetContextMode(mode) {
+  await postBudgetAction('/api/budgets/1m', { mode: mode });
+  refreshSettings();
+}
+
+async function forceBudgetOneMillion() {
+  if (!confirm('Force 1M context on? Sonnet and Pro subscriptions may require Claude Extra Usage.')) return;
+  await setBudgetContextMode('on');
+}
+
+async function applyBudgetDoctorFix() {
+  await postBudgetAction('/api/budgets/doctor-fix', {});
+  refreshSettings();
+}
+
 async function refreshSettings() {
   var container = document.getElementById('settings-content');
+  refreshBudgetHealth();
   try {
     var r = await apiFetch('/api/settings');
     var d = await r.json();

package/dist/cli/index.js

@@ -959,6 +959,14 @@ function upsertEnvValue(key, value) {
     // harden-permissions`.
     writeFileSync(ENV_PATH, content, { mode: 0o600 });
 }
+function removeEnvValue(key) {
+    if (!existsSync(ENV_PATH))
+        return;
+    const upperKey = key.toUpperCase();
+    const content = readFileSync(ENV_PATH, 'utf-8');
+    const lines = content.split(/\r?\n/).filter(line => !new RegExp(`^${upperKey}=`).test(line));
+    writeFileSync(ENV_PATH, lines.join('\n').trimEnd() + '\n', { mode: 0o600 });
+}
 function cmdConfigSet(key, value) {
     const upperKey = key.toUpperCase();
     upsertEnvValue(upperKey, value);
@@ -1033,8 +1041,27 @@ const BUDGET_ALIASES = {
     'cron-t2': 'BUDGET_CRON_T2_USD',
     t2: 'BUDGET_CRON_T2_USD',
 };
-function isOneMillionContextEnabled(value) {
-    return /^(0|false|no)$/i.test(String(value).trim());
+function normalizeOneMillionCliMode(value) {
+    const v = String(value ?? '').trim().toLowerCase();
+    if (!v)
+        return null;
+    if (v === 'auto')
+        return 'auto';
+    if (['off', 'disable', 'disabled', 'safe', '200k', 'standard'].includes(v))
+        return 'off';
+    if (['on', 'enable', 'enabled', 'yes', 'true', '1'].includes(v))
+        return 'on';
+    return null;
+}
+function legacyDisableToOneMillionCliMode(value) {
+    const v = String(value ?? '').trim().toLowerCase();
+    if (!v)
+        return null;
+    if (['1', 'true', 'yes', 'on'].includes(v))
+        return 'off';
+    if (['0', 'false', 'no', 'off'].includes(v))
+        return 'on';
+    return null;
 }
 function normalizeBudgetKey(name) {
     const raw = name.trim();
@@ -1084,20 +1111,33 @@ async function cmdBudgetsShow() {
         const source = entry?.source ?? 'unknown';
         console.log(`  ${label.padEnd(12)} ${BOLD}${formatBudgetValue(entry?.value).padEnd(8)}${RESET} ${DIM}${key} from ${source}${RESET}`);
     }
+    const oneMModeEntry = byKey.get('CLEMENTINE_1M_CONTEXT_MODE');
+    const persistedOneMMode = readPersistedEnvValue('CLEMENTINE_1M_CONTEXT_MODE');
+    const oneMMode = normalizeOneMillionCliMode(persistedOneMMode ?? oneMModeEntry?.value)
+        ?? 'auto';
+    const oneMModeSource = persistedOneMMode !== undefined ? '.env' : oneMModeEntry?.source ?? 'default';
     const oneM = byKey.get('CLAUDE_CODE_DISABLE_1M_CONTEXT');
     const persistedOneM = readPersistedEnvValue('CLAUDE_CODE_DISABLE_1M_CONTEXT');
     const oneMValue = persistedOneM ?? oneM?.value;
     const oneMSource = persistedOneM !== undefined ? '.env' : oneM?.source ?? 'unknown';
-    const oneMEnabled = isOneMillionContextEnabled(oneMValue);
+    const legacyMode = legacyDisableToOneMillionCliMode(oneMValue);
     console.log();
-    console.log(`  1M context   ${oneMEnabled ? `${YELLOW}enabled${RESET}` : `${GREEN}disabled${RESET}`} ${DIM}CLAUDE_CODE_DISABLE_1M_CONTEXT=${String(oneMValue ?? '')} from ${oneMSource}${RESET}`);
-    if (oneMEnabled) {
-        console.log(`  ${YELLOW}Note:${RESET} 1M context requires an eligible plan or Claude Extra Usage; accounts without it will fail calls.`);
+    const modeColor = oneMMode === 'off' ? GREEN : oneMMode === 'on' ? YELLOW : BOLD;
+    console.log(`  1M context   ${modeColor}${oneMMode}${RESET} ${DIM}CLEMENTINE_1M_CONTEXT_MODE=${String(persistedOneMMode ?? oneMModeEntry?.value ?? 'auto')} from ${oneMModeSource}${RESET}`);
+    if (legacyMode && oneMModeEntry?.source === 'default') {
+        console.log(`               ${DIM}legacy CLAUDE_CODE_DISABLE_1M_CONTEXT=${String(oneMValue ?? '')} from ${oneMSource} maps to mode=${legacyMode}${RESET}`);
+    }
+    if (oneMMode === 'auto') {
+        console.log(`               ${DIM}allows included Opus 1M on Max/Team/Enterprise; keeps Sonnet on 200K unless mode=on${RESET}`);
+    }
+    else if (oneMMode === 'on') {
+        console.log(`  ${YELLOW}Note:${RESET} forced 1M requires Extra Usage for Sonnet and for Pro subscriptions.`);
     }
     console.log();
     console.log(`  ${DIM}Useful commands:${RESET}`);
-    console.log(`    clementine budgets safe        ${DIM}lower background budgets and disable 1M context${RESET}`);
-    console.log(`    clementine budgets 1m on       ${DIM}enable 1M context for accounts with entitlement/Extra Usage${RESET}`);
+    console.log(`    clementine budgets safe        ${DIM}lower background budgets and force 200K context${RESET}`);
+    console.log(`    clementine budgets 1m auto     ${DIM}allow included Opus 1M, keep Sonnet safe${RESET}`);
+    console.log(`    clementine budgets 1m on       ${DIM}force 1M context for Extra Usage/API users${RESET}`);
     console.log(`    clementine budgets 1m off      ${DIM}disable 1M context for maximum compatibility${RESET}`);
     console.log(`    clementine budgets set chat 10 ${DIM}raise one budget cap${RESET}`);
     console.log();
@@ -1113,6 +1153,7 @@ async function cmdBudgetsSafe() {
     const RESET = '\x1b[0m';
     const writes = [
         ...SAFE_BACKGROUND_BUDGETS,
+        { key: 'CLEMENTINE_1M_CONTEXT_MODE', value: 'off', label: '1M context mode' },
         { key: 'CLAUDE_CODE_DISABLE_1M_CONTEXT', value: '1', label: '1M context disabled' },
     ];
     for (const item of writes) {
@@ -1134,23 +1175,34 @@ function cmdBudgetsOneMillion(mode) {
     const normalized = mode.trim().toLowerCase();
     const on = new Set(['on', 'enable', 'enabled', 'yes', 'true', '1']);
     const off = new Set(['off', 'disable', 'disabled', 'no', 'false', '0']);
-    if (!on.has(normalized) && !off.has(normalized)) {
-        console.error('  Usage: clementine budgets 1m <on|off>');
+    const auto = new Set(['auto', 'smart', 'default']);
+    if (!on.has(normalized) && !off.has(normalized) && !auto.has(normalized)) {
+        console.error('  Usage: clementine budgets 1m <auto|on|off>');
         process.exitCode = 1;
         return;
     }
+    if (auto.has(normalized)) {
+        upsertEnvValue('CLEMENTINE_1M_CONTEXT_MODE', 'auto');
+        removeEnvValue('CLAUDE_CODE_DISABLE_1M_CONTEXT');
+        console.log();
+        console.log('  Set Claude 1M context mode to auto.');
+        console.log('  Opus can use included 1M on Max/Team/Enterprise; Sonnet stays on 200K unless you force mode=on. Restart Clementine to apply.');
+        console.log();
+        return;
+    }
     const enable = on.has(normalized);
+    upsertEnvValue('CLEMENTINE_1M_CONTEXT_MODE', enable ? 'on' : 'off');
     upsertEnvValue('CLAUDE_CODE_DISABLE_1M_CONTEXT', enable ? '0' : '1');
     if (enable) {
         console.log();
-        console.log('  Enabled Claude 1M context for Clementine.');
-        console.log('  Requires an eligible account or Claude Extra Usage; restart Clementine to apply.');
+        console.log('  Forced Claude 1M context on for Clementine.');
+        console.log('  Requires Extra Usage for Sonnet and Pro subscriptions, or API/PAYG billing. Restart Clementine to apply.');
         console.log();
     }
     else {
         console.log();
         console.log('  Disabled Claude 1M context for Clementine.');
-        console.log('  This is the safest default for users without Claude Extra Usage. Restart Clementine to apply.');
+        console.log('  This is the safest recovery mode for users hitting 1M entitlement errors. Restart Clementine to apply.');
         console.log();
     }
 }
@@ -2368,13 +2420,13 @@ budgetsCmd
 });
 budgetsCmd
     .command('safe')
-    .description('Apply the stable local-safe preset: lower background budgets and disable 1M context')
+    .description('Apply the stable local-safe preset: lower background budgets and force 200K context')
     .action(async () => {
     await cmdBudgetsSafe();
 });
 budgetsCmd
     .command('1m <mode>')
-    .description('Toggle Claude 1M context for Clementine (on | off)')
+    .description('Set Claude 1M context mode for Clementine (auto | on | off)')
     .action(cmdBudgetsOneMillion);
 budgetsCmd
     .command('set <name> <value>')

package/dist/config/config-doctor.js

@@ -38,6 +38,7 @@ const NUMERIC_KEYS = new Set([
 const ENUM_KEYS = {
     CLEMENTINE_ADVISOR_RULES_LOADER: ['off', 'shadow', 'primary'],
     DEFAULT_MODEL_TIER: ['haiku', 'sonnet', 'opus'],
+    CLEMENTINE_1M_CONTEXT_MODE: ['auto', 'off', 'on'],
     WEBHOOK_ENABLED: ['true', 'false'],
     ALLOW_ALL_USERS: ['true', 'false'],
     CLEMENTINE_ALLOW_SOURCE_EDITS: ['true', 'false', '1', '0', 'yes', 'no'],
@@ -109,9 +110,11 @@ export function applyDoctorFixes(baseDir) {
         }
         changed.push({ key, value, reason });
     };
+    const oneMMode = byKey.get('CLEMENTINE_1M_CONTEXT_MODE');
     const oneM = byKey.get('CLAUDE_CODE_DISABLE_1M_CONTEXT');
-    if (oneM && isFalseyToggle(oneM.value)) {
-        setSafeValue('CLAUDE_CODE_DISABLE_1M_CONTEXT', '1', 'Disable Claude Code 1M context beta unless the account explicitly has Extra Usage.');
+    if ((oneMMode && String(oneMMode.value).toLowerCase() === 'on') || (oneM && isFalseyToggle(oneM.value))) {
+        setSafeValue('CLEMENTINE_1M_CONTEXT_MODE', 'off', 'Force standard 200K context until the account is confirmed stable.');
+        setSafeValue('CLAUDE_CODE_DISABLE_1M_CONTEXT', '1', 'Disable Claude Code 1M context for backward compatibility with older Claude Code versions.');
     }
     for (const [key, recommended] of Object.entries(SAFE_BACKGROUND_DEFAULTS)) {
         const entry = byKey.get(key);
@@ -273,16 +276,28 @@ function checkRangeSanity(cfg, findings) {
 function checkOperationalOverrides(cfg, baseDir, findings) {
     const byKey = new Map(cfg.entries.map(e => [e.key, e]));
     const persistedEnv = readEnvValues(baseDir);
+    const oneMMode = byKey.get('CLEMENTINE_1M_CONTEXT_MODE');
+    if (oneMMode && oneMMode.source !== 'default' && String(oneMMode.value).toLowerCase() === 'on') {
+        findings.push({
+            severity: 'warning',
+            key: 'CLEMENTINE_1M_CONTEXT_MODE',
+            message: `1M context is forced on from ${oneMMode.source}. Sonnet 1M requires Claude Extra Usage, and Pro subscriptions require Extra Usage for both Sonnet and Opus 1M.`,
+            fix: 'clementine budgets 1m auto   # smart mode, or clementine budgets safe for recovery',
+        });
+    }
     const oneM = byKey.get('CLAUDE_CODE_DISABLE_1M_CONTEXT');
-    if (oneM && oneM.source !== 'default' && isFalseyToggle(oneM.value)) {
+    if (oneM
+        && oneM.source !== 'default'
+        && isFalseyToggle(oneM.value)
+        && (!oneMMode || oneMMode.source === 'default')) {
         const source = oneM.source === 'process.env' && persistedEnv.CLAUDE_CODE_DISABLE_1M_CONTEXT !== undefined
             ? '.env'
             : oneM.source;
         findings.push({
             severity: 'warning',
             key: 'CLAUDE_CODE_DISABLE_1M_CONTEXT',
-            message: `1M context is explicitly enabled from ${source}. Accounts without Claude Extra Usage will fail every call with "Extra usage is required for 1M context."`,
-            fix: 'clementine config doctor --fix   # sets CLAUDE_CODE_DISABLE_1M_CONTEXT=1',
+            message: `Legacy 1M context is explicitly enabled from ${source}. Sonnet 1M requires Extra Usage and can fail calls with "Extra usage is required for 1M context."`,
+            fix: 'clementine budgets 1m auto   # smart mode, or clementine budgets safe for recovery',
         });
     }
     for (const [key, recommended] of Object.entries(SAFE_BACKGROUND_DEFAULTS)) {

package/dist/config/effective-config.js

@@ -30,7 +30,8 @@ const SPECS = [
     { key: 'HAIKU_MODEL', group: 'models', jsonPath: 'models.haiku', default: 'claude-haiku-4-5-20251001' },
     { key: 'SONNET_MODEL', group: 'models', jsonPath: 'models.sonnet', default: 'claude-sonnet-4-6' },
     { key: 'OPUS_MODEL', group: 'models', jsonPath: 'models.opus', default: 'claude-opus-4-7' },
-    { key: 'CLAUDE_CODE_DISABLE_1M_CONTEXT', group: 'models', default: true },
+    { key: 'CLEMENTINE_1M_CONTEXT_MODE', group: 'models', default: 'auto' },
+    { key: 'CLAUDE_CODE_DISABLE_1M_CONTEXT', group: 'models', default: '' },
     // Team routing
     { key: 'AUTO_DELEGATE_ENABLED', group: 'team', default: false },
     // Budgets

package/dist/config.d.ts

@@ -11,6 +11,12 @@ export declare const PKG_DIR: string;
 /** Data home — user data, vault, .env, logs, sessions. */
 export declare const BASE_DIR: string;
 import { shellEscape as _shellEscape } from './config/env-parser.js';
+export type OneMillionContextMode = 'auto' | 'off' | 'on';
+export declare const CLEMENTINE_1M_CONTEXT_MODE: OneMillionContextMode;
+export declare function currentOneMillionContextMode(): OneMillionContextMode;
+export declare function claudeCodeDisableOneMillionForModel(model: string | null | undefined, mode?: OneMillionContextMode): '1' | '0' | undefined;
+export declare function normalizeClaudeModelForOneMillionContext(model: string, mode?: OneMillionContextMode): string;
+export declare function usesOneMillionContext(model: string | null | undefined, mode?: OneMillionContextMode): boolean;
 /**
  * Look up a config value: local .env first, then process.env fallback.
  * Keychain refs in either source are resolved lazily; failed resolution

package/dist/config.js

@@ -27,31 +27,84 @@ function readEnvFile() {
     return parseEnvText(readFileSync(envPath, 'utf-8'));
 }
 const env = readEnvFile();
-// ── Claude Code CLI runtime env propagation ─────────────────────────
-//
-// The Claude Code CLI binary bundled inside @anthropic-ai/claude-agent-sdk
-// auto-attaches the `context-1m-2025-08-07` beta header for any model that
-// supports a 1M context (Sonnet 4.6, Opus 4.6/4.7, etc.). On accounts
-// without the "extra usage" entitlement, every API call then fails with
-// "Extra usage is required for 1M context."
-//
-// We don't ask for 1M anywhere in our code, but the CLI does on its own.
-// The CLI honors CLAUDE_CODE_DISABLE_1M_CONTEXT — when truthy, the auto-
-// enable path is skipped and the standard 200K context is used.
-//
-// Default to disabled here so users without extra usage stop hitting the
-// gate. Anyone who has paid for / been entitled to 1M can opt back in by
-// setting CLAUDE_CODE_DISABLE_1M_CONTEXT=0 in their .env.
-{
-    const userPref = env['CLAUDE_CODE_DISABLE_1M_CONTEXT'] ?? process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT;
-    if (userPref === undefined || userPref === '') {
-        process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
-    }
-    else {
-        // Propagate the user's explicit choice from .env into process.env so the
-        // spawned CLI subprocess inherits it.
-        process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT = userPref;
-    }
+function normalizeOneMillionContextMode(value) {
+    const v = String(value ?? '').trim().toLowerCase();
+    if (!v)
+        return null;
+    if (v === 'auto')
+        return 'auto';
+    if (['off', 'disable', 'disabled', 'safe', '200k', 'standard'].includes(v))
+        return 'off';
+    if (['on', 'enable', 'enabled', 'yes', 'true', '1'].includes(v))
+        return 'on';
+    return null;
+}
+function legacyDisableToOneMillionContextMode(value) {
+    const v = String(value ?? '').trim().toLowerCase();
+    if (!v)
+        return null;
+    if (['1', 'true', 'yes', 'on'].includes(v))
+        return 'off';
+    if (['0', 'false', 'no', 'off'].includes(v))
+        return 'on';
+    return null;
+}
+const oneMillionModePref = env['CLEMENTINE_1M_CONTEXT_MODE'] ?? process.env.CLEMENTINE_1M_CONTEXT_MODE;
+const legacyOneMillionPref = env['CLAUDE_CODE_DISABLE_1M_CONTEXT'] ?? process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT;
+export const CLEMENTINE_1M_CONTEXT_MODE = normalizeOneMillionContextMode(oneMillionModePref)
+    ?? legacyDisableToOneMillionContextMode(legacyOneMillionPref)
+    ?? 'auto';
+if (CLEMENTINE_1M_CONTEXT_MODE === 'off') {
+    process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '1';
+}
+else if (CLEMENTINE_1M_CONTEXT_MODE === 'on') {
+    process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT = '0';
+}
+else if (oneMillionModePref !== undefined) {
+    // Explicit auto mode should override stale shell/package env inherited from
+    // older installs. Per-query SDK options decide whether to disable 1M.
+    delete process.env.CLAUDE_CODE_DISABLE_1M_CONTEXT;
+}
+function modelFamily(model) {
+    const m = String(model ?? '').toLowerCase();
+    if (m.includes('opusplan'))
+        return 'opusplan';
+    if (m.includes('opus'))
+        return 'opus';
+    if (m.includes('sonnet'))
+        return 'sonnet';
+    if (m.includes('haiku'))
+        return 'haiku';
+    return 'other';
+}
+export function currentOneMillionContextMode() {
+    return normalizeOneMillionContextMode(process.env.CLEMENTINE_1M_CONTEXT_MODE)
+        ?? CLEMENTINE_1M_CONTEXT_MODE;
+}
+export function claudeCodeDisableOneMillionForModel(model, mode = currentOneMillionContextMode()) {
+    if (mode === 'off')
+        return '1';
+    if (mode === 'on')
+        return '0';
+    return modelFamily(model) === 'opus' ? undefined : '1';
+}
+export function normalizeClaudeModelForOneMillionContext(model, mode = currentOneMillionContextMode()) {
+    if (mode === 'on')
+        return model;
+    const family = modelFamily(model);
+    const shouldStrip = mode === 'off'
+        || family === 'sonnet'
+        || family === 'haiku'
+        || family === 'opusplan';
+    return shouldStrip ? model.replace(/\[1m\]/ig, '') : model;
+}
+export function usesOneMillionContext(model, mode = currentOneMillionContextMode()) {
+    if (mode === 'off')
+        return false;
+    const family = modelFamily(model);
+    if (mode === 'on')
+        return family === 'opus' || family === 'sonnet';
+    return family === 'opus';
 }
 // ── Keychain-ref resolution (lazy, cached) ──────────────────────────
 //

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.14",
+  "version": "1.18.16",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",